@signpostmarv/intermediary-number 0.6.2 → 0.6.3

package/lib/IntermediaryNumberTypes.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1 +0,0 @@
-export {};

package/lib/NumberStrings.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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!');
-        }
-    }
-}

package/lib/Numbers.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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;
-    }
-}