functionalscript 0.43.1 → 0.44.0

package/fjs/types/bigfloat/module.f.js

@@ -1,69 +0,0 @@
-/**
- * Big-float helpers built from bigint mantissa and exponent parts.
- *
- * @module
- */
-import { abs, sign } from '../bigint/module.f.js';
-const twoPow53 = 9007199254740992n;
-const twoPow54 = 18014398509481984n;
-/**
- * Shifts the mantissa magnitude one bit at a time, compensating the exponent,
- * until `done(magnitude, bound)` holds; the sign is restored on return.
- * A zero mantissa is returned unchanged: it can never satisfy a lower bound,
- * so shifting it would not terminate.
- */
-const normalizeMantissa = (shift, de, done) => ([m, e]) => (bound) => {
-    if (m === 0n) {
-        return [m, e];
-    }
-    const s = sign(m);
-    m = abs(m);
-    while (true) {
-        if (done(m, bound)) {
-            return [BigInt(s) * m, e];
-        }
-        m = shift(m);
-        e += de;
-    }
-};
-const increaseMantissa = normalizeMantissa(m => m << 1n, -1, (m, min) => m >= min);
-const decreaseMantissa = normalizeMantissa(m => m >> 1n, +1, (m, max) => m < max);
-const pow = (base) => (exp) => base ** BigInt(exp);
-const pow5 = pow(5n);
-export const multiply = ([m, e]) => (mul) => [m * mul, e];
-const divide = ([m, e]) => (div) => [[m / div, e], m % div];
-/**
- * Runs `f` on the magnitude `[abs(m), e]` and restores the sign of `m` on the
- * result: operations on signed mantissas factor through the magnitude.
- */
-const withSign = (m, e) => (f) => multiply(f([abs(m), e]))(BigInt(sign(m)));
-const round53 = ([[m, e], r]) => withSign(m, e)(([mAbs]) => {
-    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 [m53 + odd, e53];
-    }
-    return [m53 + o54, e53];
-});
-export const decToBin = (dec) => {
-    if (dec[0] === 0n) {
-        return [0n, 0];
-    }
-    if (dec[1] >= 0) {
-        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);
-    return withSign(m, e)(magnitude => round53(divide(magnitude)(p)));
-};
-export const proof = {
-    // normalizeMantissa guards against zero mantissa to prevent an infinite loop;
-    // this path is unreachable through decToBin (which returns early for 0n),
-    // so we exercise it here where the private helper is in scope.
-    normalizeMantissaZero: () => { increaseMantissa([0n, 5])(1n); }
-};

package/fjs/types/bigfloat/proof.f.js

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

package/fjs/types/bigint/module.f.d.ts

@@ -1,172 +0,0 @@
-/**
- * Utility functions for working with `bigint` values.
- *
- * @module
- *
- * @example
- *
- * ```js
- * import { sum, abs, log2, bitLength, mask } from './module.f.ts'
- *
- * const total = sum([1n, 2n, 3n]) // 6n
- * const absoluteValue = abs(-42n) // 42n
- * const logValue = log2(8n) // 3n
- * const bitCount = bitLength(255n) // 8n
- * const bitmask = mask(5n) // 31n
- * const c = combination([3n, 2n, 1n]) // 60n
- * ```
- */
-import { type Sign } from '../function/compare/module.f.ts';
-import type { Unary as OpUnary, Reduce as OpReduce } from '../function/operator/module.f.ts';
-import { type List } from '../list/module.f.ts';
-/**
- * Type representing a unary operation on `bigint`.
- */
-export type Unary = OpUnary<bigint, bigint>;
-/**
- * Type representing a reduction operation on `bigint` values.
- */
-export type Reduce = OpReduce<bigint>;
-/**
- * Adds two `bigint` values.
- *
- * @param a - The first bigint value.
- * @returns A function that takes the second bigint value and returns the sum.
- */
-export declare const addition: Reduce;
-/**
- * Calculates the sum of a list of `bigint` values.
- *
- * @param input - A list of bigint values.
- * @returns The sum of all values in the list.
- */
-export declare const sum: (input: List<bigint>) => bigint;
-/**
- * Multiplies two `bigint` values.
- *
- * @param a - The first bigint value.
- * @returns A function that takes the second bigint value and returns the product.
- */
-export declare const multiple: Reduce;
-/**
- * Calculates the product of a list of `bigint` values.
- *
- * @param input - A list of bigint values.
- * @returns The product of all values in the list.
- */
-export declare const product: (input: List<bigint>) => bigint;
-/**
- * Calculates the absolute value of a `bigint`.
- *
- * @param a - The bigint value.
- * @returns The absolute value of the input bigint.
- */
-export declare const abs: Unary;
-/**
- * Determines the sign of a `bigint`.
- * @param a - The bigint value.
- * @returns `1` if positive, `-1` if negative, and `0` if zero.
- */
-export declare const sign: (a: bigint) => Sign;
-/**
- * Serializes a `bigint` to a string representation.
- *
- * @param a - The bigint value.
- * @returns A string representation of the bigint (e.g., '123n').
- */
-export declare const serialize: (a: bigint) => string;
-/**
- * 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 v - The input BigInt.
- * @returns 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.
- * 3. **Remainder Phase:** Using `Math.log2`.
- */
-export declare const log2: (v: bigint) => bigint;
-/**
- * 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 v - The input BigInt.
- * @returns 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 declare const bitLength: (v: bigint) => bigint;
-/**
- * Generates a bitmask with the specified number of bits set to 1.
- *
- * @param len - The number of bits to set in the mask. Must be a non-negative integer.
- * @returns A bigint representing the bitmask, where the least significant `len` bits are 1.
- *
- * @example
- *
- * ```js
- * const result = mask(3n) // 7n
- * ```
- */
-export declare const mask: (len: bigint) => bigint;
-export declare const maxLength = 1048576n;
-export declare const max: bigint;
-/**
- * Calculates the partial factorial `b!/a!`.
- *
- * @param a - The starting bigint value.
- * @returns A function that takes `b` and computes `b!/a!`.
- */
-export declare const partialFactorial: (a: bigint) => (b: bigint) => bigint;
-/**
- * Calculates the factorial of a `bigint`.
- *
- * @param b - The bigint value.
- * @returns The factorial of the input.
- */
-export declare const factorial: (b: bigint) => bigint;
-/**
- * Calculates the number of combinations for a list of `bigint` values.
- *
- * @param k - A list of bigint values.
- * @returns The number of combinations.
- */
-export declare const combination: (...k: readonly bigint[]) => bigint;
-export declare const xor: Reduce;
-export declare const divUp: (b: bigint) => Unary;
-export declare const roundUp: (b: bigint) => Unary;
-/**
- * Converts a bit count to a byte count, rounding up — divides by `8`.
- *
- * Domain: non-negative inputs (bit/byte counts). On negative inputs `divUp`
- * truncates toward zero rather than flooring toward −∞, so the rounding
- * direction is only meaningful for `v >= 0n`.
- */
-export declare const divUp8: Unary;
-/**
- * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8`.
- *
- * Domain: non-negative inputs (bit/byte counts). See `divUp8` for the
- * truncate-vs-floor caveat on negative values.
- */
-export declare const roundUp8: Unary;