pimath 0.0.128 → 0.0.130

package/src/demo/matrices.ts

@@ -1,61 +0,0 @@
-function detMatrice(M: number[][]): { matrix: number[][], determinant: number } {
-    return {
-        matrix: M,
-        determinant: detnxn(M)
-    }
-}
-
-function det2x2(M: number[][]): number {
-    return M[0][0] * M[1][1] - M[1][0] * M[0][1]
-}
-
-function subMatrix(M: number[][], row: number, col: number) {
-    let subM = []
-
-    for (let r = 0; r < M.length; r++) {
-        if (r === row) {
-            continue
-        }
-
-        let subMrow = []
-        for (let c = 0; c < M[r].length; c++) {
-            if (c === col) {
-                continue
-            }
-            subMrow.push(M[r][c])
-        }
-        subM.push(subMrow)
-    }
-    return subM
-}
-
-function detnxn(M: number[][]) {
-    let result = 0
-
-    if (M.length === 2) {
-        result = det2x2(M)
-    } else {
-        for (let i = 0; i < M.length; i++) {
-            if (M[i][0] !== 0) {
-                result += M[i][0] * Math.pow(-1, i) * detnxn(subMatrix(M, i, 0))
-
-
-            }
-        }
-    }
-
-    return result
-}
-
-const M = detMatrice([
-    [0, 2, -1, 4, 0],
-    [3, 5, 0, 0, -2],
-    [0, -3, 1, 0, 0],
-    [0, 0, -4, 3, -3],
-    [-1, 0, 0, 1, 2]
-])
-
-document.getElementById('app').innerHTML = `<p>\\[${M.matrix} = ${M.determinant}\\]</p>`;
-
-// @ts-ignore
-renderMathInElement(document.getElementById('app'))

package/src/demo/playground.ts

@@ -1,153 +0,0 @@
-import {Point} from "../maths/geometry/point.ts";
-import {Line} from "../maths/geometry/line.ts";
-
-let A = new Point(0, 2),
-    B = new Point(2, 3),
-    C = new Point(1 / 2, 4),
-    D = new Point(2, -1 / 2);
-
-let L1 = new Line(A, B).simplifyDirection(),
-    L2 = new Line(C, D).simplifyDirection();
-
-document.getElementById('app').innerHTML = `<p>\\( ${L1.tex.parametric} \\)</p>`;
-document.getElementById('app').innerHTML += `<p>\\( ${L2.tex.parametric} \\)</p>`;
-
-let I = L1.intersection(L2);
-if (I.hasIntersection) {
-    document.getElementById('app').innerHTML += `<p>\\[ ${L1.intersection(L2).point.tex} \\]</p>`
-} else if (I.isParallel) {
-    document.getElementById('app').innerHTML += `<p>Elles sont parallèles</p>`
-} else if (I.isSame) {
-    document.getElementById('app').innerHTML += `<p>Elles sont confondues</p>`
-}
-
-
-// @ts-ignore
-renderMathInElement(document.getElementById('app'), {fleqn: true});
-/*let p;
-p = new Pi.Polynom('3x(6x+9)+6(6x+9)');
-document.getElementById('app').innerHTML = `<p>${p.raw}</p>`;
-document.getElementById('app').innerHTML += `<p>${p.display}</p>`;
-
-let v1 = new Pi.Vector('3 4'),
-	v2 = new Pi.Vector('-2 5');
-
-console.log(v1);
-console.log(v2);
-console.log(Pi.Vector.scalarProduct(v1, v2));
-
-
-let P = new Pi.Polynom('(x+5)(x-17)(37x+35)');
-let Q = new Pi.Polynom('1');
-P.factorize(100)
-
-P.factors.forEach(n=> {
-	console.log(n.tex)
-	Q.multiply(n);
-})
-
-// Check that we have the same polynom.
-console.log(P.tex);
-console.log(Q.tex);
-
-
-
-
-
-/*let n = new Pi.Polynom(),
-		d = new Pi.Polynom();
-n.parse('(x+3)(x+4)');
-d.parse('(x+3)(x-2)')
-
-let r = new Pi.Rational(n, d);
-document.getElementById('app').innerHTML = `<p>${r.tex}</p>`*/
-
-
-/*
-let M = new Pi.Monom().random('x', 2, false, false);
-console.log(M.displayWithSign);
-
-let S = new Pi.LinearSystem().parse(
-	'x-3y=-2',
-	'4x+7x=1'
-);
-S.solve();
-document.getElementById('app').innerHTML = `<p>${S.tex}</p>`;
-document.getElementById('app').innerHTML += `<p>${S.texSolution}</p>`;
-let S = new Pi.LinearSystem().generate(3,-5,2);
-document.getElementById('app').innerHTML = `<p>${S.tex}</p>`;
-S.solve();
-S.log;
-S.tex;
-
-S = new Pi.LinearSystem().generate(-1,8,-2);
-document.getElementById('app').innerHTML += `<p>${S.tex}</p>`;
-S.solve();
-S.log;
-
-let P = new Pi.Polynom('3x^2+5yx-2');
-console.log(P.tex);
-console.log(P.numberOfVars);
-P.replaceBy('y', new Pi.Polynom('2x+1'));
-console.log(P.tex);
-
-let A = new Pi.Equation('2x+3y=5');
-console.log(A.tex);
-
-A.isolate('x');
-console.log(A.tex);
-
-A.isolate('y');
-console.log(A.tex);
-
-let P = new Pi.Polynom().rndSimple(2).makeItComplicate();
-console.log(P.tex);
-console.log(P.texString);
-
-let A = new Pi.Fraction().parse('2/5');
-console.log(A.frac);
-
-let F = new Pi.Fraction().parse('18/5');
-let N = new Pi.Root().parse(F).reduce();
-console.log(N.tex);
-
-let E = new Pi.Equation().create(new Pi.Polynom().parse('x^2+6x-8'), new Pi.Polynom().zero());
-E.solve();
-console.log(E.solutions);
-
-let D = 42;
-console.log(Pi.Numeric.dividers(D));
-
-let X = new Pi.Polynom().rndFactorable(2, false);
-console.log(X.tex);
-X.factors.forEach(function(P, i){
-	console.log(P.tex);
-});
-
-let EQ = new Pi.Equation('2x+3>=5x-2');
-EQ.solve();
-console.log(EQ.solution);
-
-EQ.parseString('2x+3<5x-2');
-EQ.solve();
-console.log(EQ.solution);
-
-EQ.parseString('7x+3>5x-2');
-EQ.solve();
-console.log(EQ.solution);
-
-EQ.parseString('7x+3=<5x-2');
-EQ.solve();
-console.log(EQ.solution);
-
-EQ.parseString('7x+3=<7x-2');
-EQ.solve();
-console.log(EQ.solution);
-
-EQ.parseString('7x+3>7x-2');
-EQ.solve();
-console.log(EQ.solution);
-
-EQ.parseString('x^2+6x+9>=0');
-EQ.solve();
-console.log(EQ.solution);*/

