atomic-fns 1.2.0 → 2.0.0

package/dist/decimal/index.d.ts

@@ -1,151 +1,14 @@
 /**
- * `Decimal` provides support for correct rounded floating point arithmetic.
+ * Exact decimal arithmetic shaped after the TC39 Decimal draft, with Currency.
  *
- * @module decimal
- */
-/**
- * Casts the given value as a {@link Decimal}.
- */
-export declare function decimal(x: any): Decimal;
-/**
- * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard
- * `Number` type. It also supports user-defined precision (default is 20 decimal places), which
- * can be as large as needed.
+ * @example
+ * ```ts
+ * import { Decimal } from 'atomic-fns/decimal'
+ *
+ * new Decimal('0.1').add('0.2').toString() // '0.3'
+ * ```
+ * @module
  */
-export declare class Decimal {
-    static PRECISION: number;
-    private i;
-    private e;
-    /**
-     * Returns a new `Decimal` instance from the value or `0`.
-     * @param {*} value
-     * @returns {Decimal}
-     * @throws {ValueError} if the value is not numeric.
-     * @throws {RangeError} if the value is infinite or its exponent is past 10,000.
-     */
-    constructor(value?: any);
-    /**
-     * Returns a new `Decimal` that has the opposite sign of this `Decimal`.
-     * @example
-  ```js
-  let a = decimal('5')
-  a.negated()  // -5
-  ```
-     * @returns {Decimal}
-     */
-    negated(): Decimal;
-    /**
-     * Returns a new `Decimal` that is the sum of this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('50000000000')
-  let b = decimal('0.000000005')
-  a.add(b)  // 50000000000.000000005
-  ```
-     * @returns {Decimal}
-     */
-    add(x: any): Decimal;
-    /**
-     * Returns a new `Decimal` that is the difference between this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('1')
-  let b = decimal('0.0000000000000000001')
-  a.sub(b)  // 0.9999999999999999999
-  ```
-     * @returns {Decimal}
-     */
-    sub(x: any): Decimal;
-    /**
-     * Returns a new `Decimal` that is the product of this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('0.0000000000000000000025')
-  let b = decimal('400000000000000000000')
-  a.mul(b)  // 1
-  ```
-     * @returns {Decimal}
-     */
-    mul(x: any): Decimal;
-    /**
-     * Returns a new `Decimal` that is the quotient of this and `x`
-     * @param x
-     * @example
-  ```js
-  let a = decimal('1')
-  let b = decimal('3')
-  a.div(b)  // 0.33333333333333333333
-  ```
-     * @returns {Decimal}
-     */
-    div(x: Decimal | string | number): Decimal;
-    /**
-     * Returns the square root of this `Decimal`.
-     * @returns {Decimal}
-     * @throws {ValueError} if this value is negative.
-     */
-    sqrt(): Decimal;
-    /** Returns a new copy of this Decimal value. */
-    clone(): Decimal;
-    /**
-     * Remove zeroes in the least-significant digit of this `Decimal`
-     */
-    private _normalize;
-    /**
-     * Truncate this `Decimal` to the configured precision
-     */
-    private _truncate;
-    /**
-     * Returns a string representation of this decimal.
-     */
-    toString(): string;
-    /**
-     * Converts this decimal to the `Number` value
-     * @returns {number}
-     */
-    toNumber(): number;
-    static get precision(): number;
-    static set precision(value: number);
-    /**
-     * Returns `true` if this value is equal to the value of `x`, otherwise `false`.
-     * @param {*} x other
-     * @returns {boolean}
-     */
-    eq(x: any): boolean;
-    /**
-     * Returns `true` if this value is less than the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    lt(x: any): boolean;
-    /**
-     * Returns a comparison value representing the ordering of this value in respect to `x`.
-     *   * `-1` if this < x
-     *   * `1` if this > x
-     *   * `0` if this == x
-     * @param {*} x
-     * @returns {number}
-     */
-    compare(x: any): 0 | 1 | -1;
-    /**
-     * Returns `true` if this value is greater than the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    gt(x: any): boolean;
-    /**
-     * Returns `true` if this value is less than or equal to the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    lte(x: any): boolean;
-    /**
-     * Returns `true` if this value is greater than or equal to the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    gte(x: any): boolean;
-}
+export { Currency } from './currency.js';
+export { Decimal } from './decimal.js';
+export type { DecimalInput, DivideOptions, RoundingMode } from './decimal.js';

package/dist/decimal/index.js

@@ -1,413 +1,13 @@
 /**
- * `Decimal` provides support for correct rounded floating point arithmetic.
+ * Exact decimal arithmetic shaped after the TC39 Decimal draft, with Currency.
  *
- * @module decimal
- */
-import { ValueError } from '../globals/index.js';
-const NUMBER_REGEX = /^\s*([+-]?)(?=\.?[0-9])([0-9]*)(\.([0-9]*))?(?:[eE]([+-]?[0-9]+))?\s*$/;
-/** Largest power of ten an exponent may reach, so a short string cannot freeze the page. */
-const MAX_EXPONENT = 10_000;
-/**
- * Casts the given value as a {@link Decimal}.
- */
-export function decimal(x) {
-    return new Decimal(x);
-}
-/**
- * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard
- * `Number` type. It also supports user-defined precision (default is 20 decimal places), which
- * can be as large as needed.
+ * @example
+ * ```ts
+ * import { Decimal } from 'atomic-fns/decimal'
+ *
+ * new Decimal('0.1').add('0.2').toString() // '0.3'
+ * ```
+ * @module
  */
-export class Decimal {
-    static PRECISION = 20;
-    i = 0n;
-    e = 0;
-    /**
-     * Returns a new `Decimal` instance from the value or `0`.
-     * @param {*} value
-     * @returns {Decimal}
-     * @throws {ValueError} if the value is not numeric.
-     * @throws {RangeError} if the value is infinite or its exponent is past 10,000.
-     */
-    constructor(value) {
-        if (value == null) {
-            return this;
-        }
-        // Check if value is a Decimal like
-        if (typeof value?.i === 'bigint' && typeof value.e === 'number') {
-            this.i = value.i;
-            this.e = value.e;
-            this._normalize();
-            return this;
-        }
-        const text = value.toString();
-        const result = NUMBER_REGEX.exec(text);
-        if (result) {
-            // console.log(result);
-            // Construct from string if possible
-            // this.i = parseInt(result[1] + result[2] + result[4]);
-            if (typeof result[2] === 'undefined')
-                result[2] = '';
-            if (typeof result[4] === 'undefined')
-                result[4] = '';
-            this.i = BigInt(result[1] + result[2] + result[4]);
-            this.e = Number(result[5] ?? 0) - result[4].length;
-            this._normalize();
-            if (result[5]) {
-                const magnitude = this.e + (this.i < 0n ? -this.i : this.i).toString().length - 1;
-                if (this.i === 0n)
-                    this.e = 0;
-                else if (Math.abs(magnitude) > MAX_EXPONENT)
-                    throw new RangeError('exponent out of range');
-            }
-        }
-        else {
-            // Conversion to string failed, so construct from number
-            value = Number(value);
-            if (Number.isNaN(value) || (value === 0 && text.trim() === '')) {
-                throw new ValueError('Decimal value must be numeric');
-            }
-            let m = 1n;
-            if (value < 0) {
-                value = -value;
-                m = -1n;
-            }
-            if (value === 0) {
-                this.i = 0n;
-                this.e = 0;
-            }
-            else {
-                // Multiply the number by 10 until it is an integer
-                let e = -Math.floor(Math.log10(value));
-                if (e > 0) {
-                    value *= 10 ** e;
-                }
-                else {
-                    e = 0;
-                }
-                while (value !== Math.round(value)) {
-                    e++;
-                    value *= 10;
-                }
-                // Divide the number by 10 until the one's digit is non-zero
-                while (value % 10 === 0 && value > 0) {
-                    e--;
-                    value /= 10;
-                }
-                value = BigInt(value);
-                this.i = value * m;
-                this.e = -e;
-            }
-        }
-    }
-    /**
-     * Returns a new `Decimal` that has the opposite sign of this `Decimal`.
-     * @example
-  ```js
-  let a = decimal('5')
-  a.negated()  // -5
-  ```
-     * @returns {Decimal}
-     */
-    negated() {
-        const negated = new Decimal();
-        negated.i = -this.i;
-        negated.e = this.e;
-        return negated;
-    }
-    /**
-     * Returns a new `Decimal` that is the sum of this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('50000000000')
-  let b = decimal('0.000000005')
-  a.add(b)  // 50000000000.000000005
-  ```
-     * @returns {Decimal}
-     */
-    add(x) {
-        let a = new Decimal(this);
-        let b = new Decimal(x);
-        // a+b = a.i * 10^a.e + b.i * 10^b.e
-        // a+b = ( a.i * 10^(a.e-b.e) + b.i ) * 10^b.e
-        const result = new Decimal();
-        // Order arguments so that a.e >= b.e
-        if (a.e < b.e) {
-            const c = a;
-            a = b;
-            b = c;
-        }
-        const intPart = exp(a.i, a.e - b.e);
-        result.i = intPart + b.i;
-        result.e = b.e;
-        result._normalize();
-        return result;
-    }
-    /**
-     * Returns a new `Decimal` that is the difference between this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('1')
-  let b = decimal('0.0000000000000000001')
-  a.sub(b)  // 0.9999999999999999999
-  ```
-     * @returns {Decimal}
-     */
-    sub(x) {
-        return this.add(decimal(x).negated());
-    }
-    /**
-     * Returns a new `Decimal` that is the product of this and `x`.
-     * @param x
-     * @example
-  ```js
-  let a = decimal('0.0000000000000000000025')
-  let b = decimal('400000000000000000000')
-  a.mul(b)  // 1
-  ```
-     * @returns {Decimal}
-     */
-    mul(x) {
-        const a = new Decimal(this);
-        const b = new Decimal(x);
-        // a * b = (a.i * b.i) * 10^(a.e + b.e)
-        const result = new Decimal();
-        result.i = a.i * b.i;
-        result.e = a.e + b.e;
-        result._normalize();
-        return result;
-    }
-    /**
-     * Returns a new `Decimal` that is the quotient of this and `x`
-     * @param x
-     * @example
-  ```js
-  let a = decimal('1')
-  let b = decimal('3')
-  a.div(b)  // 0.33333333333333333333
-  ```
-     * @returns {Decimal}
-     */
-    div(x) {
-        const a = new Decimal(this);
-        const b = new Decimal(x);
-        // We need to increase the number of digits of a and b so that a / b will have the desired precision.
-        // In order for the integer quotient to have the correct precision, a.e - b.e must be greater than that precision.
-        // So we need only to increase a.e.
-        // The quotient needs precision + a.e - b.e, and a negative a.e keeps the digits it always had
-        const increaseA = Math.max(Decimal.precision + Math.abs(a.e) - b.e, 0);
-        const intIncrease = new Decimal();
-        intIncrease.i = exp(a.i, increaseA);
-        const quotient = new Decimal();
-        quotient.i = intIncrease.i / b.i;
-        quotient.e = a.e - b.e - increaseA;
-        // No need to truncate since we already increased the number of digits before dividing
-        quotient._normalize();
-        return quotient;
-    }
-    /**
-     * Returns the square root of this `Decimal`.
-     * @returns {Decimal}
-     * @throws {ValueError} if this value is negative.
-     */
-    sqrt() {
-        if (this.i < 0n)
-            throw new ValueError('square root of a negative number');
-        Decimal.PRECISION++;
-        // Let the guess value be 10^(m/2), where m is the magnitude of this value
-        let x = new Decimal();
-        x.i = 1n;
-        x.e = Math.floor((this.e + this.i.toString().length) / 2);
-        const onehalf = new Decimal('0.5');
-        let xt = x.clone();
-        xt._truncate();
-        xt._normalize();
-        let lastxt;
-        let i;
-        for (i = 0; i < 100; i++) {
-            lastxt = xt;
-            x = this.div(x).add(x).mul(onehalf);
-            xt = x.clone();
-            xt._truncate();
-            xt._normalize();
-            if (xt.i === lastxt.i && xt.e === lastxt.e)
-                break;
-        }
-        if (i >= 100) {
-            console.log('Warning: sqrt exceeded maximum iterations. (Did it enter a cycle?)');
-        }
-        Decimal.PRECISION--;
-        xt._truncate();
-        xt._normalize();
-        // Rounding twice can leave the last digit one too high, so check it against the exact square
-        const half = new Decimal();
-        half.i = 5n;
-        half.e = -Decimal.PRECISION - 1;
-        const low = xt.sub(half);
-        if (low.gt(0) && low.mul(low).gt(this))
-            return low.sub(half);
-        return xt;
-    }
-    /** Returns a new copy of this Decimal value. */
-    clone() {
-        const a = new Decimal();
-        a.i = this.i;
-        a.e = this.e;
-        return a;
-    }
-    /**
-     * Remove zeroes in the least-significant digit of this `Decimal`
-     */
-    _normalize() {
-        if (this.i === 0n)
-            this.e = Math.min(this.e, 0);
-        if (this.i === 0n || this.i % 10n !== 0n)
-            return this;
-        const digits = this.i.toString();
-        let end = digits.length;
-        while (digits[end - 1] === '0')
-            end--;
-        this.i = BigInt(digits.slice(0, end));
-        this.e += digits.length - end;
-        return this;
-    }
-    /**
-     * Truncate this `Decimal` to the configured precision
-     */
-    _truncate() {
-        // TODO: Make this better
-        // TODO: Rounding
-        const trunc = -this.e - Decimal.PRECISION;
-        if (trunc > 0) {
-            this.i /= 10n ** BigInt(trunc - 1);
-            this.e += trunc;
-            const nextDigit = this.i % 10n;
-            if (nextDigit >= 5) {
-                this.i += 10n;
-            }
-            this.i /= 10n;
-        }
-        // while(-this.e > Decimal.PRECISION) {
-        //   this.i /= 10n;
-        //   this.e++;
-        // }
-        return this;
-    }
-    /**
-     * Returns a string representation of this decimal.
-     */
-    toString() {
-        let s = this.i.toString();
-        let m = '';
-        if (s[0] === '-') {
-            s = s.substring(1, s.length);
-            m = '-';
-        }
-        if (this.e > 0) {
-            return m + s + '0'.repeat(this.e);
-        }
-        else if (this.e < 0) {
-            if (-this.e >= s.length) {
-                return `${m}0.${'0'.repeat(-this.e - s.length)}${s}`;
-            }
-            return `${m}${s.slice(0, s.length + this.e)}.${s.slice(s.length + this.e, s.length)}`;
-        }
-        else {
-            return m + s;
-        }
-    }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.toString();
-    }
-    /**
-     * Converts this decimal to the `Number` value
-     * @returns {number}
-     */
-    toNumber() {
-        return Number(Decimal.prototype.toString.call(this));
-    }
-    static get precision() {
-        return Decimal.PRECISION;
-    }
-    static set precision(value) {
-        Decimal.PRECISION = value;
-    }
-    /**
-     * Returns `true` if this value is equal to the value of `x`, otherwise `false`.
-     * @param {*} x other
-     * @returns {boolean}
-     */
-    eq(x) {
-        if (x == null || typeof x === 'boolean')
-            return false;
-        let other;
-        try {
-            other = decimal(x);
-        }
-        catch {
-            return false;
-        }
-        return this.i === other.i && (this.e === other.e || this.i === 0n);
-    }
-    /**
-     * Returns `true` if this value is less than the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    lt(x) {
-        const other = decimal(x);
-        if (this.e === other.e)
-            return this.i < other.i;
-        const e = this.e - other.e;
-        if (e > 0) {
-            return exp(this.i, e) < other.i;
-        }
-        return this.i < exp(other.i, -e);
-    }
-    /**
-     * Returns a comparison value representing the ordering of this value in respect to `x`.
-     *   * `-1` if this < x
-     *   * `1` if this > x
-     *   * `0` if this == x
-     * @param {*} x
-     * @returns {number}
-     */
-    compare(x) {
-        const other = x == null || typeof x === 'boolean' ? decimal(x) : x;
-        if (this.eq(other))
-            return 0;
-        if (this.lt(other))
-            return -1;
-        return 1;
-    }
-    /**
-     * Returns `true` if this value is greater than the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    gt(x) {
-        return this.compare(x) > 0;
-    }
-    /**
-     * Returns `true` if this value is less than or equal to the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    lte(x) {
-        return this.compare(x) <= 0;
-    }
-    /**
-     * Returns `true` if this value is greater than or equal to the value of `x`, otherwise `false`.
-     * @param {*} x
-     * @returns {boolean}
-     */
-    gte(x) {
-        return this.compare(x) >= 0;
-    }
-}
-/** Returns a BigInt that is equal to `i` times `10^e` */
-function exp(i, e) {
-    return i * 10n ** BigInt(e);
-}
+export { Currency } from './currency.js';
+export { Decimal } from './decimal.js';

