@grain/stdlib 0.6.6 → 0.7.1

package/marshal.gr

@@ -75,8 +75,8 @@ let rec size = (value, acc, valuesSeen, toplevel) => {
       }
       let heapPtr = value
       match (load(heapPtr, 0n)) {
-        t when t == Tags._GRAIN_STRING_HEAP_TAG ||
-          t == Tags._GRAIN_BYTES_HEAP_TAG => {
+        t when t == Tags._GRAIN_STRING_HEAP_TAG
+          || t == Tags._GRAIN_BYTES_HEAP_TAG => {
           acc + roundTo8(8n + load(heapPtr, 4n))
         },
         t when t == Tags._GRAIN_ADT_HEAP_TAG => {
@@ -142,27 +142,27 @@ let rec size = (value, acc, valuesSeen, toplevel) => {
         t when t == Tags._GRAIN_BOXED_NUM_HEAP_TAG => {
           let tag = load(heapPtr, 4n)
           match (tag) {
-            t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG ||
-              t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => {
+            t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG
+              || t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => {
               acc + 16n
             },
             t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
               acc + 16n + load(heapPtr, 8n) * 8n
             },
             t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => {
-              acc +
-                16n +
-                size(load(value, 8n), 0n, valuesSeen, false) +
-                size(load(value, 12n), 0n, valuesSeen, false)
+              acc
+                + 16n
+                + size(load(value, 8n), 0n, valuesSeen, false)
+                + size(load(value, 12n), 0n, valuesSeen, false)
             },
             _ => {
               fail "Unknown number type"
             },
           }
         },
-        t when t == Tags._GRAIN_INT32_HEAP_TAG ||
-          t == Tags._GRAIN_FLOAT32_HEAP_TAG ||
-          t == Tags._GRAIN_UINT32_HEAP_TAG => {
+        t when t == Tags._GRAIN_INT32_HEAP_TAG
+          || t == Tags._GRAIN_FLOAT32_HEAP_TAG
+          || t == Tags._GRAIN_UINT32_HEAP_TAG => {
           acc + 8n
         },
         t when t == Tags._GRAIN_UINT64_HEAP_TAG => {
@@ -386,9 +386,9 @@ let rec marshalHeap = (heapPtr, buf, offset, valuesSeen) => {
         },
       }
     },
-    t when t == Tags._GRAIN_INT32_HEAP_TAG ||
-      t == Tags._GRAIN_FLOAT32_HEAP_TAG ||
-      t == Tags._GRAIN_UINT32_HEAP_TAG => {
+    t when t == Tags._GRAIN_INT32_HEAP_TAG
+      || t == Tags._GRAIN_FLOAT32_HEAP_TAG
+      || t == Tags._GRAIN_UINT32_HEAP_TAG => {
       Memory.copy(buf + offset, heapPtr, 8n)
       offset + 8n
     },
@@ -449,11 +449,11 @@ let reportError = (message, offset) => {
 @unsafe
 let validateStack = (value, offset) => {
   match (value) {
-    _ when value == fromGrain(true) ||
-      value == fromGrain(false) ||
-      value == fromGrain(void) ||
-      (value & Tags._GRAIN_NUMBER_TAG_MASK) == Tags._GRAIN_NUMBER_TAG_TYPE ||
-      (value & Tags._GRAIN_GENERIC_TAG_MASK) == Tags._GRAIN_SHORTVAL_TAG_TYPE =>
+    _ when value == fromGrain(true)
+      || value == fromGrain(false)
+      || value == fromGrain(void)
+      || (value & Tags._GRAIN_NUMBER_TAG_MASK) == Tags._GRAIN_NUMBER_TAG_TYPE
+      || (value & Tags._GRAIN_GENERIC_TAG_MASK) == Tags._GRAIN_SHORTVAL_TAG_TYPE =>
       None,
     _ => reportError("Unknown value", offset),
   }
@@ -658,9 +658,9 @@ let rec validateHeap = (buf, bufSize, offset, valuesChecked) => {
               None => void,
             }
             if (
-              load(buf, numeratorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG &&
-              load(buf, numeratorOffset + 4n) !=
-                Tags._GRAIN_BIGINT_BOXED_NUM_TAG
+              load(buf, numeratorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG
+              && load(buf, numeratorOffset + 4n)
+                != Tags._GRAIN_BIGINT_BOXED_NUM_TAG
             ) {
               return reportError(
                 "Rational/Number numerator was not in the expected format",
@@ -668,9 +668,9 @@ let rec validateHeap = (buf, bufSize, offset, valuesChecked) => {
               )
             }
             if (
-              load(buf, denominatorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG &&
-              load(buf, denominatorOffset + 4n) !=
-                Tags._GRAIN_BIGINT_BOXED_NUM_TAG
+              load(buf, denominatorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG
+              && load(buf, denominatorOffset + 4n)
+                != Tags._GRAIN_BIGINT_BOXED_NUM_TAG
             ) {
               return reportError(
                 "Rational/Number denominator was not in the expected format",
@@ -682,9 +682,9 @@ let rec validateHeap = (buf, bufSize, offset, valuesChecked) => {
               None => void,
             }
             if (
-              load(buf, numeratorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG &&
-              load(buf, numeratorOffset + 4n) !=
-                Tags._GRAIN_BIGINT_BOXED_NUM_TAG
+              load(buf, numeratorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG
+              && load(buf, numeratorOffset + 4n)
+                != Tags._GRAIN_BIGINT_BOXED_NUM_TAG
             ) {
               return reportError(
                 "Rational/Number numerator was not in the expected format",
@@ -692,9 +692,9 @@ let rec validateHeap = (buf, bufSize, offset, valuesChecked) => {
               )
             }
             let denominatorError = if (
-              load(buf, denominatorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG &&
-              load(buf, denominatorOffset + 4n) !=
-                Tags._GRAIN_BIGINT_BOXED_NUM_TAG
+              load(buf, denominatorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG
+              && load(buf, denominatorOffset + 4n)
+                != Tags._GRAIN_BIGINT_BOXED_NUM_TAG
             ) {
               return reportError(
                 "Rational/Number denominator was not in the expected format",
@@ -754,12 +754,13 @@ let validate = (buf, bufSize) => {
     } else {
       // Handle non-heap values: booleans, chars, void, etc.
       match (value) {
-        _ when value == fromGrain(true) ||
-          value == fromGrain(false) ||
-          value == fromGrain(void) ||
-          (value & Tags._GRAIN_NUMBER_TAG_MASK) == Tags._GRAIN_NUMBER_TAG_TYPE ||
-          (value & Tags._GRAIN_GENERIC_TAG_MASK) ==
-            Tags._GRAIN_SHORTVAL_TAG_TYPE => None,
+        _ when value == fromGrain(true)
+          || value == fromGrain(false)
+          || value == fromGrain(void)
+          || (value & Tags._GRAIN_NUMBER_TAG_MASK)
+            == Tags._GRAIN_NUMBER_TAG_TYPE
+          || (value & Tags._GRAIN_GENERIC_TAG_MASK)
+            == Tags._GRAIN_SHORTVAL_TAG_TYPE => None,
         _ => reportError("Unknown value", 0n),
       }
     }
@@ -1006,9 +1007,9 @@ let rec unmarshalHeap = (buf, offset, valuesUnmarshaled) => {
         },
       }
     },
-    t when t == Tags._GRAIN_INT32_HEAP_TAG ||
-      t == Tags._GRAIN_FLOAT32_HEAP_TAG ||
-      t == Tags._GRAIN_UINT32_HEAP_TAG => {
+    t when t == Tags._GRAIN_INT32_HEAP_TAG
+      || t == Tags._GRAIN_FLOAT32_HEAP_TAG
+      || t == Tags._GRAIN_UINT32_HEAP_TAG => {
       let value = Memory.malloc(8n)
       Memory.copy(value, valuePtr, 8n)
 

package/marshal.md

@@ -37,7 +37,7 @@ No other changes yet.
 </details>
 
 ```grain
-marshal : (value: a) => Bytes
+marshal: (value: a) => Bytes
 ```
 
 Serialize a value into a byte-based representation suitable for transmission
@@ -46,15 +46,15 @@ deserialized at a later time to restore the value.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`value`|`a`|The value to serialize|
+| param   | type | description            |
+| ------- | ---- | ---------------------- |
+| `value` | `a`  | The value to serialize |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Bytes`|A byte-based representation of the value|
+| type    | description                              |
+| ------- | ---------------------------------------- |
+| `Bytes` | A byte-based representation of the value |
 
 Examples:
 
@@ -74,7 +74,7 @@ No other changes yet.
 </details>
 
 ```grain
-unmarshal : (bytes: Bytes) => Result<a, String>
+unmarshal: (bytes: Bytes) => Result<a, String>
 ```
 
 Deserialize the byte-based representation of a value back into an in-memory
@@ -86,15 +86,15 @@ unmarshaled corresponds to the expected type.
 
 Parameters:
 
-|param|type|description|
-|-----|----|-----------|
-|`bytes`|`Bytes`|The data to deserialize|
+| param   | type    | description             |
+| ------- | ------- | ----------------------- |
+| `bytes` | `Bytes` | The data to deserialize |
 
 Returns:
 
-|type|description|
-|----|-----------|
-|`Result<a, String>`|An in-memory value|
+| type                | description        |
+| ------------------- | ------------------ |
+| `Result<a, String>` | An in-memory value |
 
 Examples:
 

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 }
 
@@ -81,7 +83,7 @@ provide let e = 2.718281828459045
  * @returns The sum of the two operands
  *
  * @example
- * from Number use { (+) }
+ * use Number.{ (+) }
  * assert 1 + 2 == 3
  *
  * @since v0.6.0
@@ -97,7 +99,7 @@ provide let (+) = (+)
  * @returns The difference of the two operands
  *
  * @example
- * from Number use { (-) }
+ * use Number.{ (-) }
  * assert 5 - 2 == 3
  *
  * @since v0.6.0
@@ -113,7 +115,7 @@ provide let (-) = (-)
  * @returns The product of the two operands
  *
  * @example
- * from Number use { (*) }
+ * use Number.{ (*) }
  * assert 5 * 4 == 20
  *
  * @since v0.6.0
@@ -129,7 +131,7 @@ provide let (*) = (*)
  * @returns The quotient of the two operands
  *
  * @example
- * from Number use { (/) }
+ * use Number.{ (/) }
  * assert 10 / 2.5 == 4
  *
  * @since v0.6.0
@@ -137,6 +139,22 @@ provide let (*) = (*)
  */
 provide let (/) = (/)
 
+/**
+ * Computes the remainder of the division of the first operand by the second.
+ * The result will have the sign of the second operand.
+ *
+ * @param num1: The first operand
+ * @param num2: The second operand
+ * @returns The modulus of its operands
+ *
+ * @example
+ * use Number.{ (%) }
+ * assert 10 % 3 == 1
+ *
+ * @since v0.7.1
+ */
+provide let (%) = (%)
+
 /**
  * Computes the exponentiation of the given base and power.
  *
@@ -145,7 +163,7 @@ provide let (/) = (/)
  * @returns The base raised to the given power
  *
  * @example
- * from Number use { (**) }
+ * use Number.{ (**) }
  * assert 10 ** 2 == 100
  *
  * @since v0.6.0
@@ -153,6 +171,104 @@ provide let (/) = (/)
  */
 provide let (**) = (**)
 
+/**
+ * Checks if the first value is equal to the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is equal to the second value or `false` otherwise
+ *
+ * @example
+ * use Number.{ (==) }
+ * assert 1 == 1
+ *
+ * @since v0.7.1
+ */
+provide let (==) = Numbers.numberEq
+
+/**
+ * Checks if the first value is equal to the second value.
+ *
+ * @param x: The first value
+ * @param y: The second value
+ * @returns `true` if the first value is equal to the second value or `false` otherwise
+ *
+ * @example
+ * use Number.{ (==) }
+ * assert 1 == 1
+ *
+ * @since v0.7.1
+ */
+provide let (!=) = (x, y) => !Numbers.numberEq(x, y)
+
+/**
+ * Checks if the first value is less than the second value.
+ *
+ * @param num1: The first value
+ * @param num2: The second value
+ * @returns `true` if the first value is less than the second value or `false` otherwise
+ *
+ * @example
+ * use Number.{ (<) }
+ * assert 1 < 5
+ *
+ * @since v0.7.1
+ */
+provide let (<) = (<)
+
+/**
+ * Checks if the first value is greater than the second value.
+ *
+ * @param num1: The first value
+ * @param num2: The second value
+ * @returns `true` if the first value is greater than the second value or `false` otherwise
+ *
+ * @example
+ * use Number.{ (>) }
+ * assert 5 > 1
+ *
+ * @since v0.7.1
+ */
+provide let (>) = (>)
+
+/**
+ * Checks if the first value is less than or equal to the second value.
+ *
+ * @param num1: The first value
+ * @param num2: The second value
+ * @returns `true` if the first value is less than or equal to the second value or `false` otherwise
+ *
+ * @example
+ * use Number.{ (<=) }
+ * assert 1 <= 2
+ * @example
+ * use Number.{ (<=) }
+ * assert 1 <= 1
+ *
+ * @since v0.7.1
+ */
+@unsafe
+provide let (<=) = (<=)
+
+/**
+ * Checks if the first value is greater than or equal to the second value.
+ *
+ * @param num1: The first value
+ * @param num2: The second value
+ * @returns `true` if the first value is greater than or equal to the second value or `false` otherwise
+ *
+ * @example
+ * use Number.{ (>=) }
+ * assert 3 >= 2
+ * @example
+ * use Number.{ (>=) }
+ * assert 1 >= 1
+ *
+ * @since v0.7.1
+ */
+@unsafe
+provide let (>=) = (>=)
+
 /**
  * Computes the exponentiation of Euler's number to the given power.
  *
@@ -551,8 +667,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 +775,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 +855,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 +1159,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)
+  }
+}