package/src/main.ts

@@ -1,42 +0,0 @@
-import {Numeric} from "./maths/numeric";
-import {NumExp} from "./maths/numexp";
-import {Shutingyard} from "./maths/shutingyard";
-import {Random} from "./maths/randomization/random";
-import {Fraction} from "./maths/coefficients/fraction";
-import {NthRoot} from "./maths/coefficients/nthRoot";
-import {Monom} from "./maths/algebra/monom";
-import {Polynom} from "./maths/algebra/polynom";
-import {Equation} from "./maths/algebra/equation";
-import {LinearSystem} from "./maths/algebra/linearSystem";
-import {Rational} from "./maths/algebra/rational";
-import {Logicalset} from "./maths/algebra/logicalset";
-import {Vector} from "./maths/geometry/vector";
-import {Line} from "./maths/geometry/line";
-import {Triangle} from "./maths/geometry/triangle";
-import {Circle} from "./maths/geometry/circle";
-import {Point} from "./maths/geometry/point";
-
-// Expose as global
-export const PiMath = {
-    ShutingYard: Shutingyard,
-    Numeric: Numeric,
-    NumExp: NumExp,
-    Fraction: Fraction,
-    Root: NthRoot,
-    Monom: Monom,
-    Polynom: Polynom,
-    Equation: Equation,
-    LinearSystem: LinearSystem,
-    Rational: Rational,
-    Logicalset: Logicalset,
-    Random: Random,
-    Geometry: {
-        Vector: Vector,
-        Point: Point,
-        Line: Line,
-        Triangle: Triangle,
-        Circle: Circle
-    }
-};
-
-// (<any>window).PiMath = PiMath

package/src/maths/algebra/logicalset.ts

