functionalscript 0.2.5 → 0.3.0

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

@@ -1,116 +0,0 @@
-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

@@ -1,6 +0,0 @@
-/** @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

@@ -1,77 +0,0 @@
-// @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.d.mts

@@ -1,6 +0,0 @@
-declare namespace _default {
-    let decToBin: (() => void)[];
-    let roundingPositive: (() => void)[];
-    let roundingNegative: (() => void)[];
-}
-export default _default;

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

@@ -1,349 +0,0 @@
-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

@@ -1,29 +0,0 @@
-/** @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/out/types/bigint/module.f.mjs

@@ -1,114 +0,0 @@
-// @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;
-};