pimath 0.0.26 → 0.0.30

package/src/maths/numexp.ts

@@ -0,0 +1,138 @@
+import {Shutingyard, ShutingyardMode, ShutingyardType, tokenConstant} from "./shutingyard";
+import {Fraction} from "./coefficients";
+
+export class NumExp {
+    private _rpn: { token: string, tokenType: string }[]
+    private _expression: string
+
+    constructor(value: string) {
+        this._expression = value
+        this._rpn = new Shutingyard(ShutingyardMode.NUMERIC).parse(value).rpn
+    }
+
+    get rpn(): { token: string; tokenType: string }[] {
+        return this._rpn;
+    }
+
+    get expression(): string {
+        return this._expression;
+    }
+
+    private _extractDecimalPart(value: number): string {
+        let decimal = value.toString()
+
+        if (!decimal.includes('.')) {
+            return ''
+        }
+
+        decimal = decimal.split('.')[1]
+
+        return decimal.substring(0, decimal.length - 2)
+    }
+
+    private _numberCorrection(value: number): number {
+        // Must modify the number if it's like:
+        // a: 3.0000000000000003
+        // b: 3.9999999999999994
+        // remove the last character
+        // check if around n last characters are either 0 or 9
+        // if it is, 'round' the number.
+
+        const epsilon = 0.00000000000001,
+            number_of_digits = 6
+
+        let decimal = this._extractDecimalPart(value)
+        if(decimal===''){return value}
+
+        const n9 = decimal.match(/9+$/g)
+        const n0 = decimal.match(/0+$/g)
+
+        if (n9 && n9[0].length >= number_of_digits) {
+            // New tested values.
+            let mod = this._extractDecimalPart(value + epsilon),
+                mod0 = mod.match(/0+$/g)
+
+            if(mod0 && mod0[0].length>= number_of_digits){
+                // The value can be changed. Remove all zeros!
+                return +((value+epsilon).toString().split(mod0[0])[0])
+            }
+        }
+
+        if (n0 && n0[0].length >= number_of_digits) {
+            // New tested values.
+            let mod = this._extractDecimalPart(value - epsilon),
+                mod9 = mod.match(/9+$/g)
+
+            if(mod9 && mod9[0].length>= number_of_digits){
+                // The value can be changed. Remove all nines!
+                return +(value.toString().split(n0[0])[0])
+            }
+        }
+
+        return value
+    }
+
+    private _addToStack(stack:number[], value: number): void {
+        stack.push(this._numberCorrection(value))
+    }
+
+    evaluate(values: { [Key: string]: number }): number {
+        let stack: number[] = []
+        for (const element of this._rpn) {
+            if (element.tokenType === ShutingyardType.COEFFICIENT) {
+                // May be a numeric value or a Fraction.
+                if (!isNaN(+element.token)) {
+                    this._addToStack(stack, +element.token)
+                } else {
+                    this._addToStack(stack, new Fraction(element.token).value)
+                }
+            } else if (element.tokenType === ShutingyardType.VARIABLE) {
+                if (values[element.token] !== undefined) {
+                    this._addToStack(stack, +values[element.token])
+                }
+            } else if (element.tokenType === ShutingyardType.CONSTANT) {
+                this._addToStack(stack, tokenConstant[element.token])
+            } else if (element.tokenType === ShutingyardType.OPERATION) {
+                if (element.token === '*') {
+                    const b = +stack.pop(),
+                        a = +stack.pop()
+                    this._addToStack(stack, a * b)
+                } else if (element.token === '/') {
+                    const b = +stack.pop(),
+                        a = +stack.pop()
+                    this._addToStack(stack, a / b)
+                } else if (element.token === '+') {
+                    const b = +stack.pop(),
+                        a = +stack.pop()
+                    this._addToStack(stack, a + b)
+                } else if (element.token === '-') {
+                    const b = +stack.pop(),
+                        a = +stack.pop() || 0
+                    this._addToStack(stack, a - b)
+                } else if (element.token === '^') {
+                    const b = +stack.pop(),
+                        a = +stack.pop()
+                    this._addToStack(stack, Math.pow(a, b))
+                }
+            } else if (element.tokenType === ShutingyardType.FUNCTION) {
+                const a = +stack.pop()
+                if (element.token === 'sin') {
+                    this._addToStack(stack, Math.sin(a))
+                } else if (element.token === 'cos') {
+                    this._addToStack(stack, Math.cos(a))
+                } else if (element.token === 'tan') {
+                    this._addToStack(stack, Math.tan(a))
+                } else if(element.token === 'sqrt') {
+                    this._addToStack(stack, Math.sqrt(a))
+                }
+            }
+        }
+
+        if (stack.length === 1) {
+            return stack[0]
+        } else {
+            console.error('There was a problem parsing', this._expression, '. The RPN array is', this._rpn)
+            return 0
+        }
+    }
+}

