Initial project import

tools/v/vlib/math/floor.v

@@ -0,0 +1,165 @@
+module math
+
+// floor returns the greatest integer value less than or equal to x.
+//
+// special cases are:
+// floor(±0) = ±0
+// floor(±inf) = ±inf
+// floor(nan) = nan
+pub fn floor(x f64) f64 {
+	if x == 0 || is_nan(x) || is_inf(x, 0) {
+		return x
+	}
+	if x < 0 {
+		mut d, fract := modf(-x)
+		if fract != 0.0 {
+			d = d + 1
+		}
+		return -d
+	}
+	d, _ := modf(x)
+	return d
+}
+
+// floorf returns the greatest integer value less than or equal to x.
+//
+// special cases are:
+// floor(±0) = ±0
+// floor(±inf) = ±inf
+// floor(nan) = nan
+pub fn floorf(x f32) f32 {
+	// TODO
+	return f32(floor(f64(x)))
+	/*
+	if x == 0 || is_nan(x) || is_inf(x, 0) {
+		return x
+	}
+	if x < 0 {
+		mut d, fract := modf(-x)
+		if fract != 0.0 {
+			d = d + 1
+		}
+		return -d
+	}
+	d, _ := modf(x)
+	return d
+	*/
+}
+
+// ceil returns the least integer value greater than or equal to x.
+//
+// special cases are:
+// ceil(±0) = ±0
+// ceil(±inf) = ±inf
+// ceil(nan) = nan
+pub fn ceil(x f64) f64 {
+	return -floor(-x)
+}
+
+// trunc returns the integer value of x.
+//
+// special cases are:
+// trunc(±0) = ±0
+// trunc(±inf) = ±inf
+// trunc(nan) = nan
+pub fn trunc(x f64) f64 {
+	if x == 0 || is_nan(x) || is_inf(x, 0) {
+		return x
+	}
+	d, _ := modf(x)
+	return d
+}
+
+// round returns the nearest integer, rounding half away from zero.
+//
+// special cases are:
+// round(±0) = ±0
+// round(±inf) = ±inf
+// round(nan) = nan
+pub fn round(x f64) f64 {
+	mut bits := f64_bits(x)
+	mut e_ := (bits >> shift) & mask
+	if e_ < bias {
+		// Round abs(x) < 1 including denormals.
+		bits &= sign_mask // +-0
+		if e_ == bias - 1 {
+			bits |= uvone // +-1
+		}
+	} else if e_ < bias + shift {
+		// Round any abs(x) >= 1 containing a fractional component [0,1).
+		//
+		// Numbers with larger exponents are returned unchanged since they
+		// must be either an integer, infinity, or NaN.
+		half := u64(1) << (shift - 1)
+		e_ -= bias
+		bits += half >> e_
+		bits &= ~(frac_mask >> e_)
+	}
+	return f64_from_bits(bits)
+}
+
+// Returns the rounded float, with sig_digits of precision.
+// i.e `assert round_sig(4.3239437319748394,6) == 4.323944`
+pub fn round_sig(x f64, sig_digits int) f64 {
+	mut ret_str := '${x}'
+
+	match sig_digits {
+		0 { ret_str = '${x:0.0f}' }
+		1 { ret_str = '${x:0.1f}' }
+		2 { ret_str = '${x:0.2f}' }
+		3 { ret_str = '${x:0.3f}' }
+		4 { ret_str = '${x:0.4f}' }
+		5 { ret_str = '${x:0.5f}' }
+		6 { ret_str = '${x:0.6f}' }
+		7 { ret_str = '${x:0.7f}' }
+		8 { ret_str = '${x:0.8f}' }
+		9 { ret_str = '${x:0.9f}' }
+		10 { ret_str = '${x:0.10f}' }
+		11 { ret_str = '${x:0.11f}' }
+		12 { ret_str = '${x:0.12f}' }
+		13 { ret_str = '${x:0.13f}' }
+		14 { ret_str = '${x:0.14f}' }
+		15 { ret_str = '${x:0.15f}' }
+		16 { ret_str = '${x:0.16f}' }
+		else { ret_str = '${x}' }
+	}
+
+	return ret_str.f64()
+}
+
+// round_to_even returns the nearest integer, rounding ties to even.
+//
+// special cases are:
+// round_to_even(±0) = ±0
+// round_to_even(±inf) = ±inf
+// round_to_even(nan) = nan
+pub fn round_to_even(x f64) f64 {
+	mut bits := f64_bits(x)
+	mut e_ := (bits >> shift) & mask
+	if e_ >= bias {
+		// round abs(x) >= 1.
+		// - Large numbers without fractional components, infinity, and nan are unchanged.
+		// - Add 0.499.. or 0.5 before truncating depending on whether the truncated
+		// number is even or odd (respectively).
+		half_minus_ulp := u64(u64(1) << (shift - 1)) - 1
+		e_ -= u64(bias)
+		bits += safe_shift(half_minus_ulp + safe_shift(bits, shift - e_) & 1, e_)
+		bits &= ~safe_shift(frac_mask, e_)
+	} else if e_ == bias - 1 && bits & frac_mask != 0 {
+		// round 0.5 < abs(x) < 1.
+		bits = bits & sign_mask | uvone // +-1
+	} else {
+		// round abs(x) <= 0.5 including denormals.
+		bits &= sign_mask // +-0
+	}
+	return f64_from_bits(bits)
+}
+
+@[inline]
+fn safe_shift(value u64, shift u64) u64 {
+	return if shift > u64(63) {
+		u64(0)
+	} else {
+		value >> shift
+	}
+}