@grain/stdlib 0.6.6 → 0.7.0

package/float64.gr

@@ -12,6 +12,12 @@
  */
 module Float64
 
+from "runtime/unsafe/offsets" include Offsets
+use Offsets.{
+  _FLOAT64_VALUE_OFFSET as _VALUE_OFFSET,
+  _INT64_VALUE_OFFSET,
+  _UINT64_VALUE_OFFSET,
+}
 from "runtime/unsafe/wasmi32" include WasmI32
 from "runtime/unsafe/wasmf64" include WasmF64
 use WasmF64.{ (-), (+), (*), (/), (<), (<=), (>), (>=) }
@@ -23,9 +29,8 @@ use Numbers.{
   coerceNumberToFloat64 as fromNumber,
   coerceFloat64ToNumber as toNumber,
 }
-
-@unsafe
-let _VALUE_OFFSET = 8n
+from "runtime/math/trig" include Trig
+use Trig.{ sin, cos, tan }
 
 /**
  * Infinity represented as a Float64 value.
@@ -68,6 +73,42 @@ provide let e = 2.718281828459045d
 
 provide { fromNumber, toNumber }
 
+/**
+ * Interprets an Int64 as a Float64.
+ *
+ * @param value: The value to convert
+ * @returns The Int64 interpreted as an Float64
+ *
+ * @example assert Float64.reinterpretInt64(4607182418800017408L) == 1.0d
+ * @example assert Float64.reinterpretInt64(-4616189618054758400L) == -1.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let reinterpretInt64 = (value: Int64) => {
+  let x = WasmF64.load(WasmI32.fromGrain(value), _INT64_VALUE_OFFSET)
+  let result = newFloat64(x)
+  WasmI32.toGrain(result): Float64
+}
+
+/**
+ * Interprets an Uint64 as a Float64.
+ *
+ * @param value: The value to convert
+ * @returns The Uint64 interpreted as an Float64
+ *
+ * @example assert Float64.reinterpretUint64(4607182418800017408uL) == 1.0d
+ * @example assert Float64.reinterpretUint64(13830554455654793216uL) == -1.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let reinterpretUint64 = (value: Uint64) => {
+  let x = WasmF64.load(WasmI32.fromGrain(value), _UINT64_VALUE_OFFSET)
+  let result = newFloat64(x)
+  WasmI32.toGrain(result): Float64
+}
+
 /**
  * Computes the sum of its operands.
  *
@@ -156,6 +197,27 @@ provide let (/) = (x: Float64, y: Float64) => {
   WasmI32.toGrain(ptr): Float64
 }
 
+/**
+ * Computes the exponentiation of the given base and power.
+ *
+ * @param base: The base float
+ * @param power: The exponent float
+ * @returns The base raised to the given power
+ *
+ * @example
+ * use Float64.{ (**) }
+ * assert 2.0d ** 2.0d == 4.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let (**) = (base: Float64, power: Float64) => {
+  let basev = WasmF64.load(WasmI32.fromGrain(base), _VALUE_OFFSET)
+  let powerv = WasmF64.load(WasmI32.fromGrain(power), _VALUE_OFFSET)
+  let ptr = newFloat64(Numbers.powf(basev, powerv))
+  WasmI32.toGrain(ptr): Float64
+}
+
 /**
  * Checks if the first value is less than the second value.
  *
@@ -248,6 +310,29 @@ provide let (>=) = (x: Float64, y: Float64) => {
   xv >= yv
 }
 
+/**
+ * Checks if a float is finite.
+ * All values are finite exept for NaN, infinity or negative infinity.
+ *
+ * @param x: The number to check
+ * @returns `true` if the value is finite or `false` otherwise
+ *
+ * @example Float64.isFinite(0.5d)
+ * @example Float64.isFinite(1.0d)
+ * @example Float64.isFinite(Infinityd) == false
+ * @example Float64.isFinite(-Infinityd) == false
+ * @example Float64.isFinite(NaNd) == false
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let isFinite = (x: Float64) => {
+  // uses the fact that all finite floats minus themselves are zero
+  // (NaN - NaN == NaN, inf - inf == NaN,
+  //  -inf - -inf == NaN, inf - -inf == inf, -inf - inf == -inf)
+  x - x == 0.0d
+}
+
 /**
  * Checks if the value is a float NaN value (Not A Number).
  *
@@ -280,6 +365,44 @@ provide let isNaN = (x: Float64) => x != x
  */
 provide let isInfinite = (x: Float64) => x == Infinityd || x == -Infinityd
 
