functionalscript 0.3.4 → 0.3.6

package/types/bigfloat/test.f.d.ts

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

package/types/bigfloat/test.f.js

@@ -0,0 +1,349 @@
+import * as _ from "./module.f.js";
+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/types/bigint/module.f.d.ts

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

package/types/bigint/{module.f.ts → module.f.js}

@@ -1,53 +1,27 @@
-import * as compare from '../function/compare/module.f.ts'
-import * as Operator from '../function/operator/module.f.ts'
-const { unsafeCmp } = compare
-import { reduce, type List } from '../list/module.f.ts'
-
-type Unary = Operator.Unary<bigint, bigint>
-
-export const addition
-    : (a: bigint) => (b: bigint) => bigint
-    = a => b => a + b
-
-export const sum
-: (input: List<bigint>) => bigint
-= reduce(addition)(0n)
-
-export const abs
-    : (a: bigint) => bigint
-    = a => a >= 0 ? a : -a
-
-export const sign
-    : (a: bigint) => compare.Sign
-    = a => unsafeCmp(a)(0n)
-
-export const serialize
-    : (a: bigint) => string
-    = a => `${a}n`
-
-type Additive<T> = {
-   readonly 0: T
-   readonly add: Operator.Reduce<T>
-}
-
-export const scalar_mul
-    : <T>(a: Additive<T>) => (a: T) => (n: bigint) => T
-    = ({ 0: _0, add }) => a => n => {
-    let ai = a
-    let ni = n
-    let result = _0
+import * as compare from "../function/compare/module.f.js";
+import * as Operator from "../function/operator/module.f.js";
+const { unsafeCmp } = compare;
+import { reduce } from "../list/module.f.js";
+export const addition = a => b => a + b;
+export const sum = reduce(addition)(0n);
+export const abs = a => a >= 0 ? a : -a;
+export const sign = a => unsafeCmp(a)(0n);
+export const serialize = a => `${a}n`;
+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)
+            result = add(result)(ai);
         }
-        ni >>= 1n
+        ni >>= 1n;
         if (ni === 0n) {
-            return result
+            return result;
         }
-        ai = add(ai)(ai)
+        ai = add(ai)(ai);
     }
-}
-
+};
 /**
  * Calculates the base-2 logarithm (floor).
  *
@@ -66,33 +40,34 @@ export const scalar_mul
  * 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: bigint): bigint => {
-    if (v <= 0n) { return -1n }
-    let result = 0n
-    let i = 1n
+export const log2 = (v) => {
+    if (v <= 0n) {
+        return -1n;
+    }
+    let result = 0n;
+    let i = 1n;
     while (true) {
-        const n = v >> i
+        const n = v >> i;
         if (n === 0n) {
             // overshot
-            break
+            break;
         }
-        v = n
-        result += i
-        i <<= 1n
+        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
+        i >>= 1n;
+        const n = v >> i;
         if (n !== 0n) {
-            result += i
-            v = n
+            result += i;
+            v = n;
         }
     }
-    return result
-}
-
+    return result;
+};
 /**
  * Calculates the bit length of a given BigInt.
  *
@@ -113,10 +88,12 @@ export const 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.
  */
-export const bitLength = (v: bigint): bigint => {
+export const bitLength = (v) => {
     if (v <= 0n) {
-        if (v === 0n) { return 0n }
-        v = -v
+        if (v === 0n) {
+            return 0n;
+        }
+        v = -v;
     }
-    return log2(v) + 1n
-}
+    return log2(v) + 1n;
+};

package/types/bigint/test.f.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    sum: () => void;
+    abs: (() => void)[];
+    serialize: (() => void)[];
+    log2: (() => void)[];
+    toString2: () => void;
+    minus: () => void;
+    not: () => void;
+    bitLen: {
+        0: () => void;
+        m: () => void;
+        big: () => void;
+        neg: (() => void)[];
+    };
+};
+export default _default;