package/dist/decimal/internal/bits.d.ts

@@ -0,0 +1,2 @@
+/** Bit length of a non-negative bigint (0 for 0n), read from its hex form, not its binary one. */
+export declare function bitLength(n: bigint): number;

package/dist/decimal/internal/bits.js

@@ -0,0 +1,7 @@
+/** Bit length of a non-negative bigint (0 for 0n), read from its hex form, not its binary one. */
+export function bitLength(n) {
+    if (n === 0n)
+        return 0;
+    const hex = n.toString(16);
+    return (hex.length - 1) * 4 + (32 - Math.clz32(parseInt(hex[0], 16)));
+}

package/dist/decimal/internal/echo.d.ts

@@ -0,0 +1,4 @@
+/** UTF-16 units of bad input an error message repeats. */
+export declare const MAX_ECHO = 40;
+/** `value` quoted and cut to {@link MAX_ECHO} units. */
+export declare function quoteForError(value: string): string;

package/dist/decimal/internal/echo.js

@@ -0,0 +1,6 @@
+/** UTF-16 units of bad input an error message repeats. */
+export const MAX_ECHO = 40;
+/** `value` quoted and cut to {@link MAX_ECHO} units. */
+export function quoteForError(value) {
+    return `${JSON.stringify(value.slice(0, MAX_ECHO))}${value.length > MAX_ECHO ? '...' : ''}`;
+}