package/src/maths/shutingyard.ts

@@ -1,20 +1,42 @@
 import {loadHighlighter} from "typedoc/dist/lib/utils/highlighter";
+import exp = require("constants");
 
 type tokenType = {
     [key: string]: {
         precedence: number,
-        associative: string
+        associative: string,
+        type: string
     }
 }
 
+export const tokenConstant:{[Key:string]:number} = {
+    pi: Math.PI,
+    e: Math.exp(1)
+}
+export enum ShutingyardType {
+    VARIABLE='variable',
+    COEFFICIENT='coefficient',
+    OPERATION = 'operation',
+    CONSTANT = 'constant',
+    FUNCTION = 'function',
+    MONOM = 'monom'
+}
+export enum ShutingyardMode {
+    POLYNOM= 'polynom',
+    SET = 'set',
+    NUMERIC = 'numeric'
+}
+
 export class Shutingyard {
     private _rpn: { token: string, tokenType: string }[] = [];
-    readonly _mode: 'polynom' | 'set';
+    readonly _mode: ShutingyardMode;
     private _tokenConfig: tokenType;
+    private _tokenConstant: {[Key:string]: number}
     private _uniformize: boolean;
+    private _tokenKeys: string[]
 
-    constructor(mode?: 'polynom' | 'set') {
-        this._mode = typeof mode === 'undefined' ? 'polynom' : mode;
+    constructor(mode?: ShutingyardMode ) {
+        this._mode = typeof mode === 'undefined' ? ShutingyardMode.POLYNOM : mode;
         this.tokenConfigInitialization()
     }
 
@@ -23,41 +45,57 @@ export class Shutingyard {
      * Defined operations: + - * / ^ sin cos tan
      * @param token
      */
-    isOperation(token: string): boolean {
-        if (token[0].match(/[+\-*/^]/g)) {
-            return true;
-        }
-        //
-        // if (token.match(/^sin|cos|tan/g)) {
-        //     return true;
-        // }
-
-        return false;
-    }
+    // isOperation(token: string): boolean {
+    //     if (token[0].match(/[+\-*/^]/g)) {
+    //         return true;
+    //     }
+    //     //
+    //     // if (token.match(/^sin|cos|tan/g)) {
+    //     //     return true;
+    //     // }
+    //
+    //     return false;
+    // }
 
     tokenConfigInitialization(): tokenType {
-        if (this._mode === 'set') {
+        if (this._mode === ShutingyardMode.SET) {
             this._tokenConfig = {
-                '&': {precedence: 3, associative: 'left'},
-                '|': {precedence: 3, associative: 'left'},
-                '!': {precedence: 4, associative: 'right'},
-                '-': {precedence: 2, associative: 'left'}
+                '&': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '|': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '!': {precedence: 4, associative: 'right', type: ShutingyardType.OPERATION},
+                '-': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION}
             }
             this._uniformize = false;
+        }else if (this._mode === ShutingyardMode.NUMERIC){
+            this._tokenConfig = {
+                '^': {precedence: 4, associative: 'right', type: ShutingyardType.OPERATION},
+                '*': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '/': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '+': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
+                '-': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
+                '%': {precedence: 3, associative: 'right', type: ShutingyardType.OPERATION},
+                'sin': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'sqrt': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+            }
+            this._uniformize = false
         } else {
             this._tokenConfig = {
-                '^': {precedence: 4, associative: 'right'},
-                '*': {precedence: 3, associative: 'left'},
-                '/': {precedence: 3, associative: 'left'},
-                '+': {precedence: 2, associative: 'left'},
-                '-': {precedence: 2, associative: 'left'},
-                '%': {precedence: 3, associative: 'right'},
-                'sin': {precedence: 4, associative: 'right'},
-                'cos': {precedence: 4, associative: 'right'},
-                'tab': {precedence: 4, associative: 'right'},
+                '^': {precedence: 4, associative: 'right', type: ShutingyardType.OPERATION},
+                '*': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '/': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '+': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
+                '-': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
+                '%': {precedence: 3, associative: 'right', type: ShutingyardType.OPERATION},
+                'sin': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
             }
             this._uniformize = true
         }
+
+        this._tokenKeys = Object.keys(this._tokenConfig).sort((a,b)=>b.length-a.length)
         return this._tokenConfig
     }
 
@@ -66,7 +104,7 @@ export class Shutingyard {
      * @param expr (string) Expression to analyse
      * @param start (number) CUrrent position in the expr string.
      */
-    NextToken2(expr: string, start: number): [string, number, string] {
+    NextToken(expr: string, start: number): [string, number, string] {
         let token: string, tokenType: string;
         token = '';
         tokenType = '';
@@ -86,12 +124,23 @@ export class Shutingyard {
             tokenType = 'function-argument';
         } else{
             // Order token keys by token characters length (descending)
-            const keys = Object.keys(this._tokenConfig).sort((a,b)=>b.length-a.length)
+            // TODO: this is done each time ! SHould be done once !
+            // const keys = Object.keys(this._tokenConfig).sort((a,b)=>b.length-a.length)
+
+            // Extract operation and function tokens
+            for(let key of this._tokenKeys){
+                if(expr.substring(start, start+key.length) === key){
+                    token += key;
+                    tokenType = this._tokenConfig[key].type
+                    break
+                }
+            }
 
-            for(let key of keys){
-                if(expr.substr(start, key.length) === key){
+            // Extract constant
+            for(let key in tokenConstant){
+                if(expr.substring(start, start+key.length) === key){
                     token += key;
-                    tokenType = 'operation'
+                    tokenType = ShutingyardType.CONSTANT
                     break
                 }
             }
@@ -99,77 +148,24 @@ export class Shutingyard {
             if(token===''){
                 // No function found ! Might be a coefficient !
                 if( expr[start].match(/[0-9]/) ) {
-                    token = expr.substr(start).match(/^([0-9.,/]+)/)[0]
-                    tokenType = 'coefficient'
+                    if(this._mode === ShutingyardMode.POLYNOM) {
+                        token = expr.substring(start).match(/^([0-9.,/]+)/)[0]
+                    }else{
+                        token = expr.substring(start).match(/^([0-9.,]+)/)[0]
+                    }
+                    tokenType = ShutingyardType.COEFFICIENT
                 }else if (expr[start].match(/[a-zA-Z]/)) {
-                    token = expr.substr(start).match(/^([a-zA-Z])/)[0]
-                    tokenType = 'variable'
+                    token = expr.substring(start).match(/^([a-zA-Z])/)[0]
+                    tokenType = ShutingyardType.VARIABLE
                 }else{
                     console.log('Unidentified token', expr[start], expr, start)
                     token = expr[start]
-                    tokenType = 'monom'
+                    tokenType = ShutingyardType.MONOM
                 }
 
             }
         }
 
-
-        // console.log(token, tokenType)
-        return [token, start + token.length, tokenType];
-    }
-
-    NextToken(expr: string, start: number): [string, number, string] {
-        let tokenMatch: string[], token: string, tokenType: string;
-
-        this.NextToken2(expr, start)
-        // Detect a fraction monoms or return empty array
-        tokenMatch = (expr.substr(start).match(/^[0-9/a-zA-Z^]+/g)) || [];
-
-        if (expr.substr(start, start + 3).match(/^(sin|cos|tan)/g)) {
-            token = expr.substr(start, 3)
-            tokenType = 'function'
-        } else if (tokenMatch.length > 0) {
-            token = tokenMatch[0];
-            tokenType = 'monom';
-        }
-        // It's an operation !
-        else if (expr[start].match(/[+\-*/^]/g)) {
-            token = expr[start];
-            tokenType = 'operation';
-        } else if (expr[start].match(/[&|!]/g)) {
-            token = expr[start];
-            tokenType = 'operation';
-        }
-        // It's an opening parenthese
-        else if (expr[start] === '(') {
-            token = '(';
-            tokenType = '(';
-        }
-        // It's a closing parenthese
-        else if (expr[start] === ')') {
-            token = ')';
-            tokenType = ')';
-        }
-        // It's an argument separator for a function
-        else if (expr[start] === ',') {
-            token = ',';
-            tokenType = 'function-argument';
-        }
-        // It's a monom.
-        else {
-            // TODO: Actually, negative exposant aren't supported.
-            // token = (expr.substr(start).match(/^[\da-z\^]+/g)[0])||'';
-            token = tokenMatch[0];
-            tokenType = 'monom';
-
-            if (token === '') {
-                token = expr[start];
-                tokenType = 'monom';
-                console.log('SHUTING YARD - NEXT TOKEN: error at ', start);
-            }
-        }
-
-        // console.log(token, start + token.length, tokenType);
         return [token, start + token.length, tokenType];
     }
 
@@ -241,12 +237,13 @@ export class Shutingyard {
             }
 
             // Get the next token and the corresponding new (ending) position
-            [token, tokenPos, tokenType] = this.NextToken2(expr, tokenPos);
+            [token, tokenPos, tokenType] = this.NextToken(expr, tokenPos);
 
             switch (tokenType) {
                 case 'monom':
                 case 'coefficient':
                 case 'variable':
+                case 'constant':
                     outQueue.push({
                         token,
                         tokenType

package/tests/algebra/monom.test.ts

@@ -66,7 +66,7 @@ describe('Monom tests', () => {
     });
 })
 
-describe('Monom as numerical expression', () => {
+describe('Monom as numerical expression WIP', () => {
     it('should create a numerical expression', () => {
         let M = new Monom()
 

package/tests/numexp.test.ts

@@ -0,0 +1,27 @@
+import {expect} from 'chai';
+import {NumExp} from "../src/maths/numexp";
+
+describe('Numerical expression', () => { // the tests container
+    it('RPN for numerical expression', () => {
+        const RPN = new NumExp('3*x+5').rpn
+        expect(RPN.map(x => x.token)).to.have.all.members(['3', 'x', '*', '5', '+'])
+
+        const RPN2 = new NumExp('-3*x^2-5').rpn
+        expect(RPN2.map(x=>x.token)).to.have.all.members(['3', 'x', '2', '^', '*', '-', '5', '-'])
+    })
+
+    it('Evaluate for numerical expression', () => {
+        const expr = new NumExp('3*x+5')
+        expect(expr.evaluate({x: 5})).to.be.equal(20)
+
+        const expr2 = new NumExp('-3*x^2-5')
+        expect(expr2.evaluate({x: -2})).to.be.equal(-17)
+    })
+
+
+
+    it('Evaluation simple mathematical functions', () => {
+        const expr = new NumExp('sqrt(x)')
+        expect(expr.evaluate({x: 9})).to.be.equal(3)
+    })
+});

package/tests/shutingyard.test.ts

@@ -1,5 +1,5 @@
 import {expect} from 'chai';
-import {Shutingyard} from "../src/maths/shutingyard";
+import {Shutingyard, ShutingyardMode} from "../src/maths/shutingyard";
 
 describe('Shuting yard', () => { // the tests container
     it('RPN for polynom', () => {
@@ -28,8 +28,8 @@ describe('Shuting yard', () => { // the tests container
     })
 
 	it('Custom RPN', () => {
-		const SY1: Shutingyard = new Shutingyard('set').parse('(A|B)&C');
-        const SY2: Shutingyard = new Shutingyard('set').parse('(A-B)&!C');
+		const SY1: Shutingyard = new Shutingyard(ShutingyardMode.SET).parse('(A|B)&C');
+        const SY2: Shutingyard = new Shutingyard(ShutingyardMode.SET).parse('(A-B)&!C');
 		expect(SY1.rpn.map(x=>x.token)).to.have.all.members(['A', 'B', '|', 'C', '&'])
 		expect(SY2.rpn.map(x=>x.token)).to.have.all.members(['A', 'B', '-', 'C', '!', '&'])
 	})

package/tsconfig.json

@@ -19,7 +19,6 @@
     "module": "commonjs",
     "target": "esnext",
     "allowJs": true,
-    //    "jsx": "react-jsx",
     "sourceMap": true,
     "moduleResolution": "node",
     "declaration": true,

package/esm/docs.d.ts

@@ -1,6 +0,0 @@
-export * from "./maths/algebra";
-export * from "./maths/coefficients";
-export * from "./maths/geometry";
-export * from "./maths/random/random";
-export * from "./maths/numeric";
-export * from "./maths/shutingyard";

package/esm/docs.js

@@ -1,7 +0,0 @@
-export * from "./maths/algebra";
-export * from "./maths/coefficients";
-export * from "./maths/geometry";
-export * from "./maths/random/random";
-export * from "./maths/numeric";
-export * from "./maths/shutingyard";
-//# sourceMappingURL=docs.js.map

package/esm/docs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"docs.js","sourceRoot":"","sources":["../src/docs.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,sBAAsB,CAAA;AACpC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AAErC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA"}

package/esm/maths/random/random.d.ts

@@ -1,13 +0,0 @@
-import { randomMonomConfig, randomPolynomConfig } from "./rndTypes";
-import { Monom } from "../algebra/monom";
-import { Polynom } from "../algebra/polynom";
-export declare namespace Random {
-    function polynom(config?: randomPolynomConfig): Polynom;
-    function monom(config?: randomMonomConfig): Monom;
-    function number(from: number, to: number): number;
-    function numberSym(max: number, allowZero?: boolean): number;
-    function bool(percent?: number): boolean;
-    function array(arr: any[], number?: number): any[];
-    function item(arr: any[]): any;
-    function shuffle(arr: any[]): any;
-}

package/esm/maths/random/random.js

@@ -1,27 +0,0 @@
-import { rndPolynom } from "./rndPolynom";
-import { rndMonom } from "./rndMonom";
-import { rndHelpers } from "./rndHelpers";
-export var Random;
-(function (Random) {
-    function polynom(config) {
-        return new rndPolynom(config).generate();
-    }
-    Random.polynom = polynom;
-    function monom(config) {
-        return new rndMonom(config).generate();
-    }
-    Random.monom = monom;
-    function number(from, to) { return rndHelpers.randomInt(from, to); }
-    Random.number = number;
-    function numberSym(max, allowZero) { return rndHelpers.randomIntSym(max, allowZero); }
-    Random.numberSym = numberSym;
-    function bool(percent) { return rndHelpers.randomBool(percent); }
-    Random.bool = bool;
-    function array(arr, number) { return rndHelpers.randomArray(arr, number); }
-    Random.array = array;
-    function item(arr) { return rndHelpers.randomItem(arr); }
-    Random.item = item;
-    function shuffle(arr) { rndHelpers.shuffleArray(arr); }
-    Random.shuffle = shuffle;
-})(Random || (Random = {}));
-//# sourceMappingURL=random.js.map

package/esm/maths/random/random.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"random.js","sourceRoot":"","sources":["../../../src/maths/random/random.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAC;AACpC,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAgBxC,MAAM,KAAW,MAAM,CAiBtB;AAjBD,WAAiB,MAAM;IACnB,SAAgB,OAAO,CAAC,MAA4B;QAChD,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAA;IAC5C,CAAC;IAFe,cAAO,UAEtB,CAAA;IAED,SAAgB,KAAK,CAAC,MAA0B;QAC5C,OAAO,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAA;IAC1C,CAAC;IAFe,YAAK,QAEpB,CAAA;IAED,SAAgB,MAAM,CAAC,IAAW,EAAE,EAAS,IAAW,OAAO,UAAU,CAAC,SAAS,CAAC,IAAI,EAAC,EAAE,CAAC,CAAA,CAAA,CAAC;IAA7E,aAAM,SAAuE,CAAA;IAC7F,SAAgB,SAAS,CAAC,GAAU,EAAE,SAAkB,IAAW,OAAO,UAAU,CAAC,YAAY,CAAC,GAAG,EAAE,SAAS,CAAC,CAAA,CAAA,CAAC;IAAlG,gBAAS,YAAyF,CAAA;IAClH,SAAgB,IAAI,CAAC,OAAe,IAAY,OAAO,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAA,CAAA,CAAC;IAAtE,WAAI,OAAkE,CAAA;IACtF,SAAgB,KAAK,CAAC,GAAS,EAAE,MAAc,IAAU,OAAO,UAAU,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA,CAAA,CAAC;IAApF,YAAK,QAA+E,CAAA;IACpG,SAAgB,IAAI,CAAC,GAAS,IAAQ,OAAO,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA,CAAA,CAAC;IAAxD,WAAI,OAAoD,CAAA;IACxE,SAAgB,OAAO,CAAC,GAAS,IAAQ,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC,CAAA,CAAA,CAAC;IAAtD,cAAO,UAA+C,CAAA;AAG1E,CAAC,EAjBgB,MAAM,KAAN,MAAM,QAiBtB"}