functionalscript 0.2.0 → 0.2.1

package/out/types/bigfloat/test.f.mjs

@@ -0,0 +1,349 @@
+import * as _ from './module.f.mjs';
+const { decToBin } = _;
+export default {
+    decToBin: [
+        () => {
+            const result = decToBin([0n, 0]);
+            if (result[0] !== 0n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 0) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([0n, 10]);
+            if (result[0] !== 0n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 0) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([0n, -10]);
+            if (result[0] !== 0n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 0) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([1n, 0]);
+            if (result[0] !== 4503599627370496n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== -52) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([1n, 1]);
+            if (result[0] !== 5629499534213120n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== -49) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([1000n, -2]);
+            if (result[0] !== 5629499534213120n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== -49) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([1n, -1]);
+            if (result[0] !== 7205759403792794n) {
+                throw result[0].toString(2);
+            } //+1
+            if (result[1] !== -56) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-1n, 0]);
+            if (result[0] !== -4503599627370496n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== -52) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-1n, 1]);
+            if (result[0] !== -5629499534213120n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== -49) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-1000n, -2]);
+            if (result[0] !== -5629499534213120n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== -49) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-1n, -1]);
+            if (result[0] !== -7205759403792794n) {
+                throw result[0].toString(2);
+            } //+1
+            if (result[1] !== -56) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([9007199254740993n, 0]); //54bits (...0.1)
+            if (result[0] !== 4503599627370496n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 1) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-9007199254740995n, 0]); //54bits (...1.1)
+            if (result[0] !== -4503599627370498n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 1) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-9007199254740993n, 0]); //54bits (...0.1)
+            if (result[0] !== -4503599627370496n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 1) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-9007199254740995n, 0]); //54bits (...1.1)
+            if (result[0] !== -4503599627370498n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 1) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([18014398509481985n, 0]); //55bits (...0.01)
+            if (result[0] !== 4503599627370496n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([18014398509481986n, 0]); //55bits (...0.10)
+            if (result[0] !== 4503599627370496n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([18014398509481990n, 0]); //55bits (...1.10)
+            if (result[0] !== 4503599627370498n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([18014398509481987n, 0]); //55bits (0.11)
+            if (result[0] !== 4503599627370497n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+    ],
+    roundingPositive: [
+        () => {
+            const result = decToBin([288230376151711745n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011001.101
+            // rounding up
+            if (result[0] !== 7205759403792794n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([288230376151711760n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011010.000
+            // rounding down
+            if (result[0] !== 7205759403792794n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([288230376151711780n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011010.100
+            // rounding down (to even)
+            if (result[0] !== 7205759403792794n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([288230376151711781n, -1]);
+            // reminder = 1
+            // m = 11001100110011001100110011001100110011001100110011010.100
+            // rounding up
+            if (result[0] !== 7205759403792795n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([288230376151711785n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011010.101
+            // rounding up
+            if (result[0] !== 7205759403792795n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([288230376151711805n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011011.001
+            // rounding down
+            if (result[0] !== 7205759403792795n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([288230376151711820n, -1]);
+            // reminder = 0
+            // m = 11001100110011001100110011001100110011001100110011011.100
+            // rounding up (to even)
+            if (result[0] !== 7205759403792796n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        }
+    ],
+    roundingNegative: [
+        () => {
+            const result = decToBin([-288230376151711745n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011001.101
+            // rounding down
+            if (result[0] !== -7205759403792794n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-288230376151711760n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011010.000
+            // rounding up
+            if (result[0] !== -7205759403792794n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-288230376151711780n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011010.100
+            // rounding up (to even)
+            if (result[0] !== -7205759403792794n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-288230376151711781n, -1]);
+            // reminder = 1
+            // m = -11001100110011001100110011001100110011001100110011010.100
+            // rounding down
+            if (result[0] !== -7205759403792795n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-288230376151711785n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011010.101
+            // rounding down
+            if (result[0] !== -7205759403792795n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-288230376151711805n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011011.001
+            // rounding up
+            if (result[0] !== -7205759403792795n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        },
+        () => {
+            const result = decToBin([-288230376151711820n, -1]);
+            // reminder = 0
+            // m = -11001100110011001100110011001100110011001100110011011.100
+            // rounding down (to even)
+            if (result[0] !== -7205759403792796n) {
+                throw result[0].toString(2);
+            }
+            if (result[1] !== 2) {
+                throw result[1];
+            }
+        }
+    ]
+};

package/out/types/bigint/module.f.mjs

@@ -0,0 +1,114 @@
+// @ts-self-types="./module.f.d.mts"
+import * as compare from '../function/compare/module.f.mjs';
+import * as Operator from '../function/operator/module.f.mjs';
+const { unsafeCmp } = compare;
+import * as list from '../list/module.f.mjs';
+const { reduce } = list;
+/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
+/** @type {(a: bigint) => (b: bigint) => bigint} */
+export const addition = a => b => a + b;
+export const sum = reduce(addition)(0n);
+/** @type {(a: bigint) => bigint} */
+export const abs = a => a >= 0 ? a : -a;
+/** @type {(a: bigint) => compare.Sign} */
+export const sign = a => unsafeCmp(a)(0n);
+/** @type {(a: bigint) => string} */
+export const serialize = a => `${a}n`;
+/**
+ * @template T
+ * @typedef {{
+ *  readonly 0: T
+ *  readonly add: Operator.Reduce<T>
+ * }} Additive
+ */
+/** @type {<T>(a: Additive<T>) => (a: T) => (n: bigint) => T} */
+export const scalar_mul = ({ 0: _0, add }) => a => n => {
+    let ai = a;
+    let ni = n;
+    let result = _0;
+    while (true) {
+        if ((ni & 1n) === 1n) {
+            result = add(result)(ai);
+        }
+        ni >>= 1n;
+        if (ni === 0n) {
+            return result;
+        }
+        ai = add(ai)(ai);
+    }
+};
+/**
+ * Calculates the base-2 logarithm (floor).
+ *
+ * This function returns the integer part of the logarithm. For example:
+ * - `log2(1n)` returns `0n`,
+ * - `log2(2n)` returns `1n`,
+ * - `log2(15n)` returns `3n`.
+ *
+ * @param {bigint} v - The input BigInt.
+ * @returns {bigint} The base-2 logarithm (floor) of the input BigInt, or `-1n` if the input is less than or equal to 0.
+ *
+ * @remarks
+ * The function operates in two phases:
+ * 1. **Fast Doubling Phase:** Uses exponential steps to quickly narrow down the range
+ *    of the most significant bit.
+ * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
+ *    determining the exact value of the logarithm.
+ */
+export const log2 = v => {
+    if (v <= 0n) {
+        return -1n;
+    }
+    let result = 0n;
+    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 result;
+};
+/**
+ * Calculates the bit length of a given BigInt.
+ *
+ * The bit length of a number is the number of bits required to represent its absolute value in binary,
+ * excluding leading zeros. For example:
+ * - `0n` has a bit length of 0 (it has no bits).
+ * - `1n` (binary `1`) has a bit length of 1.
+ * - `255n` (binary `11111111`) has a bit length of 8.
+ * - `-255n` (absolute value `255`, binary `11111111`) also has a bit length of 8.
+ *
+ * The function handles both positive and negative numbers. For negative inputs, the bit length is calculated
+ * based on the absolute value of the number. Zero has a bit length of 0.
+ *
+ * @param {bigint} v - The input BigInt.
+ * @returns {bigint} The bit length of the input BigInt.
+ *
+ * @remark
+ * The function uses the `log2` function to calculate the position of the most significant bit(MSB)
+ * and adds `1n` to account for the MSB itself.For negative numbers, the absolute value is used.
+ */
+export const bitLength = v => {
+    if (v <= 0n) {
+        if (v === 0n) {
+            return 0n;
+        }
+        v = -v;
+    }
+    return log2(v) + 1n;
+};

package/out/types/bigint/test.f.mjs

@@ -0,0 +1,192 @@
+import * as _ from './module.f.mjs';
+const { sum, abs, serialize, log2, bitLength } = _;
+export default {
+    sum: () => {
+        const result = sum([2n, 3n, 4n, 5n]);
+        if (result !== 14n) {
+            throw result;
+        }
+    },
+    abs: [
+        () => {
+            const result = abs(10n);
+            if (result !== 10n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = abs(-10n);
+            if (result !== 10n) {
+                throw result;
+            }
+        }
+    ],
+    serialize: [
+        () => {
+            const result = serialize(0n);
+            if (result !== '0n') {
+                throw result;
+            }
+        },
+        () => {
+            const result = serialize(123456789012345678901234567890n);
+            if (result !== '123456789012345678901234567890n') {
+                throw result;
+            }
+        },
+        () => {
+            const result = serialize(-55555n);
+            if (result !== '-55555n') {
+                throw result;
+            }
+        },
+    ],
+    log2: [
+        () => {
+            const result = log2(-3n);
+            if (result !== -1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(0n);
+            if (result !== -1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(1n);
+            if (result !== 0n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(2n);
+            if (result !== 1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(3n);
+            if (result !== 1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(4n);
+            if (result !== 2n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(7n);
+            if (result !== 2n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(8n);
+            if (result !== 3n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(15n);
+            if (result !== 3n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(16n);
+            if (result !== 4n) {
+                throw result;
+            }
+        },
+        () => {
+            // max for Bun (131_072 Bytes)
+            const v = 1048575n;
+            const result = log2(1n << v);
+            if (result !== v) {
+                throw result;
+            }
+        },
+    ],
+    toString2: () => {
+        // max for Bun (131_072 Bytes)
+        const v = 1048575n;
+        const result = (1n << v).toString(2).length - 1;
+        if (result !== 1_048_575) {
+            throw result;
+        }
+    },
+    minus: () => {
+        let i = 0n;
+        while (i < 1048575n) {
+            const s = -i;
+            if (i !== -s) {
+                throw [i, s];
+            }
+            i += 1n;
+        }
+    },
+    not: () => {
+        let i = 0n;
+        while (i < 1048575n) {
+            const s = ~i;
+            if (i !== ~s) {
+                throw [i, s];
+            }
+            i += 1n;
+        }
+    },
+    bitLen: {
+        0: () => {
+            const s = bitLength(0n);
+            if (s !== 0n) {
+                throw s;
+            }
+        },
+        m: () => {
+            let i = 0n;
+            while (i < 10000n) {
+                const s = bitLength(1n << i);
+                if (s !== i + 1n) {
+                    throw [s, i];
+                }
+                i += 1n;
+            }
+        },
+        big: () => {
+            const s = bitLength(1n << 1000000n);
+            if (s !== 1000001n) {
+                throw s;
+            }
+        },
+        neg: [
+            () => {
+                const s = bitLength(-1n);
+                if (s !== 1n) {
+                    throw s;
+                }
+            },
+            () => {
+                const s = bitLength(-2n);
+                if (s !== 2n) {
+                    throw s;
+                }
+            },
+            () => {
+                const s = bitLength(-3n);
+                if (s !== 2n) {
+                    throw s;
+                }
+            },
+            () => {
+                const s = bitLength(-4n);
+                if (s !== 3n) {
+                    throw s;
+                }
+            },
+        ]
+    }
+};