functionalscript 0.4.1 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "type": "module",
   "files": [
     "**/*.f.d.ts",

package/types/bigint/module.f.js

@@ -23,6 +23,8 @@ 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`;
+const { isFinite } = Number;
+const { log2: mathLog2 } = Math;
 /**
  * Calculates the base-2 logarithm (floor).
  *
@@ -52,7 +54,7 @@ export const log2 = (v) => {
     let result = -1n;
     // `bigints` higher than 2**1023 may lead to `Inf` during conversion to `number`.
     // For example: `Number((1n << 1024n) - (1n << 970n)) === Inf`.
-    let i = 1023n;
+    let i = 0x400n;
     while (true) {
         const n = v >> i;
         if (n === 0n) {
@@ -68,7 +70,7 @@ export const log2 = (v) => {
     //
     // 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 1023 before we divide it by 2.
-    while (i !== 1023n) {
+    while (i !== 0x400n) {
         i >>= 1n;
         const n = v >> i;
         if (n !== 0n) {
@@ -79,12 +81,20 @@ export const log2 = (v) => {
     //
     // 3. Remainder Phase.
     //
-    // We know that `v` is less than `1n << 1023` so we can calculate a remainder using
+    // We know that `v` is less than `1n << 1024` so we can calculate a remainder using
     // `Math.log2`.
-    const rem = BigInt(Math.log2(Number(v)) | 0);
-    // (v >> rem) is either `0` or `1`, and it's used as a correction for
-    // Math.log2 rounding.
-    return result + rem + (v >> rem);
+    const nl = mathLog2(Number(v));
+    if (isFinite(nl)) {
+        const rem = BigInt(nl | 0);
+        // (v >> rem) is either `0` or `1`, and it's used as a correction for
+        // Math.log2 rounding.
+        return result + rem + (v >> rem);
+    }
+    else {
+        // nl is Inf, it means log2(v) === 0x3FF and we add +1 to compensate for initial
+        // `result = -1n`.
+        return result + 0x400n;
+    }
 };
 /**
  * Calculates the bit length of a given BigInt.

package/types/bigint/test.f.js

@@ -64,6 +64,50 @@ export const clz32Log2 = (v) => {
     }
     return result - BigInt(Math.clz32(Number(v)));
 };
+const m1023log2 = (v) => {
+    if (v <= 0n) {
+        return -1n;
+    }
+    //
+    // 1. Fast Doubling.
+    //
+    let result = -1n;
+    // `bigints` higher than 2**1023 may lead to `Inf` during conversion to `number`.
+    // For example: `Number((1n << 1024n) - (1n << 970n)) === Inf`.
+    let i = 1023n;
+    while (true) {
+        const n = v >> i;
+        if (n === 0n) {
+            // overshot
+            break;
+        }
+        v = n;
+        result += i;
+        i <<= 1n;
+    }
+    //
+    // 2. Binary Search.
+    //
+    // 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 1023 before we divide it by 2.
+    while (i !== 1023n) {
+        i >>= 1n;
+        const n = v >> i;
+        if (n !== 0n) {
+            result += i;
+            v = n;
+        }
+    }
+    //
+    // 3. Remainder Phase.
+    //
+    // We know that `v` is less than `1n << 1023` so we can calculate a remainder using
+    // `Math.log2`.
+    const rem = BigInt(Math.log2(Number(v)) | 0);
+    // (v >> rem) is either `0` or `1`, and it's used as a correction for
+    // Math.log2 rounding.
+    return result + rem + (v >> rem);
+};
 const benchmark = f => () => {
     let e = 1048575n;
     let c = 1n << e;
@@ -138,6 +182,7 @@ export default {
             str32Log2,
             oldLog2,
             clz32Log2,
+            m1023log2,
             log2,
         };
         const transform = (b) => Object.fromEntries(Object.entries(list).map(([k, f]) => [k, b(f)]));