floor.go

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package math
     6  
     7  // Floor returns the greatest integer value less than or equal to x.
     8  //
     9  // Special cases are:
    10  //	Floor(±0) = ±0
    11  //	Floor(±Inf) = ±Inf
    12  //	Floor(NaN) = NaN
    13  func Floor(x float64) float64 {
    14  	if haveArchFloor {
    15  		return archFloor(x)
    16  	}
    17  	return floor(x)
    18  }
    19  
    20  func floor(x float64) float64 {
    21  	if x == 0 || IsNaN(x) || IsInf(x, 0) {
    22  		return x
    23  	}
    24  	if x < 0 {
    25  		d, fract := Modf(-x)
    26  		if fract != 0.0 {
    27  			d = d + 1
    28  		}
    29  		return -d
    30  	}
    31  	d, _ := Modf(x)
    32  	return d
    33  }
    34  
    35  // Ceil returns the least integer value greater than or equal to x.
    36  //
    37  // Special cases are:
    38  //	Ceil(±0) = ±0
    39  //	Ceil(±Inf) = ±Inf
    40  //	Ceil(NaN) = NaN
    41  func Ceil(x float64) float64 {
    42  	if haveArchCeil {
    43  		return archCeil(x)
    44  	}
    45  	return ceil(x)
    46  }
    47  
    48  func ceil(x float64) float64 {
    49  	return -Floor(-x)
    50  }
    51  
    52  // Trunc returns the integer value of x.
    53  //
    54  // Special cases are:
    55  //	Trunc(±0) = ±0
    56  //	Trunc(±Inf) = ±Inf
    57  //	Trunc(NaN) = NaN
    58  func Trunc(x float64) float64 {
    59  	if haveArchTrunc {
    60  		return archTrunc(x)
    61  	}
    62  	return trunc(x)
    63  }
    64  
    65  func trunc(x float64) float64 {
    66  	if x == 0 || IsNaN(x) || IsInf(x, 0) {
    67  		return x
    68  	}
    69  	d, _ := Modf(x)
    70  	return d
    71  }
    72  
    73  // Round returns the nearest integer, rounding half away from zero.
    74  //
    75  // Special cases are:
    76  //	Round(±0) = ±0
    77  //	Round(±Inf) = ±Inf
    78  //	Round(NaN) = NaN
    79  func Round(x float64) float64 {
    80  	// Round is a faster implementation of:
    81  	//
    82  	// func Round(x float64) float64 {
    83  	//   t := Trunc(x)
    84  	//   if Abs(x-t) >= 0.5 {
    85  	//     return t + Copysign(1, x)
    86  	//   }
    87  	//   return t
    88  	// }
    89  	bits := Float64bits(x)
    90  	e := uint(bits>>shift) & mask
    91  	if e < bias {
    92  		// Round abs(x) < 1 including denormals.
    93  		bits &= signMask // +-0
    94  		if e == bias-1 {
    95  			bits |= uvone // +-1
    96  		}
    97  	} else if e < bias+shift {
    98  		// Round any abs(x) >= 1 containing a fractional component [0,1).
    99  		//
   100  		// Numbers with larger exponents are returned unchanged since they
   101  		// must be either an integer, infinity, or NaN.
   102  		const half = 1 << (shift - 1)
   103  		e -= bias
   104  		bits += half >> e
   105  		bits &^= fracMask >> e
   106  	}
   107  	return Float64frombits(bits)
   108  }
   109  
   110  // RoundToEven returns the nearest integer, rounding ties to even.
   111  //
   112  // Special cases are:
   113  //	RoundToEven(±0) = ±0
   114  //	RoundToEven(±Inf) = ±Inf
   115  //	RoundToEven(NaN) = NaN
   116  func RoundToEven(x float64) float64 {
   117  	// RoundToEven is a faster implementation of:
   118  	//
   119  	// func RoundToEven(x float64) float64 {
   120  	//   t := math.Trunc(x)
   121  	//   odd := math.Remainder(t, 2) != 0
   122  	//   if d := math.Abs(x - t); d > 0.5 || (d == 0.5 && odd) {
   123  	//     return t + math.Copysign(1, x)
   124  	//   }
   125  	//   return t
   126  	// }
   127  	bits := Float64bits(x)
   128  	e := uint(bits>>shift) & mask
   129  	if e >= bias {
   130  		// Round abs(x) >= 1.
   131  		// - Large numbers without fractional components, infinity, and NaN are unchanged.
   132  		// - Add 0.499.. or 0.5 before truncating depending on whether the truncated
   133  		//   number is even or odd (respectively).
   134  		const halfMinusULP = (1 << (shift - 1)) - 1
   135  		e -= bias
   136  		bits += (halfMinusULP + (bits>>(shift-e))&1) >> e
   137  		bits &^= fracMask >> e
   138  	} else if e == bias-1 && bits&fracMask != 0 {
   139  		// Round 0.5 < abs(x) < 1.
   140  		bits = bits&signMask | uvone // +-1
   141  	} else {
   142  		// Round abs(x) <= 0.5 including denormals.
   143  		bits &= signMask // +-0
   144  	}
   145  	return Float64frombits(bits)
   146  }
   147
View as plain text