package/dist/decimal/internal/isqrt.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Floor integer square root via precision doubling.
+ * Below 2^52 uses `Math.sqrt` with an exact fix-up; larger n recurse on
+ * `n >> 2k` then one Newton step and one +-1 correction.
+ */
+export declare function isqrtRoot(n: bigint): {
+    root: bigint;
+    exact: boolean;
+};

package/dist/decimal/internal/isqrt.js

@@ -0,0 +1,34 @@
+import { bitLength } from './bits.js';
+/**
+ * Adjust `x` so `x*x <= n < (x+1)*(x+1)` (one +-1 step).
+ * Returns the root and whether `x*x === n` (avoids a second full square in callers).
+ */
+function isqrtFix(x, n) {
+    let y = x;
+    let y2 = y * y;
+    // Newton / Math.sqrt estimate is within 1 of the true floor root.
+    if (y2 > n) {
+        y--;
+        y2 = y * y;
+    }
+    else if (y2 + ((y << 1n) + 1n) <= n) {
+        y++;
+        y2 = y * y;
+    }
+    return { root: y, exact: y2 === n };
+}
+/**
+ * Floor integer square root via precision doubling.
+ * Below 2^52 uses `Math.sqrt` with an exact fix-up; larger n recurse on
+ * `n >> 2k` then one Newton step and one +-1 correction.
+ */
+export function isqrtRoot(n) {
+    if (n <= 1n)
+        return { root: n, exact: true };
+    if (n < 1n << 52n) {
+        return isqrtFix(BigInt(Math.floor(Math.sqrt(Number(n)))), n);
+    }
+    const k = Math.floor(bitLength(n) / 4);
+    const r = isqrtRoot(n >> BigInt(2 * k)).root << BigInt(k);
+    return isqrtFix((r + n / r) >> 1n, n);
+}

