functionalscript 0.0.571 → 0.0.572

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.571",
+  "version": "0.0.572",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {
     "tsc": "tsc",

package/types/bigint/module.f.cjs

@@ -45,34 +45,26 @@ const scalar_mul = ({ 0: _0, add }) => a => n => {
 }
 
 /**
- * Calculates the bit length of a given BigInt.
- *
- * The bit length of a number is the number of bits required to represent it in binary,
- * excluding leading zeros. For example:
- * - `0n` (binary `...0`) has a bit length of 0.
- * - `1n` (binary `...0_1`) has a bit length of 1.
- * - `255n` (binary `...0_11111111`) has a bit length of 8.
+ * Calculates the base-2 logarithm (floor).
  *
- * Negative inputs are converted to their absolute values before calculation. For example:
- * - `-255n` has a bit length of 8.
- * - `-1n` has a bit length of 1.
+ * 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. It can be positive, negative, or zero.
- * @returns {bigint} The bit length of the input BigInt.
+ * @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
- * This function determines the bit length in two phases:
- * 1. **Fast Doubling Phase:** Quickly identifies the range of the most significant bit using exponential steps.
- * 2. **Binary Search Phase:** Refines the result to precisely count all significant bits.
- *
- * The algorithm operates with logarithmic complexity, making it efficient for very large BigInts.
+ * 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.
  */
-const bitLen = v => {
-    if (v <= 0n) {
-        if (v === 0n) { return 0n }
-        v = -v
-    }
-    let result = 1n
+const log2 = v => {
+    if (v <= 0n) { return -1n }
+    let result = 0n
     let i = 1n
     while (true) {
         const n = v >> i
@@ -97,7 +89,33 @@ const bitLen = v => {
     return result
 }
 
-const log2 = (/** @type {bigint} */v) => v <= 0n ? -1n : bitLen(v) - 1n
+/**
+ * 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.
+ */
+const bitLength = v => {
+    if (v <= 0n) {
+        if (v === 0n) { return 0n }
+        v = -v
+    }
+    return log2(v) + 1n
+}
 
 module.exports = {
     /** @readonly */
@@ -115,5 +133,5 @@ module.exports = {
     /** @readonly */
     log2,
     /** @readonly */
-    bitLen,
+    bitLength,
 }

package/types/bigint/test.f.cjs

@@ -1,4 +1,4 @@
-const { sum, abs, serialize, log2, bitLen } = require('./module.f.cjs')
+const { sum, abs, serialize, log2, bitLength } = require('./module.f.cjs')
 
 module.exports = {
     sum: () => {
@@ -101,36 +101,36 @@ module.exports = {
     },
     bitLen: {
         0: () => {
-            const s = bitLen(0n)
+            const s = bitLength(0n)
             if (s !== 0n) { throw s }
         },
         m: () => {
             let i = 0n
             while (i < 10_000n) {
-                const s = bitLen(1n << i)
+                const s = bitLength(1n << i)
                 if (s !== i + 1n) { throw [s, i] }
                 i += 1n
             }
         },
         big: () => {
-            const s = bitLen(1n << 1_000_000n)
+            const s = bitLength(1n << 1_000_000n)
             if (s !== 1_000_001n) { throw s }
         },
         neg: [
             () => {
-                const s = bitLen(-1n)
+                const s = bitLength(-1n)
                 if (s !== 1n) { throw s }
             },
             () => {
-                const s = bitLen(-2n)
+                const s = bitLength(-2n)
                 if (s !== 2n) { throw s }
             },
             () => {
-                const s = bitLen(-3n)
+                const s = bitLength(-3n)
                 if (s !== 2n) { throw s }
             },
             () => {
-                const s = bitLen(-4n)
+                const s = bitLength(-4n)
                 if (s !== 3n) { throw s }
             },
         ]