pimath 0.0.49 → 0.0.53

package/src/maths/algebra/rational.ts

@@ -5,143 +5,288 @@
 
 import {Polynom} from "./polynom";
 import {Fraction} from "../coefficients/fraction";
+import {literalType} from "./monom";
+import {Equation, ISolution, PARTICULAR_SOLUTION} from "./equation";
 
 /**
  * Rational class can handle rational polynoms
  */
-    export class Rational {
-        private _rawString: string;
-        private _numerator: Polynom;
-        private _denominator: Polynom;
-
-        /**
-         *
-         * @param numerator
-         * @param denominator
-         */
-        constructor(numerator?: Polynom, denominator?: Polynom) {
-            this._numerator = numerator ? numerator.clone() : new Polynom();
-            this._denominator = denominator ? denominator.clone() : new Polynom();
+export class Rational {
+    private _rawString: string;
+
+    /**
+     *
+     * @param numerator
+     * @param denominator
+     */
+    constructor(numerator?: Polynom, denominator?: Polynom) {
+        this._numerator = numerator ? numerator.clone() : new Polynom();
+        this._denominator = denominator ? denominator.clone() : new Polynom();
+    }
+
+    private _numerator: Polynom;
+
+    get numerator(): Polynom {
+        return this._numerator
+    }
+
+    private _denominator: Polynom;
+
+    get denominator(): Polynom {
+        return this._denominator
+    }
+
+    get tex(): string {
+        return `\\frac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
+    }
+
+    get texFactors(): string {
+        return `\\frac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`
+    }
+
+    clone = (): Rational => {
+        this._numerator = this._numerator.clone()
+        this._denominator = this._denominator.clone()
+
+        return this;
+    }
+
+    domain = (): string => {
+        let zeroes = this._denominator.getZeroes();
+        if (zeroes.length === 0 || zeroes[0].tex === PARTICULAR_SOLUTION.real) {
+            return PARTICULAR_SOLUTION.real
+        } else if (zeroes[0].tex === PARTICULAR_SOLUTION.varnothing) {
+            return PARTICULAR_SOLUTION.varnothing
+        } else {
+            return '\\mathbb{R}\\setminus\\left\\{' +
+                zeroes.map(x => x.tex).join(';') + '\\right\\}'
         }
+    }
+
+    amplify = (P: Polynom): Rational => {
+        this._numerator.multiply(P);
+        this._denominator.multiply(P);
+
+        return this;
+    }
+
+    derivative = (letter?: string): Rational => {
+        let N = this._numerator.clone(),
+            D = this._denominator.clone(),
+            dN = N.clone().derivative(letter),
+            dD = D.clone().derivative(letter)
 
-        clone = (): Rational => {
-            this._numerator = this._numerator.clone()
-            this._denominator = this._denominator.clone()
+        this._numerator = dN.clone().multiply(D).subtract(N.clone().multiply(dD))
+        this._denominator = D.clone().pow(2)
 
+        return this
+    }
+
+    simplify = (P: Polynom): Rational => {
+        let NumeratorEuclidien = this._numerator.euclidian(P);
+        if (!NumeratorEuclidien.reminder.isZero()) {
             return this;
         }
 
-        get tex(): string {
-            return `\\dfrac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
+        let DenominatorEuclidien = this._denominator.euclidian(P);
+        if (!DenominatorEuclidien.reminder.isZero()) {
+            return this;
         }
 
-        get texFactors(): string {
-            this._numerator.factorize()
-            this._denominator.factorize()
+        this._numerator = NumeratorEuclidien.quotient;
+        this._denominator = DenominatorEuclidien.quotient;
+        return this;
+    }
 
-            return `\\dfrac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`
+    reduce = (): Rational => {
+        this._numerator.factorize();
+        for (let f of this._numerator.factors) {
+            this.simplify(f);
         }
 
-        get numerator(): Polynom {
-            return this._numerator
-        }
+        return this;
+    }
 
-        get denominator(): Polynom {
-            return this._denominator
-        }
+    opposed = (): Rational => {
+        this._numerator.opposed();
+        return this;
+    }
+    add = (R: Rational): Rational => {
+        // 1. Make sure both rational are at the same denominator
+        // 2. Add the numerators.
+        // 3. Simplify
 
-        domain = (): string => {
-            let zeroes = this._denominator.getZeroes();
-            if (zeroes.length === 0 || zeroes[0] === false) {
-                return '\\mathbb{R}'
-            } else if (zeroes[0] === true) {
-                return '\\varnothing'
+        // Store the adding denominator
+        let denominator = this._denominator.clone()
+
+        // Amplif the main rational polynom by the adding denominator
+        this.amplify(R._denominator)
+
+        // Add to the numerator the adding value...
+        this._numerator.add(R._numerator.clone().multiply(denominator));
+
+        return this;
+    }
+
+    subtract = (R: Rational): Rational => {
+        return this.add(R.clone().opposed())
+    }
+
+    limits = (value: Fraction | number, offset?: string, letter?: string): Fraction => {
+        if (value === Infinity || value === -Infinity) {
+            let {quotient, reminder} = this._numerator.clone().euclidian(this._denominator)
+
+            // quotient is positive => it will be infinite.
+            if (quotient.degree(letter).isStrictlyPositive()) {
+                return value === Infinity ? quotient.limitToInfinity(letter) : quotient.limitToNegativeInfinity(letter)
+                // return quotient.monomByDegree(undefined, letter).coefficient.sign()===1?(new Fraction()).infinite():(new Fraction()).infinite().opposed()
             } else {
-                return '\\mathbb{R}\\setminus\\left{' +
-                    zeroes.map(x => {
-                        return (typeof x === 'boolean') ? '' : x.frac
-                    })
-                        .join(';') + '\\right}'
+                return quotient.monomByDegree(undefined, letter).coefficient
             }
-        }
+        } else {
+            let evalValues: literalType = {},
+                evalValuesOffset: literalType = {},
+                theLimit: Fraction | number,
+                theSign: number,
+                FR = this.clone().reduce()
 
-        amplify = (P: Polynom): Rational => {
-            this._numerator.multiply(P);
-            this._denominator.multiply(P);
+            evalValues[letter === undefined ? 'x' : letter] = new Fraction(value)
 
-            return this;
-        }
+            if (offset !== 'above' && offset !== 'below') {
+                theLimit = FR._numerator.evaluate(evalValues)
+                    .divide(FR._denominator.evaluate(evalValues))
 
-        simplify = (P: Polynom): Rational => {
-            let NumeratorEuclidien = this._numerator.euclidian(P);
-            if (!NumeratorEuclidien.reminder.isZero()) {
-                return this;
-            }
+                return theLimit.isInfinity() ? theLimit.abs() : theLimit
+            } else {
+                if (offset === 'above') {
+                    evalValuesOffset[letter === undefined ? 'x' : letter] = (new Fraction(value)).add(0.000001)
+                } else if (offset === 'below') {
+                    evalValuesOffset[letter === undefined ? 'x' : letter] = (new Fraction(value)).subtract(0.000001)
+                }
 
-            let DenominatorEuclidien = this._denominator.euclidian(P);
-            if (!DenominatorEuclidien.reminder.isZero()) {
-                return this;
-            }
+                theLimit = FR._numerator.evaluate(evalValues)
+                    .divide(FR._denominator.evaluate(evalValues))
+                theSign = FR._numerator.evaluate(evalValuesOffset)
+                    .divide(FR._denominator.evaluate(evalValuesOffset)).sign()
 
-            this._numerator = NumeratorEuclidien.quotient;
-            this._denominator = DenominatorEuclidien.quotient;
-            return this;
+                if (theLimit.isInfinity()) {
+                    return theSign === 1 ? theLimit.abs() : theLimit.abs().opposed()
+                } else {
+                    return theLimit
+                }
+            }
         }
+    }
 
-        reduce = (): Rational => {
-            console.log(this._numerator.tex)
-            this._numerator.factorize();
-            console.log(this._numerator.factors.map(x => x.tex))
-            for (let f of this._numerator.factors) {
-                this.simplify(f);
+    makeTableOfSigns = (): { factors: Polynom[], zeroes: ISolution[], signs: (string[])[], tex: string } => {
+        // Factorize the numerator and the denominator
+        this._numerator.factorize()
+        this._denominator.factorize()
+
+        let zeroes = Equation.makeSolutionsUnique([...this._numerator.getZeroes(), ...this._denominator.getZeroes()], true),
+            NFactors = this._numerator.factors,
+            DFactors = this._denominator.factors
+
+        let tableOfSigns: (string[])[] = [],
+            result: string[] = []
+
+        NFactors.forEach(factor => {
+            tableOfSigns.push(this._makeOneLineOfTableOfSigns(factor, zeroes, 'z'))
+        })
+        DFactors.forEach(factor => {
+            tableOfSigns.push(this._makeOneLineOfTableOfSigns(factor, zeroes, 'd'))
+        })
+
+        // Empty line
+        tableOfSigns.push([])
+
+        // Add the final row as cumulative
+        let resultLine: string[] = tableOfSigns[0].map((x, index) => {
+            if (index === 0) {
+                return ''
             }
+            if (index === tableOfSigns[0].length - 1) {
+                return ''
+            }
+            if (index % 2 === 0) {
+                return 't'
+            }
+            return '+'
+        })
 
-            return this;
+        for (let current of tableOfSigns) {
+            for (let i = 0; i < current.length; i++) {
+                if (i % 2 === 0) {
+                    // t, z or d
+                    if (resultLine[i] === 'd') {
+                        continue
+                    }
+                    if (current[i] !== 't') {
+                        resultLine[i] = current[i]
+                    }
+                } else {
+                    // + or -
+                    if (current[i] === '-') {
+                        resultLine[i] = resultLine[i] === '+' ? '-' : '+'
+                    }
+                }
+            }
         }
 
-        opposed = (): Rational => {
-            this._numerator.opposed();
-            return this;
+        // Add the variation line.
+        // TODO: add the variation line.
+
+        tableOfSigns.push(resultLine)
+
+        let tos = {
+            factors: [...NFactors, ...DFactors],
+            zeroes: zeroes,
+            signs: tableOfSigns,
+            tex: ''
         }
-        add = (R: Rational): Rational => {
-            // 1. Make sure both rational are at the same denominator
-            // 2. Add the numerators.
-            // 3. Simplify
 
-            // Store the adding denominator
-            let denominator = this._denominator.clone()
+        this._makeTexFromTableOfSigns(tos)
 
-            // Amplif the main rational polynom by the adding denominator
-            this.amplify(R._denominator)
+        return tos
+    }
 
-            // Add to the numerator the adding value...
-            this._numerator.add(R._numerator.clone().multiply(denominator));
+    private _makeTexFromTableOfSigns = (tos: { factors: Polynom[], zeroes: ISolution[], signs: (string[])[], tex: string }): string => {
 
-            return this;
-        }
+        let tex = `\\begin{tikzpicture}
+\\tkzTabInit[lgt=3,espcl=2,deltacl=0]{/1.2,\\(${tos.factors.map(x => x.tex).join('\\)/1,\\(')}\\)/1,/.1,\\(f(x)\\)/1.2}{{\\scriptsize \\hspace{1cm} \\(-\\infty\\)},\\(${tos.zeroes.map(x => x.tex).join('\\),\\(')}\\),{\\scriptsize \\hspace{-1cm} \\(+\\infty\\)}}`
+        tos.signs.forEach(list => {
+            tex += (`\n\\tkzTabLine{${list.join(',')}}`)
+        })
+        tex += `\n\\end{tikzpicture}`
 
-        subtract = (R: Rational): Rational => {
-            return this.add(R.clone().opposed())
-        }
+        tos.tex = tex
+
+        return tex
+    }
+    private _makeOneLineOfTableOfSigns = (factor: Polynom, zeroes: ISolution[], zeroSign: string): string[] => {
+        let oneLine: string[] = [],
+            currentZero = factor.getZeroes().map(x=>x.tex)
 
-        limits = (value: Fraction | number, letter?: string): Fraction | number => {
-            if (value === Infinity || value === -Infinity) {
-                let N = this._numerator.monomByDegree(this._numerator.degree(letter), letter),
-                    D = this._denominator.monomByDegree(this._denominator.degree(letter), letter)
 
-                N.divide(D)
+        // First +/- sign, before the first zero
+        oneLine.push('')
+        oneLine.push(factor.evaluate(zeroes[0].value - 1).sign() === 1 ? '+' : '-')
 
-                if (N.degree(letter).isStrictlyPositive()) {
-                    return N.coefficient.sign() * (Math.pow((value > 0 ? 1 : -1), N.degree(letter).value % 2)) === 1 ? Infinity : -Infinity
-                }
-                if (N.degree(letter).isZero()) {
-                    return N.coefficient
-                }
-                if (N.degree(letter).isStrictlyPositive()) {
-                    return N.coefficient.sign() * (Math.pow(-1, N.degree(letter).value % 2)) === 1 ? 0 : -0
-                }
-            } else {
-                return this._numerator.evaluate({letter: new Fraction(value)}).divide(this._denominator.evaluate({letter: new Fraction(value)}))
+        for (let i = 0; i < zeroes.length; i++) {
+            // Add the zero if it's the current one
+            oneLine.push(currentZero.includes(zeroes[i].tex) ? zeroSign : 't')
+
+            // + / - sign after the current zero
+            if (i < zeroes.length - 1) {
+                oneLine.push(factor.evaluate((zeroes[i].value + zeroes[i + 1].value) / 2).sign() === 1 ? '+' : '-')
+            } else if (i === zeroes.length - 1) {
+                oneLine.push(factor.evaluate(zeroes[i].value + 1).sign() === 1 ? '+' : '-')
             }
+
         }
+
+        oneLine.push('')
+
+        return oneLine
     }
+}

package/src/maths/coefficients/fraction.ts

@@ -21,10 +21,6 @@ export class Fraction {
         return this;
     }
 
-    get isFraction() {
-        return true;
-    }
-
     // ------------------------------------------
     // Getter and setter
     // ------------------------------------------
@@ -51,6 +47,10 @@ export class Fraction {
 
     // Display getter
     get tex(): string {
+        if(this.isInfinity()){
+            return `${this.sign()===1?'+':'-'}\\infty`
+        }
+
         if (this._denominator === 1) {
             return `${this._numerator}`;
         } else if (this._numerator < 0) {
@@ -346,6 +346,44 @@ export class Fraction {
         return M
     }
 
+    static average = (...fractions: (Fraction|number)[]): Fraction => {
+        let M = new Fraction().zero()
+
+        for(let f of fractions){
+            M.add(f)
+        }
+
+        M.divide(fractions.length)
+
+        return M
+    }
+
+    static unique = (fractions: Fraction[], sorted?: boolean): Fraction[] => {
+        // TODO: make sure it's wokring -> test !
+        let unique:{[Key:string]:boolean} = {},
+            distinct: Fraction[] = []
+        fractions.forEach(x => {
+            if(!unique[x.clone().reduce().tex]){
+                distinct.push(x.clone())
+                unique[x.tex]=true
+            }
+        })
+
+        if(sorted) {
+            return Fraction.sort(distinct)
+        }else{
+            return distinct
+        }
+    }
+    static sort = (fractions: Fraction[], reverse?:boolean): Fraction[] => {
+        // Todo make sure it's the correct order, not reverse -> make a test
+        let sorted = fractions.sort((a, b)=>a.value-b.value)
+
+        if(reverse){sorted.reverse()}
+
+        return sorted
+    }
+
     // ------------------------------------------
     // Mathematical operations specific to fractions
     // ------------------------------------------
@@ -463,10 +501,10 @@ export class Fraction {
         return isNaN(this._numerator);
     }
     isInfinity = (): boolean => {
-        return this._numerator === Infinity;
+        return Math.abs(this._numerator) === Infinity;
     }
     isFinite = (): boolean => {
-        return !this.isInfinity();
+        return !this.isInfinity() && !this.isNaN();
     }
     isSquare = (): boolean => {
         return Math.sqrt(this._numerator) % 1 === 0 && Math.sqrt(this._denominator) % 1 === 0

package/src/maths/coefficients/{nthroot.ts → nthRoot.ts}

@@ -1,7 +1,7 @@
 /**
- * Nthroot is something like "a+b\sqrt{3}
+ * NthRoot is something like "a+b\sqrt{3}
  */
-export class Nthroot {
+export class NthRoot {
     private _radical: number;
     private _nth: number;
     private _coefficient: number;
@@ -80,7 +80,7 @@ export class Nthroot {
     // ------------------------------------------
     // Creation / parsing functions
     // ------------------------------------------
-    parse = (radical: number, nthroot?: number, coefficient?: number): Nthroot => {
+    parse = (radical: number, nthroot?: number, coefficient?: number): NthRoot => {
         this._coefficient = (coefficient === undefined) ? 1 : coefficient;
         this._nth = (nthroot === undefined) ? 2 : nthroot;
         this._radical = (radical === undefined) ? 1 : radical;
@@ -94,7 +94,7 @@ export class Nthroot {
     // ------------------------------------------
     // Mathematical operations
     // ------------------------------------------
-    reduce = (): Nthroot => {
+    reduce = (): NthRoot => {
         // Max value to test.
         let V = Math.floor(Math.pow(this._radical, 1 / this._nth));
         while (V > 1) {
@@ -112,7 +112,7 @@ export class Nthroot {
         return this;
     };
 
-    multiply = (N: Nthroot): Nthroot => {
+    multiply = (N: NthRoot): NthRoot => {
         this._radical *= N.radical;
         return this.reduce();
     };

package/src/maths/expressions/polynomexp.bkp.ts

@@ -57,9 +57,8 @@ export class PolynomExpFactor {
             }
         }
 
-        console.log(numerators.length)
         if (denominators.length > 0) {
-            return `\\dfrac{ ${numerators.length > 0 ? numerators.join('') : 1} }{ ${denominators.join('')} }`
+            return `\\frac{ ${numerators.length > 0 ? numerators.join('') : 1} }{ ${denominators.join('')} }`
         } else {
             return numerators.join('')
         }

package/src/maths/expressions/polynomexp.ts

@@ -10,6 +10,7 @@ export class PolynomExpFactor {
         this._fn = mathFunction
         this._powerAsInteger = true
         this._forceParenthesis = true
+
     }
 
     private _forceParenthesis: boolean
@@ -206,7 +207,7 @@ export class PolynomExpProduct {
                 // restore all degrees to negative again.
                 denominators.map(x => x.degree.opposed())
 
-                tex = `\\dfrac{ ${numeratorsAsTex.join(' \\cdot ')} }{ ${denominatorsAsTex.join(' \\cdot ')} }`
+                tex = `\\frac{ ${numeratorsAsTex.join(' \\cdot ')} }{ ${denominatorsAsTex.join(' \\cdot ')} }`
             }
         }
 

package/src/maths/geometry/line.ts

@@ -440,7 +440,6 @@ export class Line {
     }
 
     getValueAtX = (value: Fraction|number): Fraction => {
-
         const equ = this.equation.clone().isolate('y'),
             F = new Fraction(value)
 

package/src/maths/geometry/point.ts

@@ -181,7 +181,7 @@ export class Point {
 
             value = V.norm
             fraction = V.normSquare.sqrt()
-            tex = V.normSquare.isSquare()?fraction.tex:`\\sqrt{\\dfrac{ ${V.normSquare.numerator} }{ ${V.normSquare.denominator} }}`
+            tex = V.normSquare.isSquare() ? fraction.tex : `\\sqrt{\\frac{ ${V.normSquare.numerator} }{ ${V.normSquare.denominator} }}`
         }
         return { value, fraction, tex }
     }

package/tests/algebra/equation.test.ts

@@ -0,0 +1,36 @@
+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 }'
+        ] )
+    })
+})

package/tests/algebra/monom.test.ts

@@ -1,10 +1,7 @@
 import {expect} from 'chai';
-import {Monom} from "../../src/maths/algebra";
 import {Random} from "../../src/maths/randomization/random";
 import {describe} from "mocha";
-import {Fraction} from "../../src/maths/coefficients";
-import {Shutingyard} from "../../src/maths/shutingyard";
-import {log} from "util";
+import {Monom} from "../../src/maths/algebra/monom";
 
 describe('Monom with integer power', () => {
     it('parsing', () => {
@@ -79,6 +76,6 @@ describe('Monom with fraction power', () => {
         console.log(M.tex)
 
         // TODO: Problem while displaying numerical expression
-        expect(M.tex).to.be.equal('-\\dfrac{ 7 }{ 5 }x^{\\tfrac{ 22 }{ 15 }}')
+        expect(M.tex).to.be.equal('-\\frac{ 7 }{ 5 }x^{\\tfrac{ 22 }{ 15 }}')
     })
 })

package/tests/algebra/polynom.test.ts

@@ -15,7 +15,7 @@ describe('Polynom tests', () => {
         const P = new Polynom('-3/5x-2')
 
         console.log(P.tex)
-        expect(P.tex).to.be.equal('-\\dfrac{ 3 }{ 5 }x-2')
+        expect(P.tex).to.be.equal('-\\frac{ 3 }{ 5 }x-2')
     })
 
     it('Tex display', () => {
@@ -43,7 +43,7 @@ describe('Polynom tests', () => {
         expect(F.integrate(0, 2).value).to.be.equal(-4)
         expect(G.integrate(-3, 3).display).to.be.equal('174/5')
     })
-    it('Random Polynom of degree 5', () => {
+    it('Random Polynom of degree 6', () => {
         let P = Random.polynom({
             degree: 6,
             numberOfMonoms: 3,
@@ -72,6 +72,10 @@ describe('Polynom tests', () => {
 
         P.factorize()
         expect(P.factors.map(x => x.tex)).to.have.all.members(['x-2', 'x-3'])
+
+        let P2 = new Polynom('x^4-32x^2+256')
+        P2.factorize()
+        expect(P2.factors.map(x => x.tex)).to.have.all.members(['x-4', 'x-4', 'x+4', 'x+4'])
     })
 })
 
@@ -79,7 +83,7 @@ describe('Polynom parsing with rational power', () => {
     it('should parse with rational powers', () => {
         const P = new Polynom('3x^(2/3)-5x+5/3');
 
-        expect(P.tex).to.be.equal('3x^{\\tfrac{ 2 }{ 3 }}-5x+\\dfrac{ 5 }{ 3 }')
+        expect(P.tex).to.be.equal('3x^{\\tfrac{ 2 }{ 3 }}-5x+\\frac{ 5 }{ 3 }')
     })
 })