@@ -1,183 +0,0 @@
-/**
- * Polynom module contains everything necessary to handle polynoms.
- * @module Logicalset
- */
-
-import {Shutingyard, ShutingyardMode} from '../shutingyard';
-
-/**
- * Polynom class can handle polynoms, reorder, resolve, ...
- */
-    export class Logicalset {
-        private _rawString: string;
-        private _rpn: { token: string, tokenType: string }[]
-
-        /**
-         *
-         * @param {string} value (optional) Default polynom to parse on class creation
-         */
-        constructor(value: string) {
-            this._rawString = value
-            this.parse(value)
-            return this;
-        }
-
-        get isLogicalset() {
-            return true;
-        };
-
-        private parse = (value: string): Logicalset => {
-            // TODO: Must format the value string to convert some items...
-
-            // Parse the updated value to the shutingyard algorithm
-            this._rpn = new Shutingyard(ShutingyardMode.SET).parse(value).rpn;
-
-            return this;
-        }
-
-        evaluate(tokenSets: { [key: string]: unknown[] }, reference?: unknown[]): unknown[] {
-            let varStack: (Set<unknown>)[] = []
-
-            let referenceSet: Set<unknown>
-            if (reference === undefined) {
-                referenceSet = new Set()
-                for (let key in tokenSets) {
-                    referenceSet = new Set([...referenceSet, ...tokenSets[key]])
-                }
-            } else {
-                referenceSet = new Set(reference)
-            }
-
-            for (let token of this._rpn) {
-                if (token.tokenType === 'variable') {
-                    // The variable has no token - assume it's empty.
-                    if (tokenSets[token.token] === undefined) {
-                        varStack.push(new Set())
-                    } else {
-                        varStack.push(new Set(tokenSets[token.token]));
-                    }
-
-                } else {
-                    switch (token.token) {
-                        case '&':
-                            if (varStack.length >= 2) {
-                                let second = varStack.pop(),
-                                    first = varStack.pop()
-
-                                varStack.push(new Set([...first].filter(x => second.has(x))))
-                            }
-                            break
-                        case '|':
-                            if (varStack.length >= 2) {
-                                let second = varStack.pop(),
-                                    first = varStack.pop()
-                                varStack.push(new Set([...first, ...second]))
-                            }
-                            break
-                        case '-':
-                            if (varStack.length >= 2) {
-                                let second = varStack.pop(),
-                                    first = varStack.pop()
-                                varStack.push(new Set([...first].filter(x => !second.has(x))))
-                            }
-                            break
-                        case '!':
-                            if (varStack.length >= 1) {
-                                let first = varStack.pop()
-
-                                varStack.push(new Set([...referenceSet].filter(x => !first.has(x))))
-                            }
-                            break
-                    }
-                }
-            }
-
-            return [...varStack[0]].sort();
-        }
-
-        vennAB(): any[] {
-            return this.evaluate({
-                    A: ['A', 'AB'],
-                    B: ['B', 'AB']
-                },
-                ['A', 'B', 'AB', 'E']
-            )
-        }
-
-        vennABC(): any[] {
-            return this.evaluate({
-                    A: ['A', 'AB', 'AC', 'ABC'],
-                    B: ['B', 'AB', 'BC', 'ABC'],
-                    C: ['C', 'AC', 'BC', 'ABC']
-                },
-                ['A', 'B', 'C', 'AB', 'AC', 'BC', 'E']
-            )
-        }
-
-        get rpn(): { token: string, tokenType: string }[] {
-            return this._rpn
-        }
-
-        get tex(): string {
-            let varStack: { token: string, tokenType: string } [] = []
-
-            for (let token of this._rpn) {
-                if (token.tokenType === 'variable') {
-                    varStack.push(token);
-                } else {
-                    switch (token.token) {
-                        case '&':
-                            if (varStack.length >= 2) {
-                                let second = varStack.pop(),
-                                    first = varStack.pop()
-
-                                if (first.tokenType === 'mix') {
-                                    first.token = `( ${first.token} )`
-                                }
-                                if (second.tokenType === 'mix') {
-                                    second.token = `( ${second.token} )`
-                                }
-                                varStack.push({token: `${first.token} \\cap ${second.token}`, tokenType: 'mix'})
-                            }
-                            break
-                        case '|':
-                            if (varStack.length >= 2) {
-                                let second = varStack.pop(),
-                                    first = varStack.pop()
-
-                                if (first.tokenType === 'mix') {
-                                    first.token = `( ${first.token} )`
-                                }
-                                if (second.tokenType === 'mix') {
-                                    second.token = `( ${second.token} )`
-                                }
-                                varStack.push({token: `${first.token} \\cup ${second.token}`, tokenType: 'mix'})
-                            }
-                            break
-                        case '-':
-                            if (varStack.length >= 2) {
-                                let second = varStack.pop(),
-                                    first = varStack.pop()
-
-                                if (first.tokenType === 'mix') {
-                                    first.token = `( ${first.token} )`
-                                }
-                                if (second.tokenType === 'mix') {
-                                    second.token = `( ${second.token} )`
-                                }
-                                varStack.push({token: `${first.token} \\setminus ${second.token}`, tokenType: 'mix'})
-                            }
-                            break
-                        case '!':
-                            if (varStack.length >= 1) {
-                                let first = varStack.pop()
-                                varStack.push({token: `\\overline{ ${first.token} }`, tokenType: 'variable'})
-                            }
-                            break
-                    }
-                }
-            }
-
-            return varStack[0].token
-        }
-    }