package/dist/decimal/internal/locale.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Canonical tags for `locales`; an empty list means the runtime's locale.
+ * @throws {TypeError} for an entry that is neither a string nor an `Intl.Locale`.
+ * @throws {RangeError} for a list longer than 255 characters, which the engine canonicalizes in
+ * quadratic time, or a malformed tag.
+ */
+export declare function canonicalLocales(locales: Intl.LocalesArgument): string[];

package/dist/decimal/internal/locale.js

@@ -0,0 +1,24 @@
+/** Longest locale list, joined, that `Intl` is asked to canonicalize. */
+const MAX_LOCALE_LENGTH = 255;
+/**
+ * Canonical tags for `locales`; an empty list means the runtime's locale.
+ * @throws {TypeError} for an entry that is neither a string nor an `Intl.Locale`.
+ * @throws {RangeError} for a list longer than 255 characters, which the engine canonicalizes in
+ * quadratic time, or a malformed tag.
+ */
+export function canonicalLocales(locales) {
+    if (locales === undefined)
+        return [];
+    const entries = Array.isArray(locales) ? locales : [locales];
+    const tags = entries.map((entry) => {
+        if (typeof entry === 'string')
+            return entry;
+        if (entry instanceof Intl.Locale)
+            return entry.toString();
+        throw new TypeError('locale must be a string or an Intl.Locale');
+    });
+    if (tags.join().length > MAX_LOCALE_LENGTH) {
+        throw new RangeError(`locale is longer than ${String(MAX_LOCALE_LENGTH)} characters`);
+    }
+    return Intl.getCanonicalLocales(tags);
+}

package/dist/decimal/internal/minor-units.d.ts

@@ -0,0 +1,2 @@
+/** The ISO 4217 minor-unit digits of an upper-case `code`, or undefined when it has none. */
+export declare function isoMinorUnits(code: string): number | undefined;