+/**
+ * Returns the smaller of its operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The smaller of the two operands
+ *
+ * @example Float64.min(5.0d, 2.0d) == 2.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let min = (x: Float64, y: Float64) => {
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newFloat64(WasmF64.min(xv, yv))
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * Returns the larger of its operands.
+ *
+ * @param x: The first operand
+ * @param y: The second operand
+ * @returns The larger of the two operands
+ *
+ * @example Float64.max(5.0d, 2.0d) == 5.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let max = (x: Float64, y: Float64) => {
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newFloat64(WasmF64.max(xv, yv))
+  WasmI32.toGrain(ptr): Float64
+}
+
 /**
  * Returns the absolute value. That is, it returns `x` if `x` is positive or zero and the negation of `x` if `x` is negative.
  *
@@ -315,3 +438,197 @@ provide let neg = (x: Float64) => {
   let ptr = newFloat64(WasmF64.neg(xv))
   WasmI32.toGrain(ptr): Float64
 }
+
+/**
+ * Rounds its operand up to the next largest whole value.
+ *
+ * @param x: The operand to ceil
+ * @returns The next largest whole value of the operand
+ *
+ * @example Float64.ceil(5.5d) == 6.0d
+ * @example Float64.ceil(-5.5d) == -5.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let ceil = (x: Float64) => {
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let ptr = newFloat64(WasmF64.ceil(xv))
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * Rounds its operand down to the largest whole value less than the operand.
+ *
+ * @param x: The operand to floor
+ * @returns The previous whole value of the operand
+ *
+ * @example Float64.floor(5.5d) == 5.0d
+ * @example Float64.floor(-5.5d) == -6.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let floor = (x: Float64) => {
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let ptr = newFloat64(WasmF64.floor(xv))
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * Returns the whole value part of its operand, removing any fractional value.
+ *
+ * @param x: The operand to truncate
+ * @returns The whole value part of the operand
+ *
+ * @example Float64.trunc(5.5d) == 5.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let trunc = (x: Float64) => {
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let ptr = newFloat64(WasmF64.trunc(xv))
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * Returns its operand rounded to its nearest integer.
+ *
+ * @param x: The operand to round
+ * @returns The nearest integer to the operand
+ *
+ * @example Float64.round(5.5d) == 6.0d
+ * @example Float64.round(5.4d) == 5.0d
+ * @example Float64.round(-5.5d) == -6.0d
+ * @example Float64.round(-5.4d) == -5.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let round = (x: Float64) => {
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let ptr = newFloat64(WasmF64.nearest(xv))
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * Computes the square root of its operand.
+ *
+ * @param x: The operand to square root
+ * @returns The square root of the operand
+ *
+ * @example Float64.sqrt(25.0d) == 5.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let sqrt = (x: Float64) => {
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let ptr = newFloat64(WasmF64.sqrt(xv))
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * Copys the sign of the second operand to the first operand.
+ *
+ * @param x: The operand to be modify
+ * @param y: The operand to copy the sign from
+ * @returns The first operand with the sign of the second operand
+ *
+ * @example Float64.copySign(2.0d, 1.0d) == 2.0d
+ * @example Float64.copySign(3.0d, -1.0d) == -3.0d
+ * @example Float64.copySign(-5.0d, 1.0d) == 5.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let copySign = (x: Float64, y: Float64) => {
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
+  let ptr = newFloat64(WasmF64.copySign(xv, yv))
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * Determines whether two values are considered close to each other using a relative and absolute tolerance.
+ *
+ * @param a: The first value
+ * @param b: The second value
+ * @param relativeTolerance: The maximum tolerance to use relative to the larger absolute value `a` or `b`
+ * @param absoluteTolerance: The absolute tolerance to use, regardless of the values of `a` or `b`
+ * @returns `true` if the values are considered close to each other or `false` otherwise
+ *
+ * @example Float64.isClose(1.233d, 1.233d)
+ * @example Float64.isClose(1.233d, 1.233000001d)
+ * @example Float64.isClose(8.005d, 8.450d, absoluteTolerance=0.5d)
+ * @example Float64.isClose(4.0d, 4.1d, relativeTolerance=0.025d)
+ * @example Float64.isClose(1.233d, 1.24d) == false
+ * @example Float64.isClose(1.233d, 1.4566d) == false
+ * @example Float64.isClose(8.005d, 8.450d, absoluteTolerance=0.4d) == false
+ * @example Float64.isClose(4.0d, 4.1d, relativeTolerance=0.024d) == false
+ *
+ * @since v0.7.0
+ */
+provide let isClose = (a, b, relativeTolerance=1e-9d, absoluteTolerance=0.0d) => {
+  if (a == b) {
+    true
+  } else if (isFinite(a) && isFinite(b)) {
+    abs(a - b)
+      <= max(relativeTolerance * max(abs(a), abs(b)), absoluteTolerance)
+  } else {
+    // NaN and infinities which were not equal
+    false
+  }
+}
+
+/**
+ * Computes the sine of a float (in radians).
+ *
+ * @param radians: The input in radians
+ * @returns The computed sine
+ *
+ * @example Float64.sin(0.0d) == 0.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let sin = (radians: Float64) => {
+  let xval = WasmF64.load(WasmI32.fromGrain(radians), _VALUE_OFFSET)
+  let value = sin(xval)
+  WasmI32.toGrain(newFloat64(value)): Float64
+}
+
+/**
+ * Computes the cosine of a float (in radians).
+ *
+ * @param radians: The input in radians
+ * @returns The computed cosine
+ *
+ * @example Float64.cos(0.0d) == 1.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let cos = (radians: Float64) => {
+  let xval = WasmF64.load(WasmI32.fromGrain(radians), _VALUE_OFFSET)
+  let value = cos(xval)
+  WasmI32.toGrain(newFloat64(value)): Float64
+}
+
+/**
+ * Computes the tangent of a number (in radians).
+ *
+ * @param radians: The input in radians
+ * @returns The computed tangent
+ *
+ * @example Float64.tan(0.0d) == 0.0d
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let tan = (radians: Float64) => {
+  let xval = WasmF64.load(WasmI32.fromGrain(radians), _VALUE_OFFSET)
+  let value = tan(xval)
+  WasmI32.toGrain(newFloat64(value)): Float64
+}