pimath 0.0.23 → 0.0.27

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,55 @@ 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},
+            }
         } 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
     }
 
@@ -86,12 +122,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)
 
-            for(let key of keys){
-                if(expr.substr(start, key.length) === key){
+            // Extract operation and function tokens
+            for(let key of this._tokenKeys){
+                if(expr.substring(start, start+key.length) === key){
                     token += key;
-                    tokenType = 'operation'
+                    tokenType = this._tokenConfig[key].type
+                    break
+                }
+            }
+
+            // Extract constant
+            for(let key in tokenConstant){
+                if(expr.substring(start, start+key.length) === key){
+                    token += key;
+                    tokenType = ShutingyardType.CONSTANT
                     break
                 }
             }
@@ -99,79 +146,81 @@ 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];
-    }
+    // 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.substring(start).match(/^[0-9/a-zA-Z^]+/g)) || [];
+    //
+    //     if (expr.substring(start, start + 3).match(/^(sin|cos|tan)/g)) {
+    //         token = expr.substring(start, 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.substring(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];
+    // }
 
     /**
      * Sanitize an expression by adding missing common operation (multiplication between parentheseses)
@@ -247,6 +296,7 @@ export class Shutingyard {
                 case 'monom':
                 case 'coefficient':
                 case 'variable':
+                case 'constant':
                     outQueue.push({
                         token,
                         tokenType

package/tests/algebra/monom.test.ts

@@ -1,10 +1,11 @@
 import {expect} from 'chai';
 import {Monom} from "../../src/maths/algebra";
 import {Random} from "../../src/maths/random";
-import exp = require("constants");
+import {describe} from "mocha";
+import {Fraction} from "../../src/maths/coefficients";
 
-describe('Monom tests', ()=> {
-    it('parsing', ()=>{
+describe('Monom tests', () => {
+    it('parsing', () => {
         const M0a = new Monom('3');
         expect(M0a.tex).to.be.equal('3')
 
@@ -30,7 +31,7 @@ describe('Monom tests', ()=> {
         expect(M5.tex).to.be.equal('-24x^{7/3}y^{-5}')
     })
 
-    it('basic operations', ()=>{
+    it('basic operations', () => {
         const M1 = new Monom('3x'),
             M2 = new Monom('2x')
 
@@ -64,3 +65,16 @@ describe('Monom tests', ()=> {
         expect(M.degree().value).to.be.greaterThan(0)
     });
 })
+
+describe('Monom as numerical expression WIP', () => {
+    it('should create a numerical expression', () => {
+        let M = new Monom()
+
+        M.coefficient = new Fraction(3, 7)
+        M.setLetter('3', new Fraction(0.5).reduce())
+
+        console.log(M.tex)
+        // TODO: Problem while displaying numerical expression
+        console.log(M.display)
+    })
+})

package/tests/algebra/polynom.test.ts

@@ -1,7 +1,8 @@
 import {expect} from 'chai';
 import {Fraction} from "../../src/maths/coefficients";
-import {Polynom} from "../../src/maths/algebra";
+import {Monom, Polynom} from "../../src/maths/algebra";
 import {Random} from "../../src/maths/random";
+import {describe} from "mocha";
 
 describe('Polynom tests', () => {
     it('Parse polynom', () => {
@@ -38,10 +39,24 @@ describe('Polynom tests', () => {
     it('Random Polynom of degree 5', function () {
         let P = Random.polynom({
             degree: 6,
-            numberOfMonoms: 3
+            numberOfMonoms: 3,
+            positive: true,
+            fraction: {
+                max: 3
+            }
         })
 
         expect(P.length).to.be.equal(3)
-        expect(P.degree().value).to.be.lessThanOrEqual(6)
+        expect(P.degree().value).to.be.equal(6)
     });
-})
+
+    it('should calculate correctly the quotient and reminder', function () {
+        let P = new Polynom('(x-3)(x^2+5x-4)+12'),
+            D = new Polynom('x-3')
+
+        let euclidian = P.euclidian(D);
+
+        expect(euclidian.quotient.tex).to.be.equal('x^{2}+5x-4')
+        expect(euclidian.reminder.tex).to.be.equal('12')
+    });
+})

package/tests/geometry/circle.test.ts

@@ -0,0 +1,28 @@
+import {describe} from "mocha";
+import {Circle, Line, Point} from "../../src/maths/geometry";
+import {Fraction} from "../../src/maths/coefficients";
+import {expect} from "chai";
+
+describe('Circle', function () {
+    it('should calculate the intersection of a circle and a line', function () {
+        let C = new Circle(
+            new Point(8, 6),
+            20,
+            true
+        ),
+            LT = new Line('2x+y-32=0'),
+            LS = new Line('3x-y-8=0'),
+            IPT = C.lineIntersection(LT),
+            IPS = C.lineIntersection(LS)
+
+        expect(IPT).to.be.length(1)
+        expect(IPT[0].x.value).to.be.equal(12)
+        expect(IPT[0].y.value).to.be.equal(8)
+
+        expect(IPS).to.be.length(2)
+        expect(IPS[0].x.value).to.be.equal(4)
+        expect(IPS[0].y.value).to.be.equal(4)
+        expect(IPS[1].x.value).to.be.equal(6)
+        expect(IPS[1].y.value).to.be.equal(10)
+    });
+});

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

@@ -8,6 +8,9 @@
       "src/maths/numeric.ts",
       "src/maths/shutingyard.ts"
     ],
+    "plugin": [
+      "./typedoc.katex.js"
+    ],
     "out": "docs"
   },
   "compilerOptions": {
@@ -16,7 +19,7 @@
     "module": "commonjs",
     "target": "esnext",
     "allowJs": true,
-//    "jsx": "react",
+    //    "jsx": "react-jsx",
     "sourceMap": true,
     "moduleResolution": "node",
     "declaration": true,

package/typedoc.katex.js

@@ -0,0 +1,11 @@
+const { JSX } = require("typedoc");
+
+exports.load = function (app) {
+    app.renderer.hooks.on("head.end", () => {
+        return JSX.createElement(JSX.Fragment, null,
+            JSX.createElement("link", { rel: "stylesheet", href: "https://cdn.jsdelivr.net/npm/katex@0.15.1/dist/katex.min.css", integrity: "sha384-R4558gYOUz8mP9YWpZJjofhk+zx0AS11p36HnD2ZKj/6JR5z27gSSULCNHIRReVs", crossorigin: "anonymous" },
+                JSX.createElement("script", { defer: true, src: "https://cdn.jsdelivr.net/npm/katex@0.15.1/dist/katex.min.js", integrity: "sha384-z1fJDqw8ZApjGO3/unPWUPsIymfsJmyrDVWC8Tv/a1HeOtGmkwNd/7xUS0Xcnvsx", crossorigin: "anonymous" }),
+                JSX.createElement("script", { defer: true, src: "https://cdn.jsdelivr.net/npm/katex@0.15.1/dist/contrib/auto-render.min.js", integrity: "sha384-+XBljXPPiv+OzfbB3cVmLHf4hdUFHlWNZN5spNQ7rmHTXpd7WvJum6fIACpNNfIR", crossorigin: "anonymous", onload: "renderMathInElement(document.body);" })),
+            "}); }");
+    });
+}