@grain/stdlib 0.6.6 → 0.7.0

package/number.gr

@@ -48,6 +48,8 @@ from "runtime/atoi/parse" include Parse as Atoi
 from "runtime/atof/parse" include Parse as Atof
 from "runtime/unsafe/tags" include Tags
 from "runtime/exception" include Exception
+from "runtime/math/trig" include Trig
+use Trig.{ sin, cos, tan }
 
 use Atoi.{ type ParseIntError }
 
@@ -551,8 +553,8 @@ provide let isClose = (a, b, relativeTolerance=1e-9, absoluteTolerance=0.0) => {
   if (a == b) {
     true
   } else if (isFinite(a) && isFinite(b)) {
-    abs(a - b) <=
-      max(relativeTolerance * max(abs(a), abs(b)), absoluteTolerance)
+    abs(a - b)
+      <= max(relativeTolerance * max(abs(a), abs(b)), absoluteTolerance)
   } else {
     // NaN and infinities which were not equal
     false
@@ -659,28 +661,6 @@ provide let parse = input => {
   }
 }
 
-/**
- * Computes how many times pi has to be subtracted to achieve the required bounds for sin.
- */
-let reduceToPiBound = (radians: Number) => {
-  floor(radians / pi)
-}
-
-/**
- * Computes the sine of a number using Chebyshev polynomials. Requires the input to be bounded to (-pi, pi). More information on the algorithm can be found here: http://mooooo.ooo/chebyshev-sine-approximation/.
- */
-let chebyshevSine = (radians: Number) => {
-  let pi_minor = -0.00000008742278
-  let x2 = radians * radians
-  let p11 = 0.00000000013291342
-  let p9 = p11 * x2 + -0.000000023317787
-  let p7 = p9 * x2 + 0.0000025222919
-  let p5 = p7 * x2 + -0.00017350505
-  let p3 = p5 * x2 + 0.0066208798
-  let p1 = p3 * x2 + -0.10132118
-  (radians - pi - pi_minor) * (radians + pi + pi_minor) * p1 * radians
-}
-
 @unsafe
 let rf = z => {
   // see: musl/src/math/asin.c and SUN COPYRIGHT NOTICE at top of file
@@ -761,8 +741,8 @@ provide let asin = angle => {
       WasmI64.reinterpretF64(s) & 0xFFFFFFFF00000000N
     )
     let c = (z - f * f) / (s + f)
-    x = 0.5W * pio2_hi -
-      (2.0W * s * r - (pio2_lo - 2.0W * c) - (0.5W * pio2_hi - 2.0W * f))
+    x = 0.5W * pio2_hi
+      - (2.0W * s * r - (pio2_lo - 2.0W * c) - (0.5W * pio2_hi - 2.0W * f))
   }
   x = WasmF64.copySign(x, origAngle)
   return WasmI32.toGrain(newFloat64(x)): Number
@@ -1065,10 +1045,159 @@ provide let linearMap = (inputRange, outputRange, current) => {
       throw Exception.InvalidArgument("The outputRange must be finite")
     if (isNaN(outputRange.rangeStart) || isNaN(outputRange.rangeEnd))
       throw Exception.InvalidArgument("The outputRange must not include NaN")
-    let mapped = (current - inputRange.rangeStart) *
-      (outputRange.rangeEnd - outputRange.rangeStart) /
-      (inputRange.rangeEnd - inputRange.rangeStart) +
-      outputRange.rangeStart
+    let mapped = (current - inputRange.rangeStart)
+      * (outputRange.rangeEnd - outputRange.rangeStart)
+      / (inputRange.rangeEnd - inputRange.rangeStart)
+      + outputRange.rangeStart
     clamp(outputRange, mapped)
   }
 }
