@signpostmarv/intermediary-number 0.1.0

package/lib/IntermediaryNumber.js

@@ -0,0 +1,529 @@
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import Fraction from 'fraction.js';
+import { is_string, } from './Docs.json';
+import { NumberStrings, } from './NumberStrings';
+import { TokenScan, } from './TokenScan';
+export const regex_recurring_number = /^-?(\d+\.)(\d+r|\d*\[\d+\]r?|\d*\(\d+\)r?)$/;
+function do_math(left_operand, operator, right_operand) {
+    return IntermediaryCalculation.maybe_reduce_operands(left_operand, operator, IntermediaryNumber.reuse_or_create(right_operand));
+}
+function abs(value) {
+    if (value.isZero()) {
+        return value;
+    }
+    return (value.isLessThan(0)
+        ? IntermediaryNumber.Zero.minus(value)
+        : value);
+}
+function compare(value, to) {
+    const comparable = IntermediaryNumber.reuse_or_create(value).toBigNumberOrFraction();
+    let result;
+    if (comparable instanceof BigNumber) {
+        result = to.toBigNumber().comparedTo(comparable);
+    }
+    else {
+        result = to.toFraction().compare(comparable);
+    }
+    assert.strictEqual((-1 === result
+        || 0 === result
+        || 1 === result), true, `Expecting -1, 0, or 1, receieved ${JSON.stringify(result)}`);
+    return result;
+}
+const conversion_cache = new class {
+    toAmountString_cache;
+    toBigNumber_cache;
+    toFraction_cache;
+    toString_cache;
+    get AmountString() {
+        if (!this.toAmountString_cache) {
+            this.toAmountString_cache = new WeakMap();
+        }
+        return this.toAmountString_cache;
+    }
+    get BigNumber() {
+        if (!this.toBigNumber_cache) {
+            this.toBigNumber_cache = new WeakMap();
+        }
+        return this.toBigNumber_cache;
+    }
+    get Fraction() {
+        if (!this.toFraction_cache) {
+            this.toFraction_cache = new WeakMap();
+        }
+        return this.toFraction_cache;
+    }
+    get String() {
+        if (!this.toString_cache) {
+            this.toString_cache = new WeakMap();
+        }
+        return this.toString_cache;
+    }
+    dispose(of) {
+        for (const cache of [
+            this.toAmountString_cache,
+            this.toBigNumber_cache,
+            this.toFraction_cache,
+            this.toString_cache,
+        ]) {
+            if (cache) {
+                cache.delete(of);
+            }
+        }
+    }
+};
+export function dispose(value) {
+    conversion_cache.dispose(value);
+}
+function max(first, second, ...remaining) {
+    let max = IntermediaryNumber.reuse_or_create(first);
+    for (const entry of [second, ...remaining]) {
+        const maybe = IntermediaryNumber.reuse_or_create(entry);
+        if (-1 === max.compare(maybe)) {
+            max = maybe;
+        }
+    }
+    return IntermediaryNumber.reuse_or_create(max);
+}
+export class IntermediaryNumber {
+    value;
+    static One = new this('1');
+    static Zero = new this('0');
+    constructor(value) {
+        this.value = value;
+    }
+    get resolve_type() {
+        return this.type;
+    }
+    get type() {
+        if (this.value instanceof BigNumber) {
+            return 'BigNumber';
+        }
+        else if (this.value instanceof Fraction) {
+            return 'Fraction';
+        }
+        else if (NumberStrings.is_amount_string(this.value)) {
+            return 'amount_string';
+        }
+        return 'numeric_string';
+    }
+    abs() {
+        return abs(this);
+    }
+    compare(value) {
+        return compare(value, this);
+    }
+    divide(value) {
+        return do_math(this, '/', value);
+    }
+    do_math_then_dispose(operator, right_operand) {
+        const result = this[operator](right_operand);
+        if (result !== this) {
+            dispose(this);
+        }
+        return result;
+    }
+    isGreaterThan(value) {
+        return 1 === this.compare(value);
+    }
+    isLessThan(value) {
+        return -1 === this.compare(value);
+    }
+    isOne() {
+        return 0 === this.compare(1);
+    }
+    isZero() {
+        return 0 === this.compare(0);
+    }
+    max(first, ...remaining) {
+        return max(this, first, ...remaining);
+    }
+    minus(value) {
+        return do_math(this, '-', value);
+    }
+    modulo(value) {
+        return do_math(this, '%', value);
+    }
+    plus(value) {
+        if (this.isZero()) {
+            return IntermediaryNumber.reuse_or_create(value);
+        }
+        return do_math(this, '+', value);
+    }
+    times(value) {
+        return do_math(this, 'x', value);
+    }
+    toAmountString() {
+        if (NumberStrings.is_amount_string(this.value)) {
+            return this.value;
+        }
+        return NumberStrings.round_off(this.toBigNumberOrFraction());
+    }
+    toBigNumber() {
+        if (this.value instanceof BigNumber) {
+            return this.value;
+        }
+        else if (this.value instanceof Fraction) {
+            return BigNumber(this.value.valueOf());
+        }
+        const cache = conversion_cache.BigNumber;
+        if (cache.has(this)) {
+            return cache.get(this);
+        }
+        const value = BigNumber(this.value);
+        cache.set(this, value);
+        return value;
+    }
+    toBigNumberOrFraction() {
+        return ('Fraction' === this.type)
+            ? this.toFraction()
+            : this.toBigNumber();
+    }
+    toFraction() {
+        if (this.value instanceof Fraction) {
+            return this.value;
+        }
+        const cache = conversion_cache.Fraction;
+        if (cache.has(this)) {
+            return cache.get(this);
+        }
+        const value = new Fraction(this.toString());
+        cache.set(this, value);
+        return value;
+    }
+    toJSON() {
+        if (this.isOne()) {
+            return {
+                type: 'IntermediaryNumber',
+                value: '1',
+            };
+        }
+        else if (this.isZero()) {
+            return {
+                type: 'IntermediaryNumber',
+                value: '0',
+            };
+        }
+        if (this.value instanceof Fraction) {
+            const [left, right] = this.value.toFraction().split('/');
+            if (undefined === right) {
+                return {
+                    type: 'IntermediaryNumber',
+                    value: left,
+                };
+            }
+            return {
+                type: 'IntermediaryCalculation',
+                left: {
+                    type: 'IntermediaryNumber',
+                    value: left,
+                },
+                operation: '/',
+                right: {
+                    type: 'IntermediaryNumber',
+                    value: right,
+                },
+            };
+        }
+        else if (this.value instanceof BigNumber) {
+            return {
+                type: 'IntermediaryNumber',
+                value: this.value.toFixed(),
+            };
+        }
+        return {
+            type: 'IntermediaryNumber',
+            value: this.value,
+        };
+    }
+    toString() {
+        if (this.value instanceof BigNumber) {
+            return this.value.toFixed();
+        }
+        return this.value.toString();
+    }
+    static create(input) {
+        if ('' === input) {
+            return IntermediaryNumber.Zero;
+        }
+        if (input instanceof Fraction) {
+            return new this(input.simplify(1 / (2 ** 52)));
+        }
+        if (input instanceof BigNumber
+            || NumberStrings.is_numeric_string(input)) {
+            return new this(input);
+        }
+        else if ('number' === typeof input) {
+            return new this(BigNumber(input));
+        }
+        else if (is_string(input) && regex_recurring_number.test(input)) {
+            let only_last_digit_recurring = false;
+            if (/^\d*\.\d+r$/.test(input)) {
+                only_last_digit_recurring = true;
+            }
+            if (input.endsWith('r')) {
+                input = input.substring(0, input.length - 1);
+            }
+            if (only_last_digit_recurring) {
+                input = input.replace(/(\d)$/, '($1)');
+            }
+            else if (input.includes('[')) {
+                input = input.replace(/\[(\d+)\]/, '($1)');
+            }
+            return new this(new Fraction(input));
+        }
+        throw new Error('Unsupported argument specified!');
+    }
+    static create_if_valid(input) {
+        const maybe = input.trim();
+        if (NumberStrings.is_amount_string(maybe)
+            || NumberStrings.is_numeric_string(maybe)) {
+            return IntermediaryNumber.create(maybe);
+        }
+        else if (/^(\d+|\d*\.\d+)\s*[+/*x%-]\s*(\d+|\d*\.\d+)$/.test(maybe)) {
+            return (new TokenScan(input)).parsed;
+        }
+        const scientific = /^(-?\d+(?:\.\d+))e([+-])(\d+)$/.exec(maybe);
+        if (scientific) {
+            const calc = new IntermediaryCalculation(IntermediaryNumber.Zero, scientific[2], IntermediaryNumber.create(scientific[3])).toBigNumber();
+            return IntermediaryNumber.create(scientific[1]).times((new BigNumber(10)).pow(calc));
+        }
+        try {
+            return IntermediaryCalculation.fromString(maybe);
+        }
+        catch (err) {
+            return new NotValid(maybe, err);
+        }
+    }
+    static fromJson(json) {
+        if ('IntermediaryNumber' === json.type) {
+            return this.create(json.value);
+        }
+        return new IntermediaryCalculation(this.fromJson(json.left), json.operation, this.fromJson(json.right));
+    }
+    static reuse_or_create(input) {
+        return (((input instanceof IntermediaryNumber)
+            || (input instanceof IntermediaryCalculation))
+            ? input
+            : this.create(input));
+    }
+}
+export class NotValid extends Error {
+    reason;
+    value;
+    constructor(not_valid, reason) {
+        super('Value given was not valid!');
+        this.value = not_valid;
+        this.reason = reason;
+    }
+}
+const BigNumber_operation_map = {
+    '+': (a, b) => a.plus(b),
+    '-': (a, b) => a.minus(b),
+    'x': (a, b) => a.times(b),
+    '*': (a, b) => a.times(b),
+    '%': (a, b) => a.modulo(b),
+};
+const Fraction_operation_map = {
+    '+': (a, b) => a.add(b),
+    '-': (a, b) => a.sub(b),
+    'x': (a, b) => a.mul(b),
+    '*': (a, b) => a.mul(b),
+    '/': (a, b) => a.div(b),
+    '%': (a, b) => a.mod(b),
+};
+export class IntermediaryCalculation {
+    left_operand;
+    operation;
+    right_operand;
+    constructor(left, operation, right) {
+        this.left_operand = left;
+        this.operation = operation;
+        this.right_operand = right;
+    }
+    get left_type() {
+        if (this.left_operand instanceof IntermediaryCalculation) {
+            return 'IntermediaryCalculation';
+        }
+        return this.left_operand.type;
+    }
+    get resolve_type() {
+        return `${this.left_type} ${this.operation} ${this.right_type}`;
+    }
+    get right_type() {
+        if (this.right_operand instanceof IntermediaryCalculation) {
+            return 'IntermediaryCalculation';
+        }
+        return this.right_operand.type;
+    }
+    get type() {
+        return 'IntermediaryCalculation';
+    }
+    abs() {
+        return abs(this);
+    }
+    compare(value) {
+        return compare(value, this);
+    }
+    divide(value) {
+        return do_math(this, '/', value);
+    }
+    do_math_then_dispose(operator, right_operand) {
+        const result = this[operator](right_operand);
+        if (result !== this) {
+            dispose(this);
+        }
+        return result;
+    }
+    isGreaterThan(value) {
+        return 1 === this.compare(value);
+    }
+    isLessThan(value) {
+        return -1 === this.compare(value);
+    }
+    isOne() {
+        return 0 === this.compare(1);
+    }
+    isZero() {
+        return 0 === this.compare(0);
+    }
+    max(first, ...remaining) {
+        return max(this, first, ...remaining);
+    }
+    minus(value) {
+        return do_math(this, '-', value);
+    }
+    modulo(value) {
+        return do_math(this, '%', value);
+    }
+    plus(value) {
+        if (this.isZero()) {
+            return IntermediaryNumber.reuse_or_create(value);
+        }
+        return do_math(this, '+', value);
+    }
+    resolve() {
+        const left_operand = this.operand_to_IntermediaryNumber(this.left_operand);
+        const right_operand = this.operand_to_IntermediaryNumber(this.right_operand);
+        const left = left_operand.toBigNumberOrFraction();
+        const right = right_operand.toBigNumberOrFraction();
+        if ('/' === this.operation
+            || left instanceof Fraction
+            || right instanceof Fraction) {
+            return IntermediaryNumber.create(Fraction_operation_map[this.operation](((left instanceof BigNumber)
+                ? left_operand.toFraction()
+                : left), ((right instanceof BigNumber)
+                ? right_operand.toFraction()
+                : right)));
+        }
+        return IntermediaryNumber.create(BigNumber_operation_map[this.operation](left, right));
+    }
+    times(value) {
+        return do_math(this, 'x', value);
+    }
+    toAmountString() {
+        const cache = conversion_cache.AmountString;
+        if (cache.has(this)) {
+            return cache.get(this);
+        }
+        const value = this.resolve().toAmountString();
+        cache.set(this, value);
+        return value;
+    }
+    toBigNumber() {
+        const cache = conversion_cache.BigNumber;
+        if (cache.has(this)) {
+            return cache.get(this);
+        }
+        const value = this.resolve().toBigNumber();
+        cache.set(this, value);
+        return value;
+    }
+    toBigNumberOrFraction() {
+        return this.resolve().toBigNumberOrFraction();
+    }
+    toFraction() {
+        const cache = conversion_cache.Fraction;
+        if (cache.has(this)) {
+            return cache.get(this);
+        }
+        const value = this.resolve().toFraction();
+        cache.set(this, value);
+        return value;
+    }
+    toJSON() {
+        const left = this.operand_to_IntermediaryNumber(this.left_operand);
+        const right = this.operand_to_IntermediaryNumber(this.right_operand);
+        const maybe = IntermediaryCalculation.maybe_short_circuit(left, this.operation, right);
+        if (maybe) {
+            return maybe.toJSON();
+        }
+        return {
+            type: 'IntermediaryCalculation',
+            left: left.toJSON(),
+            operation: this.operation,
+            right: right.toJSON(),
+        };
+    }
+    toString() {
+        const cache = conversion_cache.String;
+        if (cache.has(this)) {
+            return cache.get(this);
+        }
+        const value = this.resolve().toString();
+        cache.set(this, value);
+        return value;
+    }
+    operand_to_IntermediaryNumber(operand) {
+        if ((operand instanceof IntermediaryCalculation)) {
+            return operand.resolve();
+        }
+        else if ('amount_string' === operand.type
+            || 'numeric_string' === operand.type) {
+            return IntermediaryNumber.create('/' === this.operation
+                ? operand.toFraction()
+                : operand.toBigNumberOrFraction());
+        }
+        return operand;
+    }
+    static fromString(input) {
+        return (new TokenScan(input)).parsed;
+    }
+    static maybe_reduce_operands(left, operation, right) {
+        let value = this.maybe_short_circuit(left, operation, right);
+        if (undefined === value) {
+            value = new IntermediaryCalculation(left, operation, right);
+        }
+        if (value instanceof IntermediaryCalculation) {
+            return value.resolve();
+        }
+        return value;
+    }
+    static maybe_short_circuit(left, operation, right) {
+        let value = undefined;
+        if ('+' === operation) {
+            if (left.isZero()) {
+                value = right;
+            }
+            else if (right.isZero()) {
+                value = left;
+            }
+        }
+        else if ('-' === operation && right.isZero()) {
+            value = left;
+        }
+        else if ('*x'.includes(operation)) {
+            if (left.isZero() || right.isOne()) {
+                value = left;
+            }
+            else if (right.isZero() || left.isOne()) {
+                value = right;
+            }
+        }
+        else if ('/' === operation && right.isOne()) {
+            value = left;
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=IntermediaryNumber.js.map

package/lib/IntermediaryNumberTypes.d.ts

@@ -0,0 +1,6 @@
+import BigNumber from "bignumber.js";
+import Fraction from "fraction.js";
+import { numeric_string } from './NumberStrings';
+export type input_types = BigNumber | Fraction | number | string;
+export type value_types = BigNumber | Fraction | numeric_string;
+export type type_property_types = 'BigNumber' | 'Fraction' | 'amount_string' | 'numeric_string';

package/lib/IntermediaryNumberTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IntermediaryNumberTypes.js.map

package/lib/NumberStrings.d.ts

@@ -0,0 +1,14 @@
+import { integer_string__type, StringPassedRegExp } from './Docs.json';
+import BigNumber from 'bignumber.js';
+import Fraction from 'fraction.js';
+import type { operand_types } from './IntermediaryNumber';
+export type amount_string = StringPassedRegExp<'^\\d+(?:\\.\\d{1,6})?$'> | integer_string__type | '1' | '0';
+export type numeric_string = amount_string | StringPassedRegExp<'^-?(?:\\d*\\.\\d+|\\d+(?:\\.\\d+)?)$'>;
+export declare class NumberStrings {
+    static amount_string(maybe: string): amount_string;
+    static is_amount_string(maybe: unknown): maybe is amount_string;
+    static is_numeric_string(maybe: unknown): maybe is numeric_string;
+    static round_off(number: BigNumber | Fraction | operand_types): amount_string;
+    private static configure;
+    private static throw_if_not_amount_string;
+}

package/lib/NumberStrings.js

@@ -0,0 +1,54 @@
+import { is_string, NotAnAmountString, } from './Docs.json';
+import BigNumber from 'bignumber.js';
+import Fraction from 'fraction.js';
+export class NumberStrings {
+    static amount_string(maybe) {
+        this.throw_if_not_amount_string(maybe);
+        return maybe;
+    }
+    static is_amount_string(maybe) {
+        return (is_string(maybe)
+            && (maybe === '0'
+                || /^\d+(?:\.\d{1,6})?$/.test(maybe)
+                || /^\d*(?:\.\d{1,6})$/.test(maybe)
+                || /^\d+$/.test(maybe)));
+    }
+    static is_numeric_string(maybe) {
+        return (this.is_amount_string(maybe)
+            || (is_string(maybe)
+                && /^-?(?:\d*\.\d+|\d+(?:\.\d+)?)$/.test(maybe)));
+    }
+    static round_off(number) {
+        let result;
+        number = ((number instanceof BigNumber)
+            || (number instanceof Fraction))
+            ? number
+            : number.toBigNumberOrFraction();
+        if (number instanceof BigNumber) {
+            this.configure();
+            result = number.toString();
+        }
+        else {
+            result = number.valueOf().toString();
+        }
+        if (/\.\d{7,}$/.test(result)) {
+            const [before, after] = result.split('.');
+            return `${before}.${'0' === after.substring(6, 7)
+                ? after.substring(0, 6).replace(/0+$/, '')
+                : (parseInt(after.substring(0, 6), 10) + 1).toString().padStart(Math.min(6, after.length), '0')}`.replace(/\.$/, '');
+        }
+        return result;
+    }
+    static configure() {
+        BigNumber.set({
+            DECIMAL_PLACES: 7,
+            ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL,
+        });
+    }
+    static throw_if_not_amount_string(maybe) {
+        if (!this.is_amount_string(maybe)) {
+            throw new NotAnAmountString('Not a supported amount string!');
+        }
+    }
+}
+//# sourceMappingURL=NumberStrings.js.map

package/lib/Numbers.d.ts

@@ -0,0 +1,15 @@
+import BigNumber from 'bignumber.js';
+import Fraction from 'fraction.js';
+import { math_types, operand_types } from './IntermediaryNumber';
+import { amount_string } from './NumberStrings';
+export type number_arg = BigNumber | number | amount_string;
+export declare class Numbers {
+    static divide_if_not_one(left: math_types, right: Fraction, require_fraction: true): Fraction;
+    static divide_if_not_one(left: math_types, right: Fraction, require_fraction: false): Fraction | math_types;
+    static least_common_multiple_deferred(numbers: [
+        (number_arg | operand_types),
+        (number_arg | operand_types),
+        ...(number_arg | operand_types)[]
+    ]): (Fraction);
+    static sum_series_fraction(a: Fraction, b: Fraction): Fraction;
+}

package/lib/Numbers.js

@@ -0,0 +1,50 @@
+import assert from 'assert';
+import Fraction from 'fraction.js';
+import { IntermediaryNumber, } from './IntermediaryNumber';
+export class Numbers {
+    static divide_if_not_one(left, right, require_fraction) {
+        const result = (0 === right.compare(1))
+            ? left
+            : IntermediaryNumber.reuse_or_create(left).divide(right);
+        return require_fraction
+            ? ((result instanceof Fraction)
+                ? result
+                : IntermediaryNumber.reuse_or_create(result).toFraction())
+            : result;
+    }
+    static least_common_multiple_deferred(numbers) {
+        if (2 === numbers.length) {
+            return (IntermediaryNumber.reuse_or_create(numbers[0]).toFraction().lcm(IntermediaryNumber.reuse_or_create(numbers[1]).toFraction()));
+        }
+        return (numbers.map(e => IntermediaryNumber.reuse_or_create(e).toFraction()).reduce(
+        // based on https://www.npmjs.com/package/mlcm?activeTab=code
+        (was, is) => {
+            return was.mul(is).abs().div(was.gcd(is));
+        }));
+    }
+    static sum_series_fraction(a, b) {
+        assert.strictEqual(b.compare(a), -1, `Expecting ${b.toString()} to be less than ${a.toString()}`);
+        // adapted from @stdlib/math-base-tools-sum-series
+        const tolerance = (new Fraction(1)).div((new Fraction(2)).pow(52));
+        let counter = 10000000;
+        const divisor = a.div(b);
+        function calculate(number) {
+            let previous = number;
+            return () => {
+                const next = previous.div(divisor);
+                previous = next;
+                return next;
+            };
+        }
+        const generator = calculate(a);
+        let next_term;
+        let result = a;
+        do {
+            next_term = generator();
+            result = result.add(next_term.simplify(tolerance.valueOf()));
+        } while ((-1 === tolerance.mul(result).abs().compare(next_term.abs()))
+            && --counter);
+        return result;
+    }
+}
+//# sourceMappingURL=Numbers.js.map