pimath 0.0.73 → 0.0.76

package/src/maths/algebra/polynom.ts

@@ -101,17 +101,39 @@ export class Polynom {
     get texFactors(): string {
         this.factorize()
 
-        if (this.factors.length === 0) {
+        if (this.factors.length <= 1) {
             return this.tex
         }
-        let tex = ''
+
+        // Build an array of texFactors with the number of similar items.
+        let factorsCount: { [Key: string]: { degree: number, factor: Polynom } } = {}
         for (let f of this.factors) {
-            if (f.monoms.length > 1) {
-                tex += `(${f.tex})`
+            if (factorsCount[f.tex] !== undefined) {
+                factorsCount[f.tex].degree++
             } else {
-                tex = f.tex + tex;
+                factorsCount[f.tex] = {
+                    degree: 1,
+                    factor: f
+                }
+            }
+        }
+
+        // First round to put the 'monom' first
+        let simpleFactor = new Polynom().one()
+
+        for (let item of Object.values(factorsCount).filter(item => item.factor.monoms.length === 1)) {
+            simpleFactor.multiply(item.factor)
+        }
+
+        let tex = simpleFactor.isOne() ? '' : simpleFactor.tex
+
+        // Loop through all factors that contains at least 2 monoms.
+        for (let item of Object.values(factorsCount).filter(item => item.factor.monoms.length > 1)) {
+            if (item.factor.length > 1) {
+                tex += `\\left( ${item.factor.tex} \\right)${item.degree > 1 ? '^{ ' + item.degree + ' }' : ''}`
             }
         }
+
         return tex;
     }
 
@@ -780,96 +802,103 @@ export class Polynom {
      * @param maxValue Defines the greatest value to search to (default is 20).
      */
     factorize = (letter?: string): Polynom[] => {
-        if (this.dirty_factors) {
-            let factors: Polynom[] = [];
-
-            let P = this.clone().reorder()
-
-            // Extract the common monom
-            // 2x^3+6x^2 => 2x^2
-            let M = P.commonMonom()
-            if (!M.isOne()) {
-                let tempPolynom: Polynom = new Polynom(M)
-                factors = [tempPolynom.clone()]
-                P = P.euclidian(tempPolynom).quotient;
-            }
+        if (!this.dirty_factors) {
+            return this._factors
+        }
 
-            // Main loop
-            let securityLoop = P.degree().clone().multiply(2).value,
-                maxDegree = 1
-            while (securityLoop >= 0) {
-                securityLoop--
-                if (P.monoms.length < 2) {
-                    // The polynom has only one monom => 7x^2
-                    // No need to continue.
-                    if (!P.isOne()) {
-                        factors.push(P.clone())
-                        P.one()
-                    }
-                    break
-                } else if (P.degree(letter).isOne()) {
-                    // The polynom is a first degree polynom => 3x-5
-                    // No need to continue
+
+        let factors: Polynom[] = [];
+        let P = this.clone().reorder()
+
+        // Extract the common monom
+        // 2x^3+6x^2 => 2x^2
+        let M = P.commonMonom()
+        // If the polynom starts with a negative monom, factorize it.
+        if(P.monomByDegree().coefficient.isStrictlyNegative() && M.coefficient.isStrictlyPositive()){
+            M.opposed()
+        }
+
+        if (!M.isOne()) {
+            let tempPolynom: Polynom = new Polynom(M)
+            factors = [tempPolynom.clone()]
+            P = P.euclidian(tempPolynom).quotient;
+        }
+
+        // Main loop
+        let securityLoop = P.degree().clone().multiply(2).value,
+            maxDegree = 1
+        while (securityLoop >= 0) {
+            securityLoop--
+            if (P.monoms.length < 2) {
+                // The polynom has only one monom => 7x^2
+                // No need to continue.
+                if (!P.isOne()) {
                     factors.push(P.clone())
                     P.one()
-                    break
-                } else {
-                    // Create the list of all "potential" polynom dividers.
-                    let allDividers: Polynom[] = this._getAllPotentialFactors(P, maxDegree, letter)
-                    maxDegree = P.degree(letter).value
+                }
+                break
+            } else if (P.degree(letter).isOne()) {
+                // The polynom is a first degree polynom => 3x-5
+                // No need to continue
+                factors.push(P.clone())
+                P.one()
+                break
+            } else {
+                // Create the list of all "potential" polynom dividers.
+                let allDividers: Polynom[] = this._getAllPotentialFactors(P, maxDegree, letter)
+                maxDegree = P.degree(letter).value
 
-                    // Actually: 100ms
-                    while (allDividers.length > 0) {
-                        let div = allDividers[0]
+                // Actually: 100ms
+                while (allDividers.length > 0) {
+                    let div = allDividers[0]
 
-                        if (!P.isDividableBy(div)) {
-                            // Not dividable. Remove it from the list
-                            allDividers.shift()
-                        } else {
-                            // It's dividable - so make the division
-                            let result = P.euclidian(div)
+                    if (!P.isDividableBy(div)) {
+                        // Not dividable. Remove it from the list
+                        allDividers.shift()
+                    } else {
+                        // It's dividable - so make the division
+                        let result = P.euclidian(div)
 
-                            // Add the factor
-                            factors.push(div)
+                        // Add the factor
+                        factors.push(div)
 
-                            // As it's dividable, get the quotient.
-                            P = result.quotient.clone()
+                        // As it's dividable, get the quotient.
+                        P = result.quotient.clone()
 
-                            // filter all dividers that are no more suitable.
-                            allDividers = allDividers.filter(x => {
-                                let pX = P.monoms[0],
-                                    pC = P.monoms[P.monoms.length - 1],
-                                    dX = x.monoms[0],
-                                    dC = x.monoms[x.monoms.length - 1]
+                        // filter all dividers that are no more suitable.
+                        allDividers = allDividers.filter(x => {
+                            let pX = P.monoms[0],
+                                pC = P.monoms[P.monoms.length - 1],
+                                dX = x.monoms[0],
+                                dC = x.monoms[x.monoms.length - 1]
 
-                                // Check last item (degree zero)
-                                if (!pC.isDivisible(dC)) {
-                                    return false
-                                }
+                            // Check last item (degree zero)
+                            if (!pC.isDivisible(dC)) {
+                                return false
+                            }
 
-                                // Check the first item (degree max)
-                                if (!pX.isDivisible(dX)) {
-                                    return false
-                                }
+                            // Check the first item (degree max)
+                            if (!pX.isDivisible(dX)) {
+                                return false
+                            }
 
-                                return true
-                            })
-                        }
+                            return true
+                        })
                     }
                 }
             }
+        }
 
-            // Maybe there is still something in the Polynom (not everything was possible to factorize)
-            if (!P.isOne()) {
-                factors.push(P.clone())
-            }
+        // Maybe there is still something in the Polynom (not everything was possible to factorize)
+        if (!P.isOne()) {
+            factors.push(P.clone())
+        }
 
-            // Save the factors
-            this._factors = factors
+        // Save the factors
+        this._factors = factors
 
-            // The factors list is no more dirty
-            this.dirty_factors = false
-        }
+        // The factors list is no more dirty
+        this.dirty_factors = false
 
         return this._factors;
     }

package/src/maths/algebra/rational.ts

@@ -100,6 +100,12 @@ export class Rational {
         return this
     }
 
+    factorize = (letter?: string): Rational => {
+        this._numerator.factorize(letter)
+        this._denominator.factorize(letter)
+        return this
+    }
+
     simplify = (P: Polynom): Rational => {
         let NumeratorEuclidien = this._numerator.euclidian(P);
         if (!NumeratorEuclidien.reminder.isZero()) {

package/src/maths/expressions/numexp.ts

@@ -145,6 +145,13 @@ export class NumExp {
                     this._addToStack(stack, Math.tan(a))
                 } else if(element.token === 'sqrt') {
                     this._addToStack(stack, Math.sqrt(a))
+                }else if(element.token ==='nthrt') {
+                    // TODO: support nthrt in num. exp.
+                    // this._addToStack(stack, Math.pow(a, 1/b))
+                } else if(element.token === 'ln'){
+                    this._addToStack(stack, Math.log(a))
+                } else if(element.token === 'log') {
+                    this._addToStack(stack, Math.log10(a))
                 }
             }
         }

package/src/maths/shutingyard.ts

@@ -90,6 +90,9 @@ export class Shutingyard {
                 'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
                 'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
                 'sqrt': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'nthrt': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'ln': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'log': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
             }
             this._uniformize = false
         } else if (this._mode === ShutingyardMode.EXPRESSION) {

package/tests/algebra/polynom.test.ts

@@ -5,6 +5,7 @@ import {Polynom} from "../../src/maths/algebra/polynom";
 import {Fraction} from "../../src/maths/coefficients/fraction";
 import exp = require("constants");
 
+
 describe('Polynom tests', () => {
     it('Parse polynom', () => {
         const options = new Polynom('2x(x+3)^2(x-1)');
@@ -86,14 +87,23 @@ describe('Polynom tests', () => {
         let P = new Polynom('x^6-16x^5-58x^4+1592x^3-1207x^2-37576x+94864')
 
         P.factorize()
-        expect(P.factors.map(x=>x.tex)).to.have.all.members([ 'x-4', 'x-4', 'x+7', 'x+7', 'x-11', 'x-11' ])
+        expect(P.factors.map(x => x.tex)).to.have.all.members(['x-4', 'x-4', 'x+7', 'x+7', 'x-11', 'x-11'])
+    });
+
+    it('should factorize and regroup', function () {
+        let P = new Polynom('7x(x-3)(x+5)(x^2-9)3x')
+        P.factorize()
+        expect(P.texFactors).to.be.equal('21x^{2}\\left( x+3 \\right)\\left( x-3 \\right)^{ 2 }\\left( x+5 \\right)')
+
+        const P2 = new Polynom('-2x^3+18x')
+        P2.factorize()
+        expect(P2.texFactors).to.be.equal('-2x\\left( x+3 \\right)\\left( x-3 \\right)')
     });
 })
 
 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+\\frac{ 5 }{ 3 }')
     })
 })