@signpostmarv/intermediary-number 0.5.2 → 0.6.1

package/lib/IntermediaryNumber.d.ts

@@ -21,7 +21,7 @@ export type CanConvertTypeJson = {
 };
 export type CanDoMathWithDispose_operator_types = 'divide' | 'minus' | 'modulo' | 'plus' | 'times';
 export type operand_types = IntermediaryNumber | IntermediaryCalculation | TokenScan;
-type TokenSpan_types = 'ignore' | 'nesting_open' | 'nesting_close' | 'numeric' | 'operation';
+type TokenSpan_types = 'ignore' | 'nesting_open' | 'nesting_close' | 'numeric' | 'operation' | 'Infinity';
 type TokenSpan_types_part_baked = Exclude<TokenSpan_types, 'ignore'>;
 type TokenScan_internals = {
     parsed: IntermediaryNumber | IntermediaryCalculation | undefined;
@@ -111,6 +111,15 @@ export declare class IntermediaryNumber implements CanDoMathWithDispose {
     static fromJson(json: CanConvertTypeJson): CanDoMath_result_types;
     static reuse_or_create(input: operand_types | input_types): operand_types;
 }
+export declare class IntermediaryNumberInfinity extends IntermediaryNumber {
+    static readonly One: IntermediaryNumberInfinity;
+    static readonly Zero: IntermediaryNumberInfinity;
+    isOne(): boolean;
+    isZero(): boolean;
+    toFraction(): Fraction;
+    toString(): string;
+    toStringCalculation(): string;
+}
 export declare class NotValid extends Error {
     readonly reason: unknown;
     readonly value: string;
@@ -121,6 +130,7 @@ export declare class IntermediaryCalculation implements CanResolveMathWithDispos
     readonly operation: operation_types;
     readonly right_operand: operand_types;
     constructor(left: operand_types, operation: operation_types, right: operand_types);
+    get has_infinity(): boolean;
     get left_type(): operand_type_property_types;
     get resolve_type(): string;
     get right_type(): operand_type_property_types;

package/lib/IntermediaryNumber.js

@@ -115,6 +115,9 @@ function is_nesting_close(maybe) {
 function is_numeric(maybe) {
     return 'numeric' === maybe.type;
 }
+function is_infinity(maybe) {
+    return 'Infinity' === maybe.type;
+}
 export function is_operation_value(maybe) {
     if (!(maybe.length === 1
         && '+-/x*%'.includes(maybe))) {
@@ -317,6 +320,9 @@ export class IntermediaryNumber {
             }
             return new this(new Fraction(input));
         }
+        else if ('Infinity' === input) {
+            return new IntermediaryNumberInfinity(new BigNumber('Infinity'));
+        }
         throw new Error('Unsupported argument specified!');
     }
     static create_if_valid(input) {
@@ -358,6 +364,27 @@ export class IntermediaryNumber {
     }
 }
 //#endregion
+//#region IntermediaryNumberInfinity
+export class IntermediaryNumberInfinity extends IntermediaryNumber {
+    static One = new this(new BigNumber('Infinity'));
+    static Zero = new this(new BigNumber('Infinity'));
+    isOne() {
+        return false;
+    }
+    isZero() {
+        return false;
+    }
+    toFraction() {
+        throw new Error('Cannot convert infinity to Fraction');
+    }
+    toString() {
+        return 'Infinity';
+    }
+    toStringCalculation() {
+        return 'Infinity';
+    }
+}
+//#endregion
 //#region IntermediaryCalculation
 export class NotValid extends Error {
     reason;
@@ -392,6 +419,10 @@ export class IntermediaryCalculation {
         this.operation = operation;
         this.right_operand = right;
     }
+    get has_infinity() {
+        return (this.left_operand instanceof IntermediaryNumberInfinity
+            || this.right_operand instanceof IntermediaryNumberInfinity);
+    }
     get left_type() {
         if (this.left_operand instanceof IntermediaryCalculation) {
             return 'IntermediaryCalculation';
@@ -457,6 +488,10 @@ export class IntermediaryCalculation {
         return do_math(this, '+', value);
     }
     resolve() {
+        const reduced = IntermediaryCalculation.maybe_short_circuit(this.left_operand, this.operation, this.right_operand);
+        if (reduced instanceof IntermediaryNumber) {
+            return reduced;
+        }
         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();
@@ -464,6 +499,12 @@ export class IntermediaryCalculation {
         if ('/' === this.operation
             || left instanceof Fraction
             || right instanceof Fraction) {
+            if (left_operand instanceof IntermediaryNumberInfinity) {
+                return left_operand;
+            }
+            else if (right_operand instanceof IntermediaryNumberInfinity) {
+                return right_operand;
+            }
             return IntermediaryNumber.create(Fraction_operation_map[this.operation](((left instanceof BigNumber)
                 ? left_operand.toFraction()
                 : left), ((right instanceof BigNumber)
@@ -506,8 +547,14 @@ export class IntermediaryCalculation {
         return value;
     }
     toJSON() {
-        const left = this.operand_to_IntermediaryNumber(this.left_operand);
-        const right = this.operand_to_IntermediaryNumber(this.right_operand);
+        const left = (this.left_operand instanceof IntermediaryCalculation
+            && this.left_operand.has_infinity)
+            ? this.left_operand
+            : this.operand_to_IntermediaryNumber(this.left_operand);
+        const right = (this.right_operand instanceof IntermediaryCalculation
+            && this.right_operand.has_infinity)
+            ? this.right_operand
+            : this.operand_to_IntermediaryNumber(this.right_operand);
         const maybe = IntermediaryCalculation.maybe_short_circuit(left, this.operation, right);
         if (maybe) {
             return maybe.toJSON();
@@ -571,6 +618,55 @@ export class IntermediaryCalculation {
     }
     static maybe_short_circuit(left, operation, right) {
         let value = undefined;
+        if (left instanceof IntermediaryNumberInfinity
+            && right instanceof IntermediaryNumberInfinity) {
+            if ('+' === operation
+                || '*' === operation) {
+                // infinity plus or multiplied by infintiy is infinity
+                return left;
+            }
+            else if ('-' === operation) {
+                return IntermediaryNumber.Zero;
+            }
+            else if ('/' === operation) {
+                return IntermediaryNumber.One;
+            }
+        }
+        if (left instanceof IntermediaryCalculation
+            && left.has_infinity
+            && (('+' === left.operation
+                && '-' === operation)
+                || ('-' === left.operation
+                    && '+' === operation))
+            && (right instanceof IntermediaryNumberInfinity)
+            && (!(left.left_operand instanceof IntermediaryNumberInfinity)
+                || !(left.right_operand instanceof IntermediaryNumberInfinity))) {
+            return (left.left_operand instanceof IntermediaryNumberInfinity
+                ? left.right_operand
+                : left.left_operand);
+        }
+        else if (right instanceof IntermediaryCalculation
+            && right.has_infinity
+            && (('+' === right.operation
+                && '-' === operation)
+                || ('-' === right.operation
+                    && '+' === operation))
+            && (left instanceof IntermediaryNumberInfinity)
+            && (!(right.left_operand instanceof IntermediaryNumberInfinity)
+                || !(right.right_operand instanceof IntermediaryNumberInfinity))) {
+            return (right.left_operand instanceof IntermediaryNumberInfinity
+                ? right.right_operand
+                : right.left_operand);
+        }
+        else if ('/' === operation
+            && !right.isOne()
+            && left instanceof IntermediaryCalculation
+            && left.has_infinity
+            && !(left.left_operand instanceof IntermediaryNumberInfinity)
+            && '*x'.includes(left.operation)
+            && right instanceof IntermediaryNumberInfinity) {
+            return left.left_operand;
+        }
         if ('+' === operation) {
             if (left.isZero()) {
                 value = right;
@@ -811,6 +907,9 @@ export class TokenScan {
         for (const entry of value.matchAll(/(\))/g)) {
             tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'nesting_close'));
         }
+        for (const entry of value.matchAll(/(\bInfinity\b)/g)) {
+            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'Infinity'));
+        }
         tokens = tokens.sort((a, b) => {
             return a.from - b.from;
         });
@@ -974,7 +1073,7 @@ export class TokenScan {
                 }
             }
         }
-        else if (is_numeric(is)) {
+        else if (is_numeric(is) || is_infinity(is)) {
             if ('left' === was.operand_mode) {
                 was.left_operand = IntermediaryNumber.create(value.substring(is.from, is.to));
                 was.operand_mode = 'right';

package/package.json

@@ -27,5 +27,5 @@
 		"bignumber.js": "^9.1.2",
 		"fraction.js": "^4.3.7"
 	},
-	"version": "0.5.2"
+	"version": "0.6.1"
 }