pimath 0.0.38 → 0.0.39

package/src/maths/algebra/rational.ts

@@ -5,143 +5,171 @@
 
 import {Polynom} from "./polynom";
 import {Fraction} from "../coefficients/fraction";
+import {literalType} from "./monom";
+import {log} from "util";
 
 /**
  * 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();
+    }
 
-        clone = (): Rational => {
-            this._numerator = this._numerator.clone()
-            this._denominator = this._denominator.clone()
+    private _numerator: Polynom;
 
-            return this;
-        }
+    get numerator(): Polynom {
+        return this._numerator
+    }
 
-        get tex(): string {
-            return `\\dfrac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
-        }
+    private _denominator: Polynom;
 
-        get texFactors(): string {
-            this._numerator.factorize()
-            this._denominator.factorize()
+    get denominator(): Polynom {
+        return this._denominator
+    }
 
-            return `\\dfrac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`
-        }
+    get tex(): string {
+        return `\\dfrac{ ${this._numerator.tex} }{ ${this._denominator.tex} }`;
+    }
 
-        get numerator(): Polynom {
-            return this._numerator
-        }
+    get texFactors(): string {
+        this._numerator.factorize()
+        this._denominator.factorize()
 
-        get denominator(): Polynom {
-            return this._denominator
-        }
+        return `\\dfrac{ ${this._numerator.texFactors} }{ ${this._denominator.texFactors} }`
+    }
 
-        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 {
-                return '\\mathbb{R}\\setminus\\left{' +
-                    zeroes.map(x => {
-                        return (typeof x === 'boolean') ? '' : x.frac
-                    })
-                        .join(';') + '\\right}'
-            }
-        }
+    clone = (): Rational => {
+        this._numerator = this._numerator.clone()
+        this._denominator = this._denominator.clone()
 
-        amplify = (P: Polynom): Rational => {
-            this._numerator.multiply(P);
-            this._denominator.multiply(P);
+        return this;
+    }
 
-            return this;
+    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 {
+            return '\\mathbb{R}\\setminus\\left{' +
+                zeroes.map(x => {
+                    return (typeof x === 'boolean') ? '' : x.frac
+                })
+                    .join(';') + '\\right}'
         }
+    }
 
-        simplify = (P: Polynom): Rational => {
-            let NumeratorEuclidien = this._numerator.euclidian(P);
-            if (!NumeratorEuclidien.reminder.isZero()) {
-                return this;
-            }
+    amplify = (P: Polynom): Rational => {
+        this._numerator.multiply(P);
+        this._denominator.multiply(P);
 
-            let DenominatorEuclidien = this._denominator.euclidian(P);
-            if (!DenominatorEuclidien.reminder.isZero()) {
-                return this;
-            }
+        return this;
+    }
 
-            this._numerator = NumeratorEuclidien.quotient;
-            this._denominator = DenominatorEuclidien.quotient;
+    simplify = (P: Polynom): Rational => {
+        let NumeratorEuclidien = this._numerator.euclidian(P);
+        if (!NumeratorEuclidien.reminder.isZero()) {
             return this;
         }
 
-        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 DenominatorEuclidien = this._denominator.euclidian(P);
+        if (!DenominatorEuclidien.reminder.isZero()) {
             return this;
         }
 
-        opposed = (): Rational => {
-            this._numerator.opposed();
-            return this;
+        this._numerator = NumeratorEuclidien.quotient;
+        this._denominator = DenominatorEuclidien.quotient;
+        return this;
+    }
+
+    reduce = (): Rational => {
+        this._numerator.factorize();
+        for (let f of this._numerator.factors) {
+            this.simplify(f);
         }
-        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()
+        return this;
+    }
 
-            // Amplif the main rational polynom by the adding denominator
-            this.amplify(R._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
 
-            // Add to the numerator the adding value...
-            this._numerator.add(R._numerator.clone().multiply(denominator));
+        // Store the adding denominator
+        let denominator = this._denominator.clone()
 
-            return this;
-        }
+        // Amplif the main rational polynom by the adding denominator
+        this.amplify(R._denominator)
 
-        subtract = (R: Rational): Rational => {
-            return this.add(R.clone().opposed())
+        // 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()
 
-        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)
+            evalValues[letter === undefined ? 'x' : letter] = new Fraction(value)
 
-                N.divide(D)
+            if (offset !== 'above' && offset !== 'below') {
+                theLimit = FR._numerator.evaluate(evalValues)
+                    .divide(FR._denominator.evaluate(evalValues))
 
-                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
+                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)
                 }
-                if (N.degree(letter).isStrictlyPositive()) {
-                    return N.coefficient.sign() * (Math.pow(-1, N.degree(letter).value % 2)) === 1 ? 0 : -0
+
+                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
                 }
-            } else {
-                return this._numerator.evaluate({letter: new Fraction(value)}).divide(this._denominator.evaluate({letter: new Fraction(value)}))
             }
         }
     }
+}

package/src/maths/coefficients/fraction.ts

@@ -51,6 +51,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) {

package/src/maths/geometry/line.ts

@@ -195,6 +195,12 @@ export class Line {
                 }else if (values[2] === LinePropriety.Parallel){
                     return this.parseByPointAndVector(values[0], values[1])
                 }
+            }else if (values[0] instanceof Point && values[1] instanceof Line ) {
+                if(values[2]===LinePropriety.Parallel || values[2]===null) {
+                    return this.parseByPointAndLine(values[0], values[1], LinePropriety.Parallel)
+                }else{
+                    return this.parseByPointAndLine(values[0], values[1], LinePropriety.Perpendicular)
+                }
             }
         }
 

package/src/maths/geometry/point.ts

@@ -10,8 +10,8 @@ import {Fraction} from "../coefficients/fraction";
  * Helper class - a way to identify an object {x: number, y: number}
  */
 class PointXY {
-    public x: number
-    public y: number
+    x: number
+    y: number
 }
 
 export class Point {

package/tests/algebra/rationnal.test.ts

@@ -0,0 +1,44 @@
+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', () => {
+    it('should calculate correctly the limits to a value', () => {
+
+        const FR = new Rational(
+            new Polynom('(x+2)'),
+            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(-2).tex).to.be.equal("-\\frac{ 1 }{ 6 }")
+    })
+    it('should calculate the limits to Infinity', ()=>{
+        const FR0 = new Rational(
+            new Polynom('3'),
+            new Polynom('x-5')
+        )
+        const FR2 = new Rational(
+            new Polynom('2x+5'),
+            new Polynom('x-5')
+        )
+
+        const FR3 = new Rational(
+            new Polynom('2x^2+5'),
+            new Polynom('x-5')
+        )
+
+        expect(FR0.limits(Infinity).value).to.be.equal(0)
+        expect(FR0.limits(-Infinity).value).to.be.equal(0)
+
+        expect(FR2.limits(Infinity).value).to.be.equal(2)
+        expect(FR2.limits(-Infinity).value).to.be.equal(2)
+
+        expect(FR3.limits(Infinity).value).to.be.equal(Infinity)
+        expect(FR3.limits(-Infinity).value).to.be.equal(-Infinity)
+    })
+})