package/tests/algebra/equation.test.ts

@@ -1,64 +0,0 @@
-import {describe} from "mocha";
-import {expect} from "chai";
-import {Equation} from "../../src/maths/algebra/equation";
-
-
-describe('Equations tests', () => {
-    it('should get the solutions', () => {
-
-        let E1 = new Equation('3x+8', '0')
-        E1.solve()
-        expect(E1.solutions[0].tex).to.be.equal('-\\frac{ 8 }{ 3 }')
-
-        let E2 = new Equation('x^2+5x+6', '0')
-        E2.solve()
-        expect(E2.solutions.map(x=>x.tex)).to.have.all.members(['-3', '-2'])
-
-        let E3 = new Equation('(x-3)(x+2)(3x-5)', '0')
-        E3.solve()
-        expect(E3.solutions.map(x=>x.tex)).to.have.all.members([ '-2', '3', '\\frac{ 5 }{ 3 }' ])
-
-        let E4 = new Equation('x^2+x+10', '0')
-        E4.solve()
-        expect(E4.solutions.map(x=>x.tex)).to.have.all.members([ '\\varnothing' ])
-
-        let E5 = new Equation('(x-3)(x+2)(x-5)(x-7)(x+2)', 0)
-        E5.solve()
-        expect(E5.solutions.map(x=>x.tex)).to.have.all.members([ '-2', '3', '5', '7' ] )
-
-
-        let E6 = new Equation('5x^2+7x-31', 0)
-        E6.solve()
-        expect(E6.solutions.map(x=>x.tex)).to.have.all.members([
-            '\\frac{ -7 - \\sqrt{669} }{ 10 }',
-            '\\frac{ -7 + \\sqrt{669} }{ 10 }'
-        ] )
-    })
-
-    it('should resolve an equation of second degree', ()=>{
-        let P = new Equation('-10x^2-8x+8=0')
-        P.solve()
-        expect(P.solutions[0].tex).to.have.oneOf(['\\frac{ -2 - 2\\sqrt{6} }{ 5 }', '\\frac{ -2 + 2\\sqrt{6} }{ 5 }'])
-    })
-
-    it('should solve this equation please', function () {
-        let P = new Equation("2/7(3x+5)=9-(3-x)/7")
-        P.solve()
-
-        const sols = P.solutions.map(x => x.display)
-        expect(sols).to.be.length(1)
-        expect(sols[0]).to.be.equal('10')
-    });
-
-    it('should detect if two equations are equal or linear', function () {
-        let P = new Equation('3x+2y=5'),
-            Q = new Equation('5-3x=2y'),
-            R = new Equation('6x+4y-10=0')
-
-        expect(P.isSameAs(P)).to.be.true
-        expect(P.isSameAs(Q)).to.be.true
-        expect(P.isSameAs(R)).to.be.false
-        expect(P.isLinearTo(Q)).to.be.true
-        expect(P.isLinearTo(R)).to.be.true
-    })
-})

package/tests/algebra/linear.test.ts

