pimath 0.0.39 → 0.0.42

package/src/maths/algebra/rational.ts

@@ -6,7 +6,7 @@
 import {Polynom} from "./polynom";
 import {Fraction} from "../coefficients/fraction";
 import {literalType} from "./monom";
-import {log} from "util";
+import {Equation, ISolution, PARTICULAR_SOLUTION} from "./equation";
 
 /**
  * Rational class can handle rational polynoms
@@ -41,9 +41,6 @@ export class Rational {
     }
 
     get texFactors(): string {
-        this._numerator.factorize()
-        this._denominator.factorize()
-
         return `\\dfrac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`
     }
 
@@ -56,16 +53,13 @@ export class Rational {
 
     domain = (): string => {
         let zeroes = this._denominator.getZeroes();
-        if (zeroes.length === 0 || zeroes[0] === false) {
-            return '\\mathbb{R}'
-        } else if (zeroes[0] === true) {
-            return '\\varnothing'
+        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 => {
-                    return (typeof x === 'boolean') ? '' : x.frac
-                })
-                    .join(';') + '\\right}'
+            return '\\mathbb{R}\\setminus\\left\\{' +
+                zeroes.map(x => x.tex).join(';') + '\\right\\}'
         }
     }
 
@@ -76,6 +70,18 @@ export class Rational {
         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)
+
+        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()) {
@@ -131,14 +137,13 @@ export class Rational {
             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)
+            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{
+            } else {
                 return quotient.monomByDegree(undefined, letter).coefficient
             }
-        }
-        else {
+        } else {
             let evalValues: literalType = {},
                 evalValuesOffset: literalType = {},
                 theLimit: Fraction | number,
@@ -151,7 +156,7 @@ export class Rational {
                 theLimit = FR._numerator.evaluate(evalValues)
                     .divide(FR._denominator.evaluate(evalValues))
 
-                return theLimit.isInfinity()?theLimit.abs():theLimit
+                return theLimit.isInfinity() ? theLimit.abs() : theLimit
             } else {
                 if (offset === 'above') {
                     evalValuesOffset[letter === undefined ? 'x' : letter] = (new Fraction(value)).add(0.000001)
@@ -165,11 +170,122 @@ export class Rational {
                     .divide(FR._denominator.evaluate(evalValuesOffset)).sign()
 
                 if (theLimit.isInfinity()) {
-                    return theSign===1?theLimit.abs():theLimit.abs().opposed()
-                }else{
+                    return theSign === 1 ? theLimit.abs() : theLimit.abs().opposed()
+                } else {
                     return theLimit
                 }
             }
         }
     }
+
+    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 '+'
+        })
+
+        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] === '+' ? '-' : '+'
+                    }
+                }
+            }
+        }
+
+        // Add the variation line.
+        // TODO: add the variation line.
+
+        tableOfSigns.push(resultLine)
+
+        let tos = {
+            factors: [...NFactors, ...DFactors],
+            zeroes: zeroes,
+            signs: tableOfSigns,
+            tex: ''
+        }
+
+        this._makeTexFromTableOfSigns(tos)
+
+        return tos
+    }
+
+    private _makeTexFromTableOfSigns = (tos: { factors: Polynom[], zeroes: ISolution[], signs: (string[])[], tex: string }): string => {
+
+        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}`
+
+        tos.tex = tex
+
+        return tex
+    }
+    private _makeOneLineOfTableOfSigns = (factor: Polynom, zeroes: ISolution[], zeroSign: string): string[] => {
+        let oneLine: string[] = [],
+            // TODO : check if there is no zero ?
+            currentZero = factor.getZeroes().map(x=>x.tex)
+
+        // First +/- sign, before the first zero
+        oneLine.push('')
+        oneLine.push(factor.evaluate(zeroes[0].value - 1).sign() === 1 ? '+' : '-')
+
+        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
     // ------------------------------------------
@@ -350,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
     // ------------------------------------------
@@ -467,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/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/tests/algebra/equation.test.ts

@@ -0,0 +1,38 @@
+import {describe} from "mocha";
+import {Rational} from "../../src/maths/algebra/rational";
+import {Polynom} from "../../src/maths/algebra/polynom";
+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([
+            '\\dfrac{-7 - \\sqrt{669} }{ 10 }',
+            '\\dfrac{-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', () => {

package/tests/algebra/rationnal.test.ts

@@ -1,7 +1,6 @@
 import {describe} from "mocha";
 import {Rational} from "../../src/maths/algebra/rational";
 import {Polynom} from "../../src/maths/algebra/polynom";
-import {Fraction} from "../../src/maths/coefficients/fraction";
 import {expect} from "chai";
 
 describe('Rational tests', () => {
@@ -12,12 +11,12 @@ describe('Rational tests', () => {
             new Polynom('(x-4)(x+2)')
         )
 
-        expect(FR.limits(4).tex).to.be.equal("Infinity")
-        expect(FR.limits(4, 'below').tex).to.be.equal("-Infinity")
-        expect(FR.limits(4, 'above').tex).to.be.equal("Infinity")
+        expect(FR.limits(4).tex).to.be.equal("+\\infty")
+        expect(FR.limits(4, 'below').tex).to.be.equal("-\\infty")
+        expect(FR.limits(4, 'above').tex).to.be.equal("+\\infty")
         expect(FR.limits(-2).tex).to.be.equal("-\\frac{ 1 }{ 6 }")
     })
-    it('should calculate the limits to Infinity', ()=>{
+    it('should calculate the limits to Infinity', () => {
         const FR0 = new Rational(
             new Polynom('3'),
             new Polynom('x-5')
@@ -41,4 +40,29 @@ describe('Rational tests', () => {
         expect(FR3.limits(Infinity).value).to.be.equal(Infinity)
         expect(FR3.limits(-Infinity).value).to.be.equal(-Infinity)
     })
+
+    it('should make a table of signs', function () {
+
+        // const FR = new Rational(
+        //     new Polynom('(x-2)'),
+        //     new Polynom('(x+2)')
+        // )
+        // let tos = FR.makeTableOfSigns()
+        // expect(tos.zeroes.map(x => x.tex)).to.have.all.members(['-2', '2'])
+        // expect(tos.signs).to.be.eql([['', '-', 't', '-', 'z', '+', ''], ['', '-', 'd', '+', 't', '+', ''], [], ['', '+', 'd', '-', 'z', '+', '']])
+        const FR2 = new Rational(
+            new Polynom('(x-2)(x+5)(x^2+5x-31'),
+            new Polynom('(x+2)')
+        )
+        let tos2 = FR2.makeTableOfSigns()
+    });
+
+    it('should calculate the derivative', function () {
+        const FR = new Rational(
+            new Polynom('x^2+5x+6'),
+            new Polynom('x-3')
+        )
+
+        FR.derivative()
+    });
 })

package/tests/coefficients/fraction.test.ts

@@ -1,5 +1,6 @@
 import {expect} from "chai";
-import {Fraction} from "../../src/maths/coefficients";
+import {Fraction} from "../../src/maths/coefficients/fraction";
+import {describe} from "mocha";
 
 describe('Fraction tests', () => { // the tests container
 
@@ -33,4 +34,45 @@ describe('Fraction tests', () => { // the tests container
         expect(F.isReduced()).to.be.true
         expect(Q.isReduced()).to.be.false
     })
+
+
+})
+
+describe("Fraction static functions", ()=>{
+    it('should sort fractions', function () {
+        let list = [
+            new Fraction('3.5'),
+            new Fraction('-2.5'),
+            new Fraction('3.1'),
+            new Fraction('3.54'),
+            new Fraction('1.5')
+        ]
+
+        expect(Fraction.sort(list).map(x=>x.value)).to.eql([ -2.5, 1.5, 3.1, 3.5, 3.54 ])
+    });
+
+    it('should make a list of fractions unique', function () {
+        let list = [
+            new Fraction('3.5'),
+            new Fraction('-2.5'),
+            new Fraction('7/2'),
+            new Fraction('3.50'),
+            new Fraction('1.5')
+        ]
+
+        expect(Fraction.unique(list, true).map(x=>x.value)).to.be.eql([ -2.5, 1.5, 3.5 ])
+
+    });
+
+    it('shoudl get the average of fractions', function() {
+        let list = [
+            new Fraction('3.5'),
+            new Fraction('-2.5'),
+            new Fraction('7/2'),
+            new Fraction('3.50'),
+            new Fraction('1.5')
+        ]
+
+        expect(Fraction.average(...list).tex).to.be.equal('\\frac{ 19 }{ 10 }')
+    })
 })

package/tests/geometry/circle.test.ts

@@ -1,7 +1,9 @@
 import {describe} from "mocha";
-import {Circle, Line, Point} from "../../src/maths/geometry";
-import {Fraction} from "../../src/maths/coefficients";
 import {expect} from "chai";
+import {Circle} from "../../src/maths/geometry/circle";
+import {Line} from "../../src/maths/geometry/line";
+import {Point} from "../../src/maths/geometry/point";
+import {Fraction} from "../../src/maths/coefficients/fraction";
 
 describe('Circle', function () {
     it('should calculate the intersection of a circle and a line', function () {