+
+/**
+ * Computes the sine of a number (in radians).
+ *
+ * @param radians: The input in radians
+ * @returns The computed sine
+ *
+ * @example Number.sin(0) == 0
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let sin = (radians: Number) => {
+  use WasmF64.{ (==) }
+  let xval = coerceNumberToWasmF64(radians)
+  let value = sin(xval)
+  return if (!isFloat(radians) && value == WasmF64.trunc(value)) {
+    WasmI32.toGrain(reducedInteger(WasmI64.truncF64S(value))): Number
+  } else {
+    WasmI32.toGrain(newFloat64(value)): Number
+  }
+}
+
+/**
+ * Computes the cosine of a number (in radians).
+ *
+ * @param radians: The input in radians
+ * @returns The computed cosine
+ *
+ * @example Number.cos(0) == 1
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let cos = (radians: Number) => {
+  use WasmF64.{ (==) }
+  let xval = coerceNumberToWasmF64(radians)
+  let value = cos(xval)
+  return if (!isFloat(radians) && value == WasmF64.trunc(value)) {
+    WasmI32.toGrain(reducedInteger(WasmI64.truncF64S(value))): Number
+  } else {
+    WasmI32.toGrain(newFloat64(value)): Number
+  }
+}
+
+/**
+ * Computes the tangent of a number (in radians).
+ *
+ * @param radians: The input in radians
+ * @returns The computed tangent
+ *
+ * @example Number.tan(0) == 0
+ *
+ * @since v0.7.0
+ */
+@unsafe
+provide let tan = (radians: Number) => {
+  use WasmF64.{ (==) }
+  let xval = coerceNumberToWasmF64(radians)
+  let value = tan(xval)
+  return if (!isFloat(radians) && value == WasmF64.trunc(value)) {
+    WasmI32.toGrain(reducedInteger(WasmI64.truncF64S(value))): Number
+  } else {
+    WasmI32.toGrain(newFloat64(value)): Number
+  }
+}
+
+// Math.gamma implemented using the Lanczos approximation
+// https://en.wikipedia.org/wiki/Lanczos_approximation
+/**
+ * Computes the gamma function of a value using the Lanczos approximation.
+ *
+ * @param z: The value to interpolate
+ * @returns The gamma of the given value
+ *
+ * @example Number.gamma(1) == 1
+ * @example Number.gamma(3) == 2
+ * @example Number.isClose(Number.gamma(0.5), Number.sqrt(Number.pi))
+ *
+ * @since v0.7.0
+ */
+provide let rec gamma = z => {
+  if (z == 0 || isInteger(z) && z < 0) {
+    NaN
+  } else if (isInteger(z) && z > 0) {
+    let mut output = 1
+    for (let mut i = 1; i < z; i += 1) {
+      output *= i
+    }
+    output
+  } else {
+    let mut z = z
+    let g = 7
+    let c = [>
+      0.99999999999980993,
+      676.5203681218851,
+      -1259.1392167224028,
+      771.32342877765313,
+      -176.61502916214059,
+      12.507343278686905,
+      -0.13857109526572012,
+      9.9843695780195716e-6,
+      1.5056327351493116e-7,
+    ]
+    let mut output = 0
+    if (z < 0.5) {
+      output = pi / sin(pi * z) / gamma(1 - z)
+    } else if (z == 0.5) {
+      // Handle this case separately because it is out of the domain of Number.pow when calculating
+      output = 1.7724538509055159
+    } else {
+      z -= 1
+      let mut x = c[0]
+      for (let mut i = 1; i < g + 2; i += 1) {
+        x += c[i] / (z + i)
+      }
+
+      let t = z + g + 0.5
+      output = sqrt(2 * pi) * (t ** (z + 0.5)) * exp(t * -1) * x
+    }
+    if (abs(output) == Infinity) Infinity else output
+  }
+}
+
+/**
+ * Computes the factorial of an integer input or the gamma function of a non-integer input.
+ *
+ * @param n: The value to factorialize
+ * @returns The factorial of the given value
+ *
+ * @throws InvalidArgument(String): When `n` is a negative integer
+ *
+ * @example Number.factorial(0) == 1
+ * @example Number.factorial(3) == 6
+ * @example Number.isClose(Number.factorial(0.5), (1/2) * Number.sqrt(Number.pi))
+ *
+ * @since v0.7.0
+ */
+provide let rec factorial = n => {
+  if (isInteger(n) && n < 0) {
+    gamma(abs(n) + 1) * -1
+  } else if (!isInteger(n) && n < 0) {
+    throw Exception.InvalidArgument(
+      "Cannot compute the factorial of a negative non-integer",
+    )
+  } else {
+    gamma(n + 1)
+  }
+}