functionalscript 0.0.569 → 0.0.571

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.569",
+  "version": "0.0.571",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {
     "tsc": "tsc",

package/types/bigint/README.md

@@ -0,0 +1,35 @@
+# BigInt
+
+Bun has a `bigint` size limitation. It's `1_048_575` bits (`1024 ** 2`) or `131_072` Bytes.
+
+## Benchmarks
+
+### bitLen vs toString(2).length (2024/11/25)
+
+|Framework|bitLen            |toString(2).length|
+|---------|------------------|------------------|
+|Bun      |1.781681          |2.079615          |
+|Deno 1   |0.710344          |1.917003          |
+|Deno 2   |0.986602          |2.286932          |
+|Node 16  |1.521150          |2.330505          |
+|Node 18  |1.393006          |2.312573          |
+|Node 20  |1.055315          |2.320039          |
+|Node 22  |0.983075          |2.336697          |
+|Node 23  |0.699960          |1.872965          |
+
+`bitLen` wins.
+
+### Minus vs Not
+
+|Framework|minus `-`         |not `~`           |
+|---------|------------------|------------------|
+|Bun      |86.269967         | 80.372970        |
+|Deno 1   |18.754810         | 59.498217        |
+|Deno 2   |17.262486         | 57.157273        |
+|Node 16  |70.350582         |121.023162        |
+|Node 18  |61.039463         | 99.369215        |
+|Node 20  |16.908695         | 63.335552        |
+|Node 22  |19.546644         | 59.034978        |
+|Node 23  |18.246697         | 58.825815        |
+
+`-` wins.

package/types/bigint/module.f.cjs

@@ -44,17 +44,61 @@ const scalar_mul = ({ 0: _0, add }) => a => n => {
     }
 }
 
-/** @type {(a: bigint) => bigint} */
-const log2 = a => {
-    // Possible optimization: use a binary search in 32 bit value
-    let i = -1n
-    while (a > 0n) {
-        ++i
-        a >>= 1n
+/**
+ * Calculates the bit length of a given BigInt.
+ *
+ * The bit length of a number is the number of bits required to represent it in binary,
+ * excluding leading zeros. For example:
+ * - `0n` (binary `...0`) has a bit length of 0.
+ * - `1n` (binary `...0_1`) has a bit length of 1.
+ * - `255n` (binary `...0_11111111`) has a bit length of 8.
+ *
+ * Negative inputs are converted to their absolute values before calculation. For example:
+ * - `-255n` has a bit length of 8.
+ * - `-1n` has a bit length of 1.
+ *
+ * @param {bigint} v - The input BigInt. It can be positive, negative, or zero.
+ * @returns {bigint} The bit length of the input BigInt.
+ *
+ * @remarks
+ * This function determines the bit length in two phases:
+ * 1. **Fast Doubling Phase:** Quickly identifies the range of the most significant bit using exponential steps.
+ * 2. **Binary Search Phase:** Refines the result to precisely count all significant bits.
+ *
+ * The algorithm operates with logarithmic complexity, making it efficient for very large BigInts.
+ */
+const bitLen = v => {
+    if (v <= 0n) {
+        if (v === 0n) { return 0n }
+        v = -v
+    }
+    let result = 1n
+    let i = 1n
+    while (true) {
+        const n = v >> i
+        if (n === 0n) {
+            // overshot
+            break
+        }
+        v = n
+        result += i
+        i <<= 1n
+    }
+    // We know that `v` is not 0 so it doesn't make sense to check `n` when `i` is 0.
+    // Because of this, We check if `i` is greater than 1 before we divide it by 2.
+    while (i !== 1n) {
+        i >>= 1n
+        const n = v >> i
+        if (n !== 0n) {
+            result += i
+            v = n
+        }
     }
-    return i
+    return result
 }
 
+const log2 = (/** @type {bigint} */v) => v <= 0n ? -1n : bitLen(v) - 1n
+
 module.exports = {
     /** @readonly */
     addition,
@@ -70,4 +114,6 @@ module.exports = {
     scalar_mul,
     /** @readonly */
     log2,
+    /** @readonly */
+    bitLen,
 }

package/types/bigint/test.f.cjs

@@ -1,4 +1,4 @@
-const { sum, abs, serialize, log2 } = require('./module.f.cjs')
+const { sum, abs, serialize, log2, bitLen } = require('./module.f.cjs')
 
 module.exports = {
     sum: () => {
@@ -69,6 +69,70 @@ module.exports = {
         () => {
             const result = log2(16n)
             if (result !== 4n) { throw result }
+        },
+        () => {
+            // max for Bun (131_072 Bytes)
+            const v = 1_048_575n
+            const result = log2(1n << v)
+            if (result !== v) { throw result }
+        },
+    ],
+    toString2: () => {
+        // max for Bun (131_072 Bytes)
+        const v = 1_048_575n
+        const result = (1n << v).toString(2).length - 1
+        if (result !== 1_048_575) { throw result }
+    },
+    minus: () => {
+        let i = 0n
+        while (i < 1_048_575n) {
+            const s = -i
+            if (i !== -s) { throw [i, s] }
+            i += 1n
         }
-    ]
+    },
+    not: () => {
+        let i = 0n
+        while (i < 1_048_575n) {
+            const s = ~i
+            if (i !== ~s) { throw [i, s] }
+            i += 1n
+        }
+    },
+    bitLen: {
+        0: () => {
+            const s = bitLen(0n)
+            if (s !== 0n) { throw s }
+        },
+        m: () => {
+            let i = 0n
+            while (i < 10_000n) {
+                const s = bitLen(1n << i)
+                if (s !== i + 1n) { throw [s, i] }
+                i += 1n
+            }
+        },
+        big: () => {
+            const s = bitLen(1n << 1_000_000n)
+            if (s !== 1_000_001n) { throw s }
+        },
+        neg: [
+            () => {
+                const s = bitLen(-1n)
+                if (s !== 1n) { throw s }
+            },
+            () => {
+                const s = bitLen(-2n)
+                if (s !== 2n) { throw s }
+            },
+            () => {
+                const s = bitLen(-3n)
+                if (s !== 2n) { throw s }
+            },
+            () => {
+                const s = bitLen(-4n)
+                if (s !== 3n) { throw s }
+            },
+        ]
+    }
 }