@grain/stdlib 0.4.6 → 0.5.2

package/number.gr

@@ -19,6 +19,35 @@ import { parseInt } from "runtime/stringUtils"
 import { newFloat64, newInt64 } from "runtime/dataStructures"
 import Tags from "runtime/unsafe/tags"
 
+/**
+ * @section Constants: Number constant values.
+ */
+
+/**
+ * Pi represented as a Number value.
+ * 
+ * @since v0.5.2
+ */
+export let pi = 3.141592653589793
+
+/**
+ * Tau represented as a Number value.
+ * 
+ * @since v0.5.2
+ */
+export let tau = 6.283185307179586
+
+/**
+ * Euler's number represented as a Number value.
+ * 
+ * @since v0.5.2
+ */
+export let e = 2.718281828459045
+
+/**
+ * @section Operations: Functions for operating on values of the Number type.
+ */
+
 /**
  * Computes the sum of its operands.
  *
@@ -71,19 +100,16 @@ export let div = (/)
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec sqrt = (x: Number) => {
+@unsafe
+export let sqrt = (x: Number) => {
   let xval = coerceNumberToWasmF64(x)
   let x = WasmI32.fromGrain(x)
   let sqrtd = WasmF64.sqrt(xval)
-  let ret = if (!isFloat(x) && WasmF64.eq(sqrtd, WasmF64.trunc(sqrtd))) {
+  if (!isFloat(x) && WasmF64.eq(sqrtd, WasmF64.trunc(sqrtd))) {
     WasmI32.toGrain(reducedInteger(WasmI64.truncF64S(sqrtd))): Number
   } else {
     WasmI32.toGrain(newFloat64(sqrtd)): Number
   }
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(sqrt))
-  ret
 }
 
 /**
@@ -134,14 +160,11 @@ export let max = (x: Number, y: Number) => if (x > y) x else y
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec ceil = (x: Number) => {
+@unsafe
+export let ceil = (x: Number) => {
   let xval = coerceNumberToWasmF64(x)
   let ceiling = WasmI64.truncF64S(WasmF64.ceil(xval))
-  let ret = WasmI32.toGrain(reducedInteger(ceiling)): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(ceil))
-  ret
+  WasmI32.toGrain(reducedInteger(ceiling)): Number
 }
 
 /**
@@ -152,14 +175,11 @@ export let rec ceil = (x: Number) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec floor = (x: Number) => {
+@unsafe
+export let floor = (x: Number) => {
   let xval = coerceNumberToWasmF64(x)
   let floored = WasmI64.truncF64S(WasmF64.floor(xval))
-  let ret = WasmI32.toGrain(reducedInteger(floored)): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(floor))
-  ret
+  WasmI32.toGrain(reducedInteger(floored)): Number
 }
 
 /**
@@ -170,14 +190,11 @@ export let rec floor = (x: Number) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec trunc = (x: Number) => {
+@unsafe
+export let trunc = (x: Number) => {
   let xval = coerceNumberToWasmF64(x)
   let trunced = WasmI64.truncF64S(xval)
-  let ret = WasmI32.toGrain(reducedInteger(trunced)): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(trunc))
-  ret
+  WasmI32.toGrain(reducedInteger(trunced)): Number
 }
 
 /**
@@ -188,14 +205,11 @@ export let rec trunc = (x: Number) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec round = (x: Number) => {
+@unsafe
+export let round = (x: Number) => {
   let xval = coerceNumberToWasmF64(x)
   let rounded = WasmI64.truncF64S(WasmF64.nearest(xval))
-  let ret = WasmI32.toGrain(reducedInteger(rounded)): Number
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(round))
-  ret
+  WasmI32.toGrain(reducedInteger(rounded)): Number
 }
 
 /**
@@ -216,21 +230,21 @@ export let abs = (x: Number) => if (0 > x) x * -1 else x
  *
  * @since v0.4.0
  */