@@ -1,58 +0,0 @@
-import {describe} from "mocha";
-import {expect} from "chai";
-import {LinearSystem} from "../../src/maths/algebra/linearSystem";
-import {Polynom} from "../../src/maths/algebra/polynom";
-
-
-describe('Linear systems tests', () => {
-    it('should solve a 2x2 equations', () => {
-        let LS = new LinearSystem(
-            '4x+5y=11',
-            '7y-24=3x'
-        )
-        LS.solve(true)
-
-        expect(LS.solution).to.be.equal('\\left(-1;3\\right)')
-    })
-    it('should solve a 3x3 equations', () => {
-        let LS = new LinearSystem(
-            '2x+7y-z=-3',
-            '-3x+2y+3z=12',
-            '-5x-3y+2z=5'
-        )
-
-        LS.solve()
-        expect(LS.solutionAsDisplay).to.be.equal("(1;0;5)")
-    })
-
-    it('should solve a 3x3 equations II ', () => {
-        let LS = new LinearSystem(
-            '-x+y-z=-6',
-            '3x+2y+z=14',
-            '5x+y+3z=7'
-        )
-
-        LS.solve()
-    })
-
-    it('should calculate the reduction', function () {
-        let E1 = new Polynom('6x+21y-3z'),
-            E2 = new Polynom('-6x+21y-3z')
-
-        E1.add(E2);
-        expect(E1.reduce().display).to.be.equal('42y-6z')
-    });
-
-    it('should use a reduced linear reducation', function () {
-        let LS = new LinearSystem(
-            '3x-6y+3=0',
-            'x+12y-6=0'
-        )
-        LS.solve(true)
-
-        const tex = LS.stepTex('x')
-
-        expect(+LS.resolutionSteps['x'][0].operations[0][0]).to.be.equal(2)
-        expect(+LS.resolutionSteps['x'][0].operations[1][0]).to.be.equal(1)
-    });
-})

package/tests/algebra/monom.test.ts

@@ -1,78 +0,0 @@
-import {expect} from 'chai';
-import {Random} from "../../src/maths/randomization/random";
-import {describe} from "mocha";
-import {Monom} from "../../src/maths/algebra/monom";
-
-describe('Monom with integer power', () => {
-    it('parsing', () => {
-        const M0a = new Monom('3');
-        expect(M0a.tex).to.be.equal('3')
-
-        const M0b = new Monom('x');
-        expect(M0b.tex).to.be.equal('x')
-
-        const M0c = new Monom('3x');
-        expect(M0c.tex).to.be.equal('3x')
-
-        const M1 = new Monom('3x^5');
-        expect(M1.tex).to.be.equal('3x^{5}')
-
-        const M2 = new Monom('2/3x^2yz^3y^4')
-        expect(M2.display).to.be.equal('2/3x^(2)y^(5)z^(3)')
-
-        const M3 = new Monom('-3x^(-2)')
-        expect(M3.tex).to.be.equal('-3x^{-2}')
-
-        const M4 = new Monom('3x^(2/3)')
-        expect(M4.tex).to.be.equal('3x^{\\tfrac{ 2 }{ 3 }}')
-
-        const M5 = new Monom('-3x^(-2/3)y^(-5)8x^3')
-        expect(M5.tex).to.be.equal('-24x^{\\tfrac{ 7 }{ 3 }}y^{-5}')
-    })
-
-    it('basic operations', () => {
-        const M1 = new Monom('3x'),
-            M2 = new Monom('2x')
-
-        expect(M1.clone().add(M2).isEqual(new Monom('5x'))).to.be.true
-        expect(M1.clone().subtract(M2).isEqual(new Monom('x'))).to.be.true
-        expect(M1.clone().multiply(M2).isEqual(new Monom('6x^2'))).to.be.true
-        expect(M1.clone().divide(M2).isEqual(new Monom('3/2'))).to.be.true
-    })
-
-    it('derivative', () => { // the single test
-        const options = new Monom('7x^3'); // this will be your class
-
-        expect(options.tex).to.be.equal('7x^{3}')
-        expect(options.derivative().tex).to.be.equal('21x^{2}');
-    });
-
-    it('integrate', () => { // the single test
-        const options = new Monom('7x^3'); // this will be your class
-        expect(options.primitive().display).to.be.equal('7/4x^(4)');
-    });
-
-    it('randomize', function () {
-        const M = Random.monom({
-            letters: 'xyz',
-            degree: 5,
-            fraction: false,
-            zero: false
-        });
-
-        expect(M.coefficient.isZero()).to.be.false
-        expect(M.degree().value).to.be.greaterThan(0)
-    });
-})
-
-describe('Monom with fraction power', () => {
-    it('should create a numerical expression', () => {
-        const inputStr: string = '-1/5x^(2/3)'
-        const M = new Monom(inputStr),
-            N = new Monom('7x^(4/5)')
-
-        M.multiply(N.clone())
-
-        expect(M.tex).to.be.equal('-\\frac{ 7 }{ 5 }x^{\\tfrac{ 22 }{ 15 }}')
-    })
-})