Better code structure. Better README. Added generation of IIFE file

dist/bigint-mod-arith-latest.browser.js

@@ -0,0 +1,178 @@
+var bigintModArith = (function (exports) {
+    'use strict';
+
+    const _ZERO = BigInt(0);
+    const _ONE = BigInt(1);
+    const _TWO = BigInt(2);
+
+    /**
+     * Absolute value. abs(a)==a if a>=0. abs(a)==-a if a<0
+     *  
+     * @param {number|bigint} a 
+     * 
+     * @returns {bigint} the absolute value of a
+     */
+    function abs(a) {
+        a = BigInt(a);
+        return (a >= _ZERO) ? a : -a;
+    }
+
+    /**
+     * @typedef {Object} egcdReturn A triple (g, x, y), such that ax + by = g = gcd(a, b).
+     * @property {bigint} g
+     * @property {bigint} x 
+     * @property {bigint} y
+     */
+    /**
+     * An iterative implementation of the extended euclidean algorithm or extended greatest common divisor algorithm. 
+     * Take positive integers a, b as input, and return a triple (g, x, y), such that ax + by = g = gcd(a, b).
+     * 
+     * @param {number|bigint} a 
+     * @param {number|bigint} b 
+     * 
+     * @returns {egcdReturn}
+     */
+    function eGcd(a, b) {
+        a = BigInt(a);
+        b = BigInt(b);
+        let x = _ZERO;
+        let y = _ONE;
+        let u = _ONE;
+        let v = _ZERO;
+
+        while (a !== _ZERO) {
+            let q = b / a;
+            let r = b % a;
+            let m = x - (u * q);
+            let n = y - (v * q);
+            b = a;
+            a = r;
+            x = u;
+            y = v;
+            u = m;
+            v = n;
+        }
+        return {
+            b: b,
+            x: x,
+            y: y
+        };
+    }
+
+    /**
+     * Greatest-common divisor of two integers based on the iterative binary algorithm.
+     * 
+     * @param {number|bigint} a 
+     * @param {number|bigint} b 
+     * 
+     * @returns {bigint} The greatest common divisor of a and b
+     */
+    function gcd(a, b) {
+        a = abs(a);
+        b = abs(b);
+        let shift = _ZERO;
+        while (!((a | b) & _ONE)) {
+            a >>= _ONE;
+            b >>= _ONE;
+            shift++;
+        }
+        while (!(a & _ONE)) a >>= _ONE;
+        do {
+            while (!(b & _ONE)) b >>= _ONE;
+            if (a > b) {
+                let x = a;
+                a = b;
+                b = x;
+            }
+            b -= a;
+        } while (b);
+
+        // rescale
+        return a << shift;
+    }
+
+    /**
+     * The least common multiple computed as abs(a*b)/gcd(a,b)
+     * @param {number|bigint} a 
+     * @param {number|bigint} b 
+     * 
+     * @returns {bigint} The least common multiple of a and b
+     */
+    function lcm(a, b) {
+        a = BigInt(a);
+        b = BigInt(b);
+        return abs(a * b) / gcd(a, b);
+    }
+
+    /**
+     * Modular inverse.
+     * 
+     * @param {number|bigint} a The number to find an inverse for
+     * @param {number|bigint} n The modulo
+     * 
+     * @returns {bigint} the inverse modulo n
+     */
+    function modInv(a, n) {
+        let egcd = eGcd(a, n);
+        if (egcd.b !== _ONE) {
+            return null; // modular inverse does not exist
+        } else {
+            return toZn(egcd.x, n);
+        }
+    }
+
+    /**
+     * Modular exponentiation a**b mod n
+     * @param {number|bigint} a base
+     * @param {number|bigint} b exponent
+     * @param {number|bigint} n modulo
+     * 
+     * @returns {bigint} a**b mod n
+     */
+    function modPow(a, b, n) {
+        // See Knuth, volume 2, section 4.6.3.
+        n = BigInt(n);
+        a = toZn(a, n);
+        b = BigInt(b);
+        if (b < _ZERO) {
+            return modInv(modPow(a, abs(b), n), n);
+        }
+        let result = _ONE;
+        let x = a;
+        while (b > 0) {
+            var leastSignificantBit = b % _TWO;
+            b = b / _TWO;
+            if (leastSignificantBit == _ONE) {
+                result = result * x;
+                result = result % n;
+            }
+            x = x * x;
+            x = x % n;
+        }
+        return result;
+    }
+
+    /**
+     * Finds the smallest positive element that is congruent to a in modulo n
+     * @param {number|bigint} a An integer
+     * @param {number|bigint} n The modulo
+     * 
+     * @returns {bigint} The smallest positive representation of a in modulo n
+     */
+    function toZn(a, n) {
+        n = BigInt(n);
+        a = BigInt(a) % n;
+        return (a < 0) ? a + n : a;
+    }
+
+    exports.abs = abs;
+    exports.eGcd = eGcd;
+    exports.gcd = gcd;
+    exports.lcm = lcm;
+    exports.modInv = modInv;
+    exports.modPow = modPow;
+    exports.toZn = toZn;
+
+    return exports;
+
+}({}));

dist/bigint-mod-arith-latest.browser.min.js

@@ -0,0 +1 @@
+var bigintModArith=function(a){'use strict';function c(b){return b=BigInt(b),b>=i?b:-b}function d(c,d){c=BigInt(c),d=BigInt(d);let e=i,f=j,g=j,h=i;for(;c!==i;){let a=d/c,b=d%c,i=e-g*a,j=f-h*a;d=c,c=b,e=g,f=h,g=i,h=j}return{b:d,x:e,y:f}}function e(d,e){d=c(d),e=c(e);let f=i;for(;!((d|e)&j);)d>>=j,e>>=j,f++;for(;!(d&j);)d>>=j;do{for(;!(e&j);)e>>=j;if(d>e){let a=d;d=e,e=a}e-=d}while(e);return d<<f}function f(b,a){let c=d(b,a);return c.b===j?h(c.x,a):null}function g(d,e,l){if(l=BigInt(l),d=h(d,l),e=BigInt(e),e<i)return f(g(d,c(e),l),l);let m=j,o=d;for(;0<e;){var p=e%k;e/=k,p==j&&(m*=o,m%=l),o*=o,o%=l}return m}function h(b,c){return c=BigInt(c),b=BigInt(b)%c,0>b?b+c:b}const i=BigInt(0),j=BigInt(1),k=BigInt(2);return a.abs=c,a.eGcd=d,a.gcd=e,a.lcm=function(d,f){return d=BigInt(d),f=BigInt(f),c(d*f)/e(d,f)},a.modInv=f,a.modPow=g,a.toZn=h,a}({});