pimath 0.0.40 → 0.0.41

package/src/maths/algebra/equation.ts

@@ -2,22 +2,28 @@ import {Polynom} from "./polynom";
 import {literalType, Monom} from "./monom";
 import {Numeric} from "../numeric";
 import {Fraction} from "../coefficients/fraction";
-import {Nthroot} from "../coefficients/nthroot";
+import {NthRoot} from "../coefficients/nthRoot";
 
 /**
  * Equation is a class to manage equations...
  */
-interface ISolution {
+export interface ISolution {
     tex: string,
     value: number,
     exact: unknown
 }
 
+export enum PARTICULAR_SOLUTION {
+    real="\\mathbb{R}",
+    varnothing="\\varnothing"
+}
+
 export class Equation {
     private _polynom: Polynom;  // Used to solve the equation // TODO: remove the private value ?
+
     // Undetermined texSolutions.
-    private _varnothing: string = '\\varnothing';
-    private _real: string = '\\mathbb{R}';
+    private _varnothing: string = PARTICULAR_SOLUTION.varnothing;
+    private _real: string = PARTICULAR_SOLUTION.real;
 
     /**
      * Create an Equation using two polynoms.
@@ -397,9 +403,29 @@ export class Equation {
             default:
                 this._solveDegree3plus();
         }
+
+        // cleanup the solutions.
+        this._solutions = Equation.makeSolutionsUnique(this._solutions)
         return this;
     };
 
+    static makeSolutionsUnique(solutions: ISolution[], sorted?: boolean):ISolution[] {
+        let solutionAsTex:string[] = [],
+            uniqueSolutions = solutions.filter(sol=>{
+                if(!solutionAsTex.includes(sol.tex)){
+                    solutionAsTex.push(sol.tex)
+                    return true
+                }else{
+                    return false
+                }
+            })
+
+        if(sorted===true){
+            uniqueSolutions.sort((a, b)=>a.value-b.value)
+        }
+        return uniqueSolutions
+    }
+
     test = (values: literalType): Boolean => {
         return this.left.evaluate(values).isEqual(this.right.evaluate(values))
     }
@@ -526,12 +552,13 @@ export class Equation {
                 }
             } else {
                 this._solutions = [{
-                    tex: v.display,
+                    tex: v.tex,
                     value: v.value,
                     exact: v
                 }]
             }
-        } else {
+        }
+        else {
             if (m1.value === 0) {
                 // In this case, the coefficient of the x variable is zero.
                 if (m0.value === 0 && this.isAlsoEqual()) {
@@ -565,7 +592,7 @@ export class Equation {
         let aF = this._polynom.monomByDegree(2, letter).coefficient,
             bF = this._polynom.monomByDegree(1, letter).coefficient,
             cF = this._polynom.monomByDegree(0, letter).coefficient,
-            delta: number, nthDelta: Nthroot,
+            delta: number, nthDelta: NthRoot,
             lcm = Numeric.lcm(aF.denominator, bF.denominator, cF.denominator),
             a = aF.multiply(lcm).value,
             b = bF.multiply(lcm).value,
@@ -594,7 +621,7 @@ export class Equation {
                     }
                 ]
             } else {
-                nthDelta = new Nthroot(delta).reduce();
+                nthDelta = new NthRoot(delta).reduce();
                 if (nthDelta.hasRadical()) {
                     // -b +- coeff\sqrt{radical}
                     // -------------------------
@@ -696,7 +723,6 @@ export class Equation {
             }];
         }
 
-
         // Handle now the inequations.
         if (!this.isStrictEqual()) {
             if (this._solutions.length === 2) {
@@ -763,9 +789,29 @@ export class Equation {
         return this._solutions;
     };
 
-    private _solveDegree3plus = (): ISolution[] => {
-        // TODO: try to resolve equations with a degree superior than 2.
-        this._solutions = [{tex: 'solve x - not yet handled', value: NaN, exact: false}];  // ESLint remove system :(
+    private _solveDegree3plus = (letter?: string): ISolution[] => {
+        // Push everything to the left
+        // factorize
+        // solve each factors.
+        let equ = this.clone().moveLeft()
+        equ.left.factorize()
+
+        this._solutions = []
+
+        equ.left.factors.forEach(factor=>{
+            if(factor.degree(letter).leq(2)) {
+                let factorAsEquation = new Equation(factor, 0)
+                factorAsEquation.solve()
+                factorAsEquation.solutions.forEach(solution => {
+                    this._solutions.push(solution)
+                })
+            }else{
+                console.log(factor.tex, ': cannot actually get the solution of this equation')
+            }
+        })
+
+        // TODO: check equation resolution for more than degree 2
+        // this._solutions = [{tex: 'solve x - not yet handled', value: NaN, exact: false}];  // ESLint remove system :(
         return this._solutions;
     };
 }

package/src/maths/algebra/polynom.ts

@@ -6,6 +6,7 @@ import {literalType, Monom} from './monom';
 import {Shutingyard, ShutingyardType, Token} from '../shutingyard';
 import {Numeric} from '../numeric';
 import {Fraction} from "../coefficients/fraction";
+import {Equation, ISolution} from "./equation";
 
 export type PolynomParsingType = string | Polynom | number | Fraction | Monom
 
@@ -65,6 +66,9 @@ export class Polynom {
     get texFactors(): string {
         this.factorize()
 
+        if(this.factors.length===0){
+            return this.tex
+        }
         let tex = ''
         for (let f of this.factors) {
             if (f.monoms.length > 1) {
@@ -773,6 +777,7 @@ export class Polynom {
         }
 
         let securityLoop = P.degree().clone().multiply(2).value
+        let result
         // securityLoop = 0
 
         while (securityLoop >= 0) {
@@ -791,8 +796,8 @@ export class Polynom {
                 for (let m1d of m1) {
                     for (let m2d of m2) {
                         // if(m1d.degree()===m2d.degree()){continue}
-                        let dividerPolynom = new Polynom(),
-                            result
+                        let dividerPolynom = new Polynom()
+
                         dividerPolynom.monoms = [m1d.clone(), m2d.clone()]
                         result = P.euclidian(dividerPolynom)
 
@@ -813,77 +818,104 @@ export class Polynom {
             }
         }
 
+        if(!P.isOne()){factors.push(P.clone())}
+
         this.factors = factors
         return factors;
     }
 
     // TODO: get zeroes for more than first degree and for more than natural degrees
-    getZeroes = (): (Fraction | boolean)[] => {
-        const Z: Fraction[] = [];
-
-        switch (this.degree().value) {
-            case 0:
-                if (this._monoms[0].coefficient.value === 0) {
-                    return [true];
-                } else {
-                    return [false];
-                }
-            case 1:
-                // There is only one monoms,
-                if (this._monoms.length === 1) {
-                    return [new Fraction().zero()];
-                } else {
-                    const P = this.clone().reduce().reorder();
-                    return [P.monoms[1].coefficient.opposed().divide(P.monoms[0].coefficient)];
-                }
-            // TODO: Determine the zeros of an equation of second degree.
-            //case 2:
-            default:
-                // Make sure the polynom is factorized.
-                if (this._factors.length === 0) {
-                    this.factorize()
-                }
-
-                let zeroes = [], zeroesAsTex = [];
-                for (let P of this._factors) {
-                    if (P.degree().greater(2)) {
-                        // TODO: Handle other polynom.
-
-                    } else if (P.degree().value === 2) {
-                        let A = P.monomByDegree(2).coefficient,
-                            B = P.monomByDegree(1).coefficient,
-                            C = P.monomByDegree(0).coefficient,
-                            D = B.clone().pow(2).subtract(A.clone().multiply(C).multiply(4));
-
-                        if (D.value > 0) {
-                            /*console.log('Two zeroes for ', P.tex); */
-                            let x1 = (-(B.value) + Math.sqrt(D.value)) / (2 * A.value),
-                                x2 = (-(B.value) - Math.sqrt(D.value)) / (2 * A.value);
-
-                            zeroes.push(new Fraction(x1.toFixed(3)).reduce());
-                            zeroes.push(new Fraction(x2.toFixed(3)).reduce());
-                        } else if (D.value === 0) {
-                            /*console.log('One zero for ', P.tex); */
-
-                        } else {
-                            console.log('No zero for ', P.tex);
-                        }
-                    } else {
-                        for (let z of P.getZeroes()) {
-                            // Check if the zero is already in the list.
-                            if (z === false || z === true) {
-                                continue;
-                            }
-                            if (zeroesAsTex.indexOf(z.frac) === -1) {
-                                zeroes.push(z);
-                                zeroesAsTex.push(z.frac);
-                            }
-                        }
-                    }
-                }
-                return zeroes;
-        }
-        return Z;
+    getZeroes = (): ISolution[] => {
+        let equ = new Equation(this.clone(), 0)
+        equ.solve()
+        return equ.solutions
+
+        //
+        // const Z: Fraction[] = [];
+        //
+        // // ISolution: {tex: string, value: number, exact: boolean|Fraction|...}
+        //
+        // switch (this.degree().value) {
+        //     case 0:
+        //         if (this._monoms[0].coefficient.value === 0) {
+        //             return [{
+        //                 tex: '\\mathbb{R}',
+        //                 value: NaN,
+        //                 exact: false
+        //             }];
+        //         } else {
+        //             return [{
+        //                 tex: '\\varnothing',
+        //                 value: NaN,
+        //                 exact: false
+        //             }];
+        //         }
+        //     case 1:
+        //         // There is only one monoms,
+        //         if (this._monoms.length === 1) {
+        //             return [{
+        //                 tex: '0',
+        //                 value: 0,
+        //                 exact: new Fraction().zero()
+        //             }];
+        //         } else {
+        //             const P = this.clone().reduce().reorder();
+        //             const coeff = P.monoms[1].coefficient.opposed().divide(P.monoms[0].coefficient)
+        //             return [{
+        //                 tex: coeff.tex,
+        //                 value: coeff.value,
+        //                 exact: coeff
+        //             }];
+        //         }
+        //     // TODO: Determine the zeros of an equation of second degree.
+        //     //case 2:
+        //     default:
+        //         // Make sure the polynom is factorized.
+        //         if (this._factors.length === 0) {
+        //             this.factorize()
+        //         }
+        //
+        //         let zeroes:Fraction[] = [], zeroesAsTex = [];
+        //         for (let P of this._factors) {
+        //             if (P.degree().greater(2)) {
+        //                 // TODO: get zeroes of polynom with a degree greater than 2.
+        //
+        //             } else if (P.degree().value === 2) {
+        //                 let A = P.monomByDegree(2).coefficient,
+        //                     B = P.monomByDegree(1).coefficient,
+        //                     C = P.monomByDegree(0).coefficient,
+        //                     D = B.clone().pow(2).subtract(A.clone().multiply(C).multiply(4));
+        //
+        //                 if (D.value > 0) {
+        //                     /*console.log('Two zeroes for ', P.tex); */
+        //                     let x1 = (-(B.value) + Math.sqrt(D.value)) / (2 * A.value),
+        //                         x2 = (-(B.value) - Math.sqrt(D.value)) / (2 * A.value);
+        //
+        //                     zeroes.push(new Fraction(x1.toFixed(3)).reduce());
+        //                     zeroes.push(new Fraction(x2.toFixed(3)).reduce());
+        //                 } else if (D.value === 0) {
+        //                     /*console.log('One zero for ', P.tex); */
+        //                 } else {
+        //                     console.log('No zero for ', P.tex);
+        //                 }
+        //             } else {
+        //                 for (let z of P.getZeroes()) {
+        //                     // Check if the zero is already in the list.
+        //                     // if (z === false || z === true) {
+        //                     //     continue;
+        //                     // }
+        //                     if (zeroesAsTex.indexOf(z.frac) === -1) {
+        //                         zeroes.push(z);
+        //                         zeroesAsTex.push(z.frac);
+        //                     }
+        //                 }
+        //             }
+        //         }
+        //
+        //
+        //         return zeroes;
+        // }
+        // return Z;
     };
 
     // TODO: analyse the next functions to determine if they are useful or not...

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}'
+                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
     // ------------------------------------------
@@ -470,7 +504,7 @@ export class Fraction {
         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();
     };