pimath 0.0.42 → 0.0.43

package/src/maths/algebra/rational.ts

@@ -5,287 +5,143 @@
 
 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;
-
-    /**
-     *
-     * @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 `\\dfrac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
-    }
-
-    get texFactors(): string {
-        return `\\dfrac{ ${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\\}'
+    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();
         }
-    }
 
-    amplify = (P: Polynom): Rational => {
-        this._numerator.multiply(P);
-        this._denominator.multiply(P);
-
-        return this;
-    }
+        clone = (): Rational => {
+            this._numerator = this._numerator.clone()
+            this._denominator = this._denominator.clone()
 
-    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()) {
             return this;
         }
 
-        let DenominatorEuclidien = this._denominator.euclidian(P);
-        if (!DenominatorEuclidien.reminder.isZero()) {
-            return this;
+        get tex(): string {
+            return `\\dfrac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
         }
 
-        this._numerator = NumeratorEuclidien.quotient;
-        this._denominator = DenominatorEuclidien.quotient;
-        return this;
-    }
+        get texFactors(): string {
+            this._numerator.factorize()
+            this._denominator.factorize()
 
-    reduce = (): Rational => {
-        this._numerator.factorize();
-        for (let f of this._numerator.factors) {
-            this.simplify(f);
+            return `\\dfrac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`
         }
 
-        return this;
-    }
-
-    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
-
-        // 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 quotient.monomByDegree(undefined, letter).coefficient
-            }
-        } else {
-            let evalValues: literalType = {},
-                evalValuesOffset: literalType = {},
-                theLimit: Fraction | number,
-                theSign: number,
-                FR = this.clone().reduce()
-
-            evalValues[letter === undefined ? 'x' : letter] = new Fraction(value)
+        get numerator(): Polynom {
+            return this._numerator
+        }
 
-            if (offset !== 'above' && offset !== 'below') {
-                theLimit = FR._numerator.evaluate(evalValues)
-                    .divide(FR._denominator.evaluate(evalValues))
+        get denominator(): Polynom {
+            return this._denominator
+        }
 
-                return theLimit.isInfinity() ? theLimit.abs() : theLimit
+        domain = (): string => {
+            let zeroes = this._denominator.getZeroes();
+            if (zeroes.length === 0 || zeroes[0] === false) {
+                return '\\mathbb{R}'
+            } else if (zeroes[0] === true) {
+                return '\\varnothing'
             } 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)
-                }
-
-                theLimit = FR._numerator.evaluate(evalValues)
-                    .divide(FR._denominator.evaluate(evalValues))
-                theSign = FR._numerator.evaluate(evalValuesOffset)
-                    .divide(FR._denominator.evaluate(evalValuesOffset)).sign()
-
-                if (theLimit.isInfinity()) {
-                    return theSign === 1 ? theLimit.abs() : theLimit.abs().opposed()
-                } else {
-                    return theLimit
-                }
+                return '\\mathbb{R}\\setminus\\left{' +
+                    zeroes.map(x => {
+                        return (typeof x === 'boolean') ? '' : x.frac
+                    })
+                        .join(';') + '\\right}'
             }
         }
-    }
-
-    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[] = []
+        amplify = (P: Polynom): Rational => {
+            this._numerator.multiply(P);
+            this._denominator.multiply(P);
 
-        NFactors.forEach(factor => {
-            tableOfSigns.push(this._makeOneLineOfTableOfSigns(factor, zeroes, 'z'))
-        })
-        DFactors.forEach(factor => {
-            tableOfSigns.push(this._makeOneLineOfTableOfSigns(factor, zeroes, 'd'))
-        })
-
-        // Empty line
-        tableOfSigns.push([])
+            return this;
+        }
 
-        // 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 ''
+        simplify = (P: Polynom): Rational => {
+            let NumeratorEuclidien = this._numerator.euclidian(P);
+            if (!NumeratorEuclidien.reminder.isZero()) {
+                return this;
             }
-            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] === '+' ? '-' : '+'
-                    }
-                }
+            let DenominatorEuclidien = this._denominator.euclidian(P);
+            if (!DenominatorEuclidien.reminder.isZero()) {
+                return this;
             }
-        }
 
-        // Add the variation line.
-        // TODO: add the variation line.
+            this._numerator = NumeratorEuclidien.quotient;
+            this._denominator = DenominatorEuclidien.quotient;
+            return this;
+        }
 
-        tableOfSigns.push(resultLine)
+        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);
+            }
 
-        let tos = {
-            factors: [...NFactors, ...DFactors],
-            zeroes: zeroes,
-            signs: tableOfSigns,
-            tex: ''
+            return this;
         }
 
-        this._makeTexFromTableOfSigns(tos)
+        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
 
-        return tos
-    }
+            // Store the adding denominator
+            let denominator = this._denominator.clone()
 
-    private _makeTexFromTableOfSigns = (tos: { factors: Polynom[], zeroes: ISolution[], signs: (string[])[], tex: string }): string => {
+            // Amplif the main rational polynom by the adding denominator
+            this.amplify(R._denominator)
 
-        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}`
+            // Add to the numerator the adding value...
+            this._numerator.add(R._numerator.clone().multiply(denominator));
 
-        tos.tex = tex
+            return this;
+        }
 
-        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)
+        subtract = (R: Rational): Rational => {
+            return this.add(R.clone().opposed())
+        }
 
-        // First +/- sign, before the first zero
-        oneLine.push('')
-        oneLine.push(factor.evaluate(zeroes[0].value - 1).sign() === 1 ? '+' : '-')
+        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)
 
-        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')
+                N.divide(D)
 
-            // + / - 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 ? '+' : '-')
+                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)}))
             }
-
         }
-        oneLine.push('')
-
-        return oneLine
     }
-}

package/src/maths/coefficients/fraction.ts

@@ -21,6 +21,10 @@ export class Fraction {
         return this;
     }
 
+    get isFraction() {
+        return true;
+    }
+
     // ------------------------------------------
     // Getter and setter
     // ------------------------------------------
@@ -47,10 +51,6 @@ 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,44 +346,6 @@ 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
     // ------------------------------------------
@@ -501,10 +463,10 @@ export class Fraction {
         return isNaN(this._numerator);
     }
     isInfinity = (): boolean => {
-        return Math.abs(this._numerator) === Infinity;
+        return this._numerator === Infinity;
     }
     isFinite = (): boolean => {
-        return !this.isInfinity() && !this.isNaN();
+        return !this.isInfinity();
     }
     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,6 +440,7 @@ export class Line {
     }
 
     getValueAtX = (value: Fraction|number): Fraction => {
+
         const equ = this.equation.clone().isolate('y'),
             F = new Fraction(value)
 

package/tests/algebra/monom.test.ts

@@ -1,7 +1,10 @@
 import {expect} from 'chai';
+import {Monom} from "../../src/maths/algebra";
 import {Random} from "../../src/maths/randomization/random";
 import {describe} from "mocha";
-import {Monom} from "../../src/maths/algebra/monom";
+import {Fraction} from "../../src/maths/coefficients";
+import {Shutingyard} from "../../src/maths/shutingyard";
+import {log} from "util";
 
 describe('Monom with integer power', () => {
     it('parsing', () => {

package/tests/coefficients/fraction.test.ts

@@ -1,6 +1,5 @@
 import {expect} from "chai";
-import {Fraction} from "../../src/maths/coefficients/fraction";
-import {describe} from "mocha";
+import {Fraction} from "../../src/maths/coefficients";
 
 describe('Fraction tests', () => { // the tests container
 
@@ -34,45 +33,4 @@ 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,9 +1,7 @@
 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 () {

package/tests/algebra/equation.test.ts

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