functionalscript 0.1.609 → 0.2.1

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

@@ -0,0 +1,116 @@
+import * as _ from './module.f.mjs';
+import * as json from '../../json/module.f.mjs';
+import * as o from '../object/module.f.mjs';
+const { sort } = o;
+const stringify = json.stringify(sort);
+export default {
+    stringify: () => {
+        const result = stringify([1, 20, 300]);
+        if (result !== '[1,20,300]') {
+            throw result;
+        }
+    },
+    at: [
+        () => {
+            const result = _.at(2)([1, 20, 300]);
+            if (result !== 300) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.at(3)([1, 20, 300]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ],
+    first: [
+        () => {
+            const result = _.first([1, 20, 300]);
+            if (result !== 1) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.first([]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ],
+    last: [
+        () => {
+            const result = _.last([1, 20, 300]);
+            if (result !== 300) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.last([]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ],
+    head: [
+        () => {
+            const result = _.head([1, 20, 300]);
+            if (result === null) {
+                throw result;
+            }
+            const str = stringify(result);
+            if (str !== '[1,20]') {
+                throw str;
+            }
+        },
+        () => {
+            const result = _.head([]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ],
+    tail: [
+        () => {
+            const result = _.tail([1, 20, 300]);
+            const str = stringify(result);
+            if (str !== '[20,300]') {
+                throw str;
+            }
+        },
+        () => {
+            const result = _.tail([]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ],
+    splitFirst: [
+        () => {
+            const result = _.splitFirst([1, 20, 300]);
+            const str = stringify(result);
+            if (str !== '[1,[20,300]]') {
+                throw str;
+            }
+        },
+        () => {
+            const result = _.splitFirst([]);
+            if (result !== null) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.splitLast([1, 20, 300]);
+            const str = stringify(result);
+            if (str !== '[[1,20],300]') {
+                throw str;
+            }
+        },
+        () => {
+            const result = _.splitLast([]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ]
+};

package/out/types/bigfloat/module.f.d.mts

@@ -0,0 +1,6 @@
+/** @type {(b: BigFloat) => (mul: bigint) => BigFloat} */
+export const multiply: (b: BigFloat) => (mul: bigint) => BigFloat;
+/** @type {(dec: BigFloat) => BigFloat} */
+export const decToBin: (dec: BigFloat) => BigFloat;
+export type BigFloat = readonly [bigint, number];
+export type BigFloatWithRemainder = readonly [BigFloat, bigint];

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

@@ -0,0 +1,77 @@
+// @ts-self-types="./module.f.d.mts"
+import * as bi from '../bigint/module.f.mjs';
+const { abs, sign } = bi;
+/** @typedef {readonly[bigint,number]} BigFloat */
+/** @typedef {readonly[BigFloat,bigint]} BigFloatWithRemainder */
+const twoPow53 = 9007199254740992n;
+const twoPow54 = 18014398509481984n;
+/** @type {(value: BigFloat) => (min: bigint) => BigFloat} */
+const increaseMantissa = ([m, e]) => min => {
+    if (m === 0n) {
+        return [m, e];
+    }
+    const s = sign(m);
+    m = abs(m);
+    while (true) {
+        if (m >= min) {
+            return [BigInt(s) * m, e];
+        }
+        m = m << 1n;
+        e--;
+    }
+};
+/** @type {(value: BigFloat) => (max: bigint) => BigFloat} */
+const decreaseMantissa = ([m, e]) => max => {
+    if (m === 0n) {
+        return [m, e];
+    }
+    const s = sign(m);
+    m = abs(m);
+    while (true) {
+        if (m < max) {
+            return [BigInt(s) * m, e];
+        }
+        m = m >> 1n;
+        e++;
+    }
+};
+/** @type {(base: bigint) => (exp: number) => bigint} */
+const pow = base => exp => base ** BigInt(exp);
+const pow5 = pow(5n);
+/** @type {(b: BigFloat) => (mul: bigint) => BigFloat} */
+export const multiply = ([m, e]) => mul => [m * mul, e];
+/** @type {(b: BigFloat) => (div: bigint) => BigFloatWithRemainder} */
+const divide = ([m, e]) => div => [[m / div, e], m % div];
+/** @type {(b: BigFloatWithRemainder) => BigFloat} */
+const round53 = ([[m, e], r]) => {
+    const mabs = abs(m);
+    const s = BigInt(sign(m));
+    const [m54, e54] = decreaseMantissa([mabs, e])(twoPow54);
+    const o54 = m54 & 1n;
+    const m53 = m54 >> 1n;
+    const e53 = e54 + 1;
+    if (o54 === 1n && r === 0n && mabs === m54 >> BigInt(e - e54)) {
+        const odd = m53 & 1n;
+        return multiply([m53 + odd, e53])(s);
+    }
+    return multiply([m53 + o54, e53])(s);
+};
+/** @type {(dec: BigFloat) => BigFloat} */
+export const decToBin = dec => {
+    if (dec[0] === 0n) {
+        return [0n, 0];
+    }
+    if (dec[1] >= 0) {
+        /** @type {BigFloat} */
+        const bin = [dec[0] * pow5(dec[1]), dec[1]];
+        const inc = increaseMantissa(bin)(twoPow53);
+        return round53([inc, 0n]);
+    }
+    const p = pow5(-dec[1]);
+    const [m, e] = increaseMantissa(dec)(p * twoPow53);
+    const mAbs = abs(m);
+    const s = BigInt(sign(m));
+    const qr = divide([mAbs, e])(p);
+    const r53 = round53(qr);
+    return multiply(r53)(s);
+};

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.d.mts

@@ -0,0 +1,29 @@
+/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
+/** @type {(a: bigint) => (b: bigint) => bigint} */
+export const addition: (a: bigint) => (b: bigint) => bigint;
+export const sum: (input: list.List<bigint>) => bigint;
+/** @type {(a: bigint) => bigint} */
+export const abs: (a: bigint) => bigint;
+/** @type {(a: bigint) => compare.Sign} */
+export const sign: (a: bigint) => compare.Sign;
+/** @type {(a: bigint) => string} */
+export const serialize: (a: bigint) => string;
+/**
+ * @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: <T>(a: Additive<T>) => (a: T) => (n: bigint) => T;
+export function log2(v: bigint): bigint;
+export function bitLength(v: bigint): bigint;
+export type Unary = Operator.Unary<bigint, bigint>;
+export type Additive<T> = {
+    readonly 0: T;
+    readonly add: Operator.Reduce<T>;
+};
+import * as list from '../list/module.f.mjs';
+import * as compare from '../function/compare/module.f.mjs';
+import * as Operator from '../function/operator/module.f.mjs';

package/{types/bigint/module.f.d.mts → out/types/bigint/module.f.mjs}

@@ -1,29 +1,19 @@
-declare namespace _default {
-    export { addition };
-    export { sum };
-    export { abs };
-    export { sign };
-    export { serialize };
-    export { scalar_mul };
-    export { log2 };
-    export { bitLength };
-}
-export default _default;
-export type Unary = Operator.Unary<bigint, bigint>;
-export type Additive<T> = {
-    readonly 0: T;
-    readonly add: Operator.Reduce<T>;
-};
+// @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} */
-declare const addition: (a: bigint) => (b: bigint) => bigint;
-declare const sum: (input: import("../list/module.f.mjs").List<bigint>) => bigint;
+export const addition = a => b => a + b;
+export const sum = reduce(addition)(0n);
 /** @type {(a: bigint) => bigint} */
-declare const abs: (a: bigint) => bigint;
-/** @type {(a: bigint) => Compare.Sign} */
-declare const sign: (a: bigint) => Compare.Sign;
+export const abs = a => a >= 0 ? a : -a;
+/** @type {(a: bigint) => compare.Sign} */
+export const sign = a => unsafeCmp(a)(0n);
 /** @type {(a: bigint) => string} */
-declare const serialize: (a: bigint) => string;
+export const serialize = a => `${a}n`;
 /**
  * @template T
  * @typedef {{
@@ -32,7 +22,21 @@ declare const serialize: (a: bigint) => string;
  * }} Additive
  */
 /** @type {<T>(a: Additive<T>) => (a: T) => (n: bigint) => T} */
-declare const scalar_mul: <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).
  *
@@ -51,7 +55,34 @@ declare const scalar_mul: <T>(a: Additive<T>) => (a: T) => (n: bigint) => T;
  * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
  *    determining the exact value of the logarithm.
  */
-declare function log2(v: bigint): bigint;
+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.
  *
@@ -72,6 +103,12 @@ declare function log2(v: bigint): bigint;
  * 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.
  */
-declare function bitLength(v: bigint): bigint;
-import * as Operator from '../function/operator/module.f.mjs';
-import * as Compare from '../function/compare/module.f.mjs';
+export const bitLength = v => {
+    if (v <= 0n) {
+        if (v === 0n) {
+            return 0n;
+        }
+        v = -v;
+    }
+    return log2(v) + 1n;
+};