functionalscript 0.3.7 → 0.3.9

package/text/utf8/test.f.js

@@ -1,67 +1,66 @@
-import * as encoding from "./module.f.js";
+import { toCodePointList, fromCodePointList } from "./module.f.js";
 import * as json from "../../json/module.f.js";
-import * as o from "../../types/object/module.f.js";
-const { sort } = o;
-import * as list from "../../types/list/module.f.js";
+import { sort } from "../../types/object/module.f.js";
+import { toArray } from "../../types/list/module.f.js";
 const stringify = json.stringify(sort);
 export default {
     toCodePoint: [
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([-1, 256])));
+            const result = stringify(toArray(toCodePointList([-1, 256])));
             if (result !== '[2147483648,2147483648]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([128, 193, 245, 255])));
+            const result = stringify(toArray(toCodePointList([128, 193, 245, 255])));
             if (result !== '[-2147483520,-2147483455,-2147483403,-2147483393]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([0, 1, 127])));
+            const result = stringify(toArray(toCodePointList([0, 1, 127])));
             if (result !== '[0,1,127]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([194, 128, 194, 169, 223, 191])));
+            const result = stringify(toArray(toCodePointList([194, 128, 194, 169, 223, 191])));
             if (result !== '[128,169,2047]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([194, 194, 127, 194, 192, 194])));
+            const result = stringify(toArray(toCodePointList([194, 194, 127, 194, 192, 194])));
             if (result !== '[-2147483454,-2147483454,127,-2147483454,-2147483456,-2147483454]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([224, 160, 128, 224, 160, 129, 239, 191, 191])));
+            const result = stringify(toArray(toCodePointList([224, 160, 128, 224, 160, 129, 239, 191, 191])));
             if (result !== '[2048,2049,65535]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([224, 224, 160, 127, 239, 191])));
+            const result = stringify(toArray(toCodePointList([224, 224, 160, 127, 239, 191])));
             if (result !== '[-2147483424,-2147482592,127,-2147481601]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])));
+            const result = stringify(toArray(toCodePointList([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])));
             if (result !== '[65536,65537,1114111]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([240, 240, 160, 127, 244, 191])));
+            const result = stringify(toArray(toCodePointList([240, 240, 160, 127, 244, 191])));
             if (result !== '[-2147483408,-2147483104,127,-2147482817]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([240, 160, 160, 244, 160, 160])));
+            const result = stringify(toArray(toCodePointList([240, 160, 160, 244, 160, 160])));
             if (result !== '[-2147448800,-2147432416]') {
                 throw result;
             }
@@ -69,67 +68,67 @@ export default {
     ],
     fromCodePointList: [
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0, 1, 0x7F])));
+            const result = stringify(toArray(fromCodePointList([0, 1, 0x7F])));
             if (result !== '[0,1,127]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x80])));
+            const result = stringify(toArray(fromCodePointList([0x80])));
             if (result !== '[194,128]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0xa9])));
+            const result = stringify(toArray(fromCodePointList([0xa9])));
             if (result !== '[194,169]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x7ff])));
+            const result = stringify(toArray(fromCodePointList([0x7ff])));
             if (result !== '[223,191]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x800])));
+            const result = stringify(toArray(fromCodePointList([0x800])));
             if (result !== '[224,160,128]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x801])));
+            const result = stringify(toArray(fromCodePointList([0x801])));
             if (result !== '[224,160,129]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0xffff])));
+            const result = stringify(toArray(fromCodePointList([0xffff])));
             if (result !== '[239,191,191]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x10000])));
+            const result = stringify(toArray(fromCodePointList([0x10000])));
             if (result !== '[240,144,128,128]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x10001])));
+            const result = stringify(toArray(fromCodePointList([0x10001])));
             if (result !== '[240,144,128,129]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x10FFFF])));
+            const result = stringify(toArray(fromCodePointList([0x10FFFF])));
             if (result !== '[244,143,191,191]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x110000, 2147483648])));
+            const result = stringify(toArray(fromCodePointList([0x110000, 2147483648])));
             if (result !== '[2147483648,2147483648]') {
                 throw result;
             }
@@ -137,36 +136,36 @@ export default {
     ],
     toFrom: [
         () => {
-            const codePointList = encoding.toCodePointList([128, 193, 245, 255]);
-            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            const codePointList = toCodePointList([128, 193, 245, 255]);
+            const result = stringify(toArray(fromCodePointList(codePointList)));
             if (result !== '[128,193,245,255]') {
                 throw result;
             }
         },
         () => {
-            const codePointList = encoding.toCodePointList([194, 194, 127, 194, 192, 194]);
-            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            const codePointList = toCodePointList([194, 194, 127, 194, 192, 194]);
+            const result = stringify(toArray(fromCodePointList(codePointList)));
             if (result !== '[194,194,127,194,192,194]') {
                 throw result;
             }
         },
         () => {
-            const codePointList = encoding.toCodePointList([224, 224, 160, 127, 239, 191]);
-            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            const codePointList = toCodePointList([224, 224, 160, 127, 239, 191]);
+            const result = stringify(toArray(fromCodePointList(codePointList)));
             if (result !== '[224,224,160,127,239,191]') {
                 throw result;
             }
         },
         () => {
-            const codePointList = encoding.toCodePointList([240, 240, 160, 127, 244, 191]);
-            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            const codePointList = toCodePointList([240, 240, 160, 127, 244, 191]);
+            const result = stringify(toArray(fromCodePointList(codePointList)));
             if (result !== '[240,240,160,127,244,191]') {
                 throw result;
             }
         },
         () => {
-            const codePointList = encoding.toCodePointList([240, 160, 160, 244, 160, 160]);
-            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            const codePointList = toCodePointList([240, 160, 160, 244, 160, 160]);
+            const result = stringify(toArray(fromCodePointList(codePointList)));
             if (result !== '[240,160,160,244,160,160]') {
                 throw result;
             }

package/types/bigfloat/module.f.js

@@ -46,7 +46,7 @@ const round53 = ([[m, e], r]) => {
     }
     return multiply([m53 + o54, e53])(s);
 };
-export const decToBin = dec => {
+export const decToBin = (dec) => {
     if (dec[0] === 0n) {
         return [0n, 0];
     }

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

@@ -1,12 +1,29 @@
-import * as compare from '../function/compare/module.f.ts';
+/**
+ * @module
+ *
+ * This module provides a collection of utility functions for working with `bigint` values.
+ *
+ * @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
+ * ```
+ */
+import { type Sign } from '../function/compare/module.f.ts';
 import type * as Operator from '../function/operator/module.f.ts';
 import { type List } from '../list/module.f.ts';
-type Unary = Operator.Unary<bigint, bigint>;
-type Reduce = Operator.Reduce<bigint>;
+export type Unary = Operator.Unary<bigint, bigint>;
+export type Reduce = Operator.Reduce<bigint>;
 export declare const addition: Reduce;
 export declare const sum: (input: List<bigint>) => bigint;
 export declare const abs: Unary;
-export declare const sign: (a: bigint) => compare.Sign;
+export declare const sign: (a: bigint) => Sign;
 export declare const serialize: (a: bigint) => string;
 /**
  * Calculates the base-2 logarithm (floor).
@@ -44,8 +61,20 @@ export declare const log2: (v: bigint) => 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.
+ * 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 {};
+/**
+ * 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;

package/types/bigint/module.f.js

@@ -1,11 +1,27 @@
-import * as compare from "../function/compare/module.f.js";
-const { unsafeCmp } = compare;
+/**
+ * @module
+ *
+ * This module provides a collection of utility functions for working with `bigint` values.
+ *
+ * @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
+ * ```
+ */
+import { unsafeCmp } from "../function/compare/module.f.js";
 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 sign = (a) => unsafeCmp(a)(0n);
+export const serialize = (a) => `${a}n`;
 /**
  * Calculates the base-2 logarithm (floor).
  *
@@ -28,8 +44,8 @@ export const log2 = (v) => {
     if (v <= 0n) {
         return -1n;
     }
-    let result = 0n;
-    let i = 1n;
+    let result = 31n;
+    let i = 32n;
     while (true) {
         const n = v >> i;
         if (n === 0n) {
@@ -41,8 +57,8 @@ export const log2 = (v) => {
         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) {
+    // Because of this, We check if `i` is greater than 32 before we divide it by 2.
+    while (i !== 32n) {
         i >>= 1n;
         const n = v >> i;
         if (n !== 0n) {
@@ -50,7 +66,7 @@ export const log2 = (v) => {
             v = n;
         }
     }
-    return result;
+    return result - BigInt(Math.clz32(Number(v)));
 };
 /**
  * Calculates the bit length of a given BigInt.
@@ -69,8 +85,8 @@ export const log2 = (v) => {
  * @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.
+ * 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) {
@@ -81,3 +97,16 @@ export const bitLength = (v) => {
     }
     return log2(v) + 1n;
 };
+/**
+ * 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 const mask = (len) => (1n << len) - 1n;

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

@@ -1,4 +1,12 @@
 declare const _default: {
+    example: () => void;
+    benchmark: {
+        str: () => void;
+        stringHexLog2: () => void;
+        oldLog2: () => void;
+        log2: () => void;
+    };
+    mask: () => void;
     sum: () => void;
     abs: (() => void)[];
     serialize: (() => void)[];

package/types/bigint/test.f.js

@@ -1,6 +1,85 @@
-import * as _ from "./module.f.js";
-const { sum, abs, serialize, log2, bitLength } = _;
+import { sum, abs, serialize, log2, bitLength, mask } from "./module.f.js";
+const oldLog2 = (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; // multiple by two
+    }
+    // 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;
+};
+const stringLog2 = (v) => BigInt(v.toString(2).length) - 1n;
+const stringHexLog2 = (v) => {
+    const len = (BigInt(v.toString(16).length) - 1n) << 2n;
+    const x = v >> len;
+    return len + 31n - BigInt(Math.clz32(Number(x)));
+};
+const benchmark = (f) => () => {
+    let e = 1048575n;
+    let c = 1n << e;
+    for (let i = 0n; i < 1_000; ++i) {
+        const x = f(c);
+        if (x !== e) {
+            throw x;
+        }
+        c >>= 1n;
+        --e;
+    }
+};
 export default {
+    example: () => {
+        const total = sum([1n, 2n, 3n]); // 6n
+        if (total !== 6n) {
+            throw total;
+        }
+        const absoluteValue = abs(-42n); // 42n
+        if (absoluteValue !== 42n) {
+            throw total;
+        }
+        const logValue = log2(8n); // 3n
+        if (logValue !== 3n) {
+            throw total;
+        }
+        const bitCount = bitLength(255n); // 8n
+        if (bitCount !== 8n) {
+            throw total;
+        }
+        const bitmask = mask(5n); // 31n
+        if (bitmask !== 31n) {
+            throw total;
+        }
+    },
+    benchmark: {
+        str: benchmark(stringLog2),
+        stringHexLog2: benchmark(stringHexLog2),
+        oldLog2: benchmark(oldLog2),
+        log2: benchmark(log2),
+    },
+    mask: () => {
+        const result = mask(3n); // 7n
+        if (result !== 7n) {
+            throw result;
+        }
+    },
     sum: () => {
         const result = sum([2n, 3n, 4n, 5n]);
         if (result !== 14n) {