functionalscript 0.0.547 → 0.0.549

package/.github/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [16.x, 18.x, 20.x, 21.x]
+        node-version: [16.x, 18.x, 20.x, 22.x]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.547",
+  "version": "0.0.549",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {
@@ -14,7 +14,7 @@
     "type": "git",
     "url": "git+https://github.com/functionalscript/functionalscript.git"
   },
-  "author": "NatFoam",
+  "author": "Sergey Shandar",
   "license": "MIT",
   "keywords": [
     "lambda",
@@ -30,7 +30,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^20.5.1",
-    "typescript": "^5.1.6"
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.4"
   }
 }

package/prime_field/module.f.cjs

@@ -0,0 +1,94 @@
+/**
+ * @typedef {{
+ *  readonly p: bigint
+ *  readonly a: bigint
+ *  readonly b: bigint
+ *  readonly g: readonly[bigint, bigint]
+ *  readonly n: bigint
+ * }} Curve
+ */
+
+/**
+ * @typedef {{
+ *  readonly middle: bigint
+ *  readonly max: bigint
+ *  readonly neg: (a: bigint) => bigint
+ *  readonly sub: (a: bigint) => (b: bigint) => bigint
+ *  readonly add: (a: bigint) => (b: bigint) => bigint
+ *  readonly abs: (a: bigint) => bigint
+ *  readonly mul: (a: bigint) => (b: bigint) => bigint
+ *  readonly reciprocal: (a: bigint) => bigint
+ *  readonly div: (a: bigint) => (b: bigint) => bigint
+ *  readonly pow: (a: bigint) => (b: bigint) => bigint
+ *  readonly sqrt: (a: bigint) => bigint|null
+ * }} PrimeField
+ */
+
+/** @type {(p: bigint) => PrimeField} */
+const prime_field = p => {
+    /** @type {(a: bigint) => (b: bigint) => bigint} */
+    const sub = a => b => {
+        const r = a - b
+        return r < 0 ? r + p : r
+    }
+    /** @type {(a: bigint) => (b: bigint) => bigint} */
+    const mul = a => b => a * b % p
+    /** @type {(a: bigint) => bigint} */
+    const reciprocal = a => {
+        if (a === 0n) { throw '1/0' }
+        let a1 = a
+        let a0 = p
+        let f0 = 0n
+        let f1 = 1n
+        while (a1 !== 1n) {
+            const q = a0 / a1
+            const a2 = a0 % a1
+            a0 = a1
+            a1 = a2
+            const f2 = sub(f0)(mul(f1)(q))
+            f0 = f1
+            f1 = f2
+        }
+        return f1
+    }
+    const middle = p >> 1n
+    if ((p & 3n) !== 3n) { throw 'sqrt' }
+    const sqrt_k = (p + 1n) >> 2n
+    /** @type {(a: bigint) => (n: bigint) => bigint} */
+    const pow = a => n => {
+        let result = 1n
+        while (true) {
+            if ((n & 1n) === 1n) {
+                result = mul(result)(a)
+            }
+            n >>= 1n
+            if (n === 0n) {
+                return result
+            }
+            a = mul(a)(a)
+        }
+    }
+    return {
+        middle,
+        max: p - 1n,
+        neg: a => a === 0n ? 0n : p - a,
+        sub,
+        add: a => b => {
+            const r = a + b
+            return r < p ? r : r - p
+        },
+        abs: a => middle < a ? p - a : a,
+        mul,
+        reciprocal,
+        div: a => b => mul(a)(reciprocal(b)),
+        pow,
+        sqrt: a => {
+            const result = pow(a)(sqrt_k)
+            return mul(result)(result) === a ? result : null
+        }
+    }
+}
+
+module.exports = {
+    prime_field
+}

package/prime_field/test.f.cjs

@@ -0,0 +1,86 @@
+const { prime_field } = require('./module.f.cjs')
+
+module.exports = {
+    prime_field_test: () => {
+        const p = 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn;
+        const f = prime_field(p)
+        return {
+            neg: () => {
+                if (f.neg(0n) !== 0n) { throw '-0' }
+                if (f.neg(1n) !== p - 1n) { throw '-1' }
+            },
+            sub: () => {
+                if (f.sub(10n)(4n) !== 6n) { throw '10 - 4'}
+                if (f.sub(11n)(14n) !== p - 3n) { throw '11 - 14' }
+            },
+            add: () => {
+                if (f.add(13n)(24n) !== 37n) { throw '13 + 24' }
+                if (f.add(77n)(f.neg(12n)) !== 65n) { throw '77 + (-12)' }
+            },
+            mul: () => {
+                if (f.mul(100n)(0n) !== 0n) { throw '100 * 0' }
+                if (f.mul(101n)(205n) !== 20_705n) { throw '101 * 205' }
+                if (f.mul(304n)(f.neg(1n)) !== f.neg(304n)) { throw '304 * -1' }
+                if (f.mul(f.neg(507n))(609n) !== f.neg(308_763n)) { throw '-507 * 609' }
+                if (f.mul(f.neg(713n))(f.neg(825n)) !== 588_225n) { throw '-713 * -825' }
+            },
+            reciprocal: () => {
+                let i = 1n
+                while (i < 10_000n) {
+                    const x = f.reciprocal(i)
+                    if (f.mul(x)(i) !== 1n) { throw i }
+                    ++i
+                }
+            },
+            pow: () => {
+                /** @type {(a: bigint) => void} */
+                const test = a => {
+                    if (f.pow(a)(0n) !== 1n) { throw '**0'}
+                    if (f.pow(a)(1n) !== a) { throw '**1' }
+                    // https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
+                    // a^(p-1) % p = 1
+                    if (f.abs(f.pow(a)(f.middle)) !== 1n) { throw '**middle' }
+                    if (f.pow(a)(f.sub(f.max)(1n)) !== f.reciprocal(a)) { throw '**(max-1)' }
+                    if (f.pow(a)(f.max) !== 1n) { throw '**max-1' }
+                }
+                // 0
+                if (f.pow(0n)(0n) !== 1n) { throw '0**0'}
+                if (f.pow(0n)(f.max) !== 0n) { throw '0**max' }
+                // 1
+                test(1n)
+                // 2
+                test(2n)
+                if (f.pow(2n)(2n) !== 4n) { throw '2**2' }
+                if (f.pow(2n)(3n) !== 8n) { throw '2**3' }
+                if (f.pow(2n)(128n) !== 1n << 128n) { throw '2**128' }
+                // 3
+                test(3n)
+                if (f.pow(3n)(2n) !== 9n) { throw '3**2' }
+                if (f.pow(3n)(3n) !== 27n) { throw '3**3' }
+                if (f.pow(3n)(100n) !== 3n ** 100n) { throw '3**100' }
+                if (f.pow(3n)(110n) !== 3n ** 110n) { throw '3**110' }
+                if (f.pow(3n)(120n) !== 3n ** 120n) { throw '3**120' }
+                if (f.pow(3n)(121n) !== 3n ** 121n) { throw '3**121' }
+                //
+                test(f.middle)
+                test(f.max - 1n)
+                test(f.max)
+            },
+            sqrt: () => {
+                /** @type {(a: bigint) => void} */
+                const test = a => {
+                    const a2 = f.mul(a)(a)
+                    const s = f.sqrt(a2)
+                    if (s !== null && f.abs(s) !== f.abs(a)) { throw 'sqrt' }
+                }
+                let i = 1n
+                while (i < 1000n) {
+                    test(i)
+                    ++i;
+                }
+                test(f.middle);
+                test(f.max);
+            }
+        }
+    }
+}