-export let neg = (x: Number) => if (x > 0) x * -1 else x
+export let neg = (x: Number) => x * -1
 
 /**
  * Checks if a number is finite.
  * All values are finite exept for floating point NaN, infinity or negative infinity.
  *
  * @param x: The number to check
- * @returns `true` if the value is finite, otherwise `false`
+ * @returns `true` if the value is finite or `false` otherwise
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec isFinite = (x: Number) => {
+@unsafe
+export let isFinite = (x: Number) => {
   let asPtr = WasmI32.fromGrain(x)
-  let ret = if (isBoxedNumber(asPtr)) {
+  if (isBoxedNumber(asPtr)) {
     // Boxed numbers can have multiple subtypes, of which float32 and float64 can be infinite.
     let tag = WasmI32.load(asPtr, 4n)
     if (WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)) {
@@ -251,9 +265,6 @@ export let rec isFinite = (x: Number) => {
     // Simple numbers are integers and cannot be infinite.
     true
   }
-  Memory.decRef(asPtr)
-  Memory.decRef(WasmI32.fromGrain(isFinite))
-  ret
 }
 
 /**
@@ -265,10 +276,10 @@ export let rec isFinite = (x: Number) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec isNaN = (x: Number) => {
+@unsafe
+export let isNaN = (x: Number) => {
   let asPtr = WasmI32.fromGrain(x)
-  let ret = if (isBoxedNumber(asPtr)) {
+  if (isBoxedNumber(asPtr)) {
     // Boxed numbers can have multiple subtypes, of which float32 and float64 can be NaN.
     let tag = WasmI32.load(asPtr, 4n)
     if (WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)) {
@@ -287,9 +298,6 @@ export let rec isNaN = (x: Number) => {
     // Simple numbers are integers and cannot be NaN.
     false
   }
-  Memory.decRef(asPtr)
-  Memory.decRef(WasmI32.fromGrain(isNaN))
-  ret
 }
 
 /**
@@ -297,16 +305,16 @@ export let rec isNaN = (x: Number) => {
  * Note that this function is not the exact opposite of isFinite(Number) in that it doesn't return true for NaN.
  *
  * @param x: The number to check
- * @returns `true` if the value is infinite, otherwise `false`
+ * @returns `true` if the value is infinite or `false` otherwise
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec isInfinite = (x: Number) => {
+@unsafe
+export let isInfinite = (x: Number) => {
   // The following code is equivalent to (!isFinite(x) && !isNaN(x)),
   // so see those functions to understand what's going on here.
   let asPtr = WasmI32.fromGrain(x)
-  let ret = if (isBoxedNumber(asPtr)) {
+  if (isBoxedNumber(asPtr)) {
     let tag = WasmI32.load(asPtr, 4n)
     if (WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)) {
       let wf64 = WasmF64.load(asPtr, 8n)
@@ -320,24 +328,73 @@ export let rec isInfinite = (x: Number) => {
   } else {
     false
   }
-  Memory.decRef(asPtr)
-  Memory.decRef(WasmI32.fromGrain(isInfinite))
-  ret
 }
 
 /**
  * Parses a string representation of an integer into a `Number` using the
  * specified radix (also known as a number system "base").
- * 
+ *
  * If the string has a radix prefix (i.e. "0x"/"0X", "0o"/"0O", or "0b"/"0B"
  * for radixes 16, 8, or 2 respectively), the supplied radix is ignored in
  * favor of the prefix. Underscores that appear in the numeric portion of the
  * input are ignored.
- * 
+ *
  * @param input: The string to parse
  * @param radix: The number system base to use when parsing the input string
  * @returns `Ok(value)` containing the parsed number on a successful parse or `Err(msg)` containing an error message string otherwise
- * 
+ *
  * @since v0.4.5
  */
 export parseInt
+
+/**
+ * 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
+}
+
+/**
+ * Computes the sine of a number (in radians) using Chebyshev polynomials.
+ *
+ * @param radians: The input in radians
+ * @returns The computed sine
+ *
+ * @since v0.5.2
+ */
+export let sin = (radians: Number) => {
+  let quot = reduceToPiBound(radians)
+  let bounded = radians - pi * quot
+  if (quot % 2 == 0) {
+    chebyshevSine(bounded)
+  } else {
+    neg(chebyshevSine(bounded))
+  }
+}
+
+/**
+ * Computes the cosine of a number (in radians) using Chebyshev polynomials.
+ *
+ * @param radians: The input in radians
+ * @returns The computed cosine
+ *
+ * @since v0.5.2
+ */
+export let cos = (radians: Number) => {
+  sin(pi / 2 + radians)
+}

package/number.md

@@ -13,6 +13,53 @@ No other changes yet.
 import Number from "number"
 ```
 
+## Constants
+
+Number constant values.
+
+### Number.**pi**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+pi : Number
+```
+
+Pi represented as a Number value.
+
+### Number.**tau**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+tau : Number
+```
+
+Tau represented as a Number value.
+
+### Number.**e**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+e : Number
+```
+
+Euler's number represented as a Number value.
+
+## Operations
+
+Functions for operating on values of the Number type.
+
 ### Number.**add**
 
 <details disabled>
@@ -402,7 +449,7 @@ Returns:
 
 |type|description|
 |----|-----------|
-|`Bool`|`true` if the value is finite, otherwise `false`|
+|`Bool`|`true` if the value is finite or `false` otherwise|
 
 ### Number.**isNaN**
 
@@ -454,12 +501,12 @@ Returns:
 
 |type|description|
 |----|-----------|
-|`Bool`|`true` if the value is infinite, otherwise `false`|
+|`Bool`|`true` if the value is infinite or `false` otherwise|
 
 ### Number.**parseInt**
 
 <details disabled>
-<summary tabindex="-1">Added in <code>next</code></summary>
+<summary tabindex="-1">Added in <code>0.4.5</code></summary>
 No other changes yet.
 </details>
 
@@ -488,3 +535,53 @@ Returns:
 |----|-----------|
 |`Result<Number, String>`|`Ok(value)` containing the parsed number on a successful parse or `Err(msg)` containing an error message string otherwise|
 
+### Number.**sin**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+sin : Number -> Number
+```
+
+Computes the sine of a number (in radians) using Chebyshev polynomials.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`radians`|`Number`|The input in radians|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Number`|The computed sine|
+
+### Number.**cos**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+cos : Number -> Number
+```
+
+Computes the cosine of a number (in radians) using Chebyshev polynomials.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`radians`|`Number`|The input in radians|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Number`|The computed cosine|
+

package/option.md

@@ -533,7 +533,7 @@ No other changes yet.
 </details>
 
 ```grain
-( or ) : (Option<a>, Option<a>) -> Option<a>
+or : (Option<a>, Option<a>) -> Option<a>
 ```
 
 Behaves like a logical OR (`||`) where the first Option is only returned if it is the `Some` variant and falling back to the second Option in all other cases.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grain/stdlib",
-  "version": "0.4.6",
+  "version": "0.5.2",
   "description": "The standard library for the Grain language.",
   "license": "MIT",
   "homepage": "https://grain-lang.org",
@@ -18,7 +18,7 @@
     "directory": "stdlib"
   },
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   },
   "main": "index.js",
   "files": [
@@ -27,7 +27,7 @@
     "index.js"
   ],
   "scripts": {
-    "clean": "del-cli '**/*.wasm' '**/*.wat' '**/*.modsig'"
+    "clean": "del-cli \"**/*.wasm\" \"**/*.wat\" \"**/*.modsig\""
   },
   "dependencies": {},
   "devDependencies": {