pimath 0.0.54 → 0.0.57

package/src/maths/algebra/polynom.ts

@@ -182,7 +182,6 @@ export class Polynom {
                     if (element.token === '-') {
                         stack.push(stack.pop().opposed())
                     } else {
-                        console.error('While parsing, cannot apply ', element.token, 'to', stack[0].tex)
                         throw "Error parsing the polynom " + this._rawString
                     }
                 }
@@ -405,9 +404,14 @@ export class Polynom {
         const quotient: Polynom = new Polynom().zero();
         const reminder: Polynom = this.clone().reorder(letter);
 
-        // There is no variable !
+        // There is no variable - means it's a number
         if (P.variables.length === 0) {
-            return {quotient, reminder}
+            let q = this.clone().divide(P)
+            return {
+                quotient: this.clone().divide(P),
+                reminder: new Polynom().zero()
+            }
+
         }
 
         // Get at least a letter
@@ -444,8 +448,11 @@ export class Polynom {
             return this.divideByFraction(value);
         } else if (typeof value === 'number' && Number.isSafeInteger(value)) {
             return this.divideByInteger(value);
+        } else if (value instanceof Polynom) {
+            if (value.monoms.length === 1 && value.variables.length === 0) {
+                return this.divideByFraction(value.monoms[0].coefficient)
+            }
         }
-
     }
 
     pow = (nb: number): Polynom => {
@@ -778,8 +785,7 @@ export class Polynom {
 
         // It has a common monom.
         if (!M.isOne()) {
-            tempPolynom = new Polynom()
-            tempPolynom.monoms = [M]
+            tempPolynom = new Polynom(M)
             factors = [tempPolynom.clone()]
             P = P.euclidian(tempPolynom).quotient;
         }
@@ -803,8 +809,8 @@ export class Polynom {
                 break
             } else {
                 // Get the first and last monom and build all their dividers.
-                let m1 = P.monoms[0].dividers,
-                    m2 = P.monoms[P.monoms.length - 1].dividers
+                // let m1 = P.monoms[0].dividers,
+                //     m2 = P.monoms[P.monoms.length - 1].dividers
 
                 // Create the list of all "potential" polynom dividers.
                 let allDividers:Polynom[] = this._getAllPotentialFactors(P,letter)

package/src/maths/algebra/rational.ts

@@ -19,9 +19,23 @@ export class Rational {
      * @param numerator
      * @param denominator
      */
-    constructor(numerator?: Polynom, denominator?: Polynom) {
-        this._numerator = numerator ? numerator.clone() : new Polynom();
-        this._denominator = denominator ? denominator.clone() : new Polynom();
+    constructor(numerator?: Polynom | string, denominator?: Polynom | string) {
+        if (numerator instanceof Polynom) {
+            this._numerator = numerator.clone()
+        } else if (typeof numerator === 'string') {
+            this._numerator = new Polynom(numerator)
+        } else {
+            this._numerator = new Polynom()
+        }
+
+        if (denominator instanceof Polynom) {
+            this._denominator = denominator.clone()
+        } else if (typeof denominator === 'string') {
+            this._denominator = new Polynom(denominator)
+        } else {
+            this._denominator = new Polynom()
+        }
+
     }
 
     private _numerator: Polynom;
@@ -183,7 +197,7 @@ export class Rational {
         this._numerator.factorize()
         this._denominator.factorize()
 
-        let zeroes = Equation.makeSolutionsUnique([...this._numerator.getZeroes(), ...this._denominator.getZeroes()], true),
+        let zeroes = Equation.makeSolutionsUnique([...this._numerator.getZeroes(), ...this._denominator.getZeroes()], true).filter(x => !isNaN(x.value)),
             NFactors = this._numerator.factors,
             DFactors = this._denominator.factors
 
@@ -265,12 +279,16 @@ export class Rational {
     }
     private _makeOneLineOfTableOfSigns = (factor: Polynom, zeroes: ISolution[], zeroSign: string): string[] => {
         let oneLine: string[] = [],
-            currentZero = factor.getZeroes().map(x=>x.tex)
-
+            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 ? '+' : '-')
+        if (factor.degree().isZero()) {
+            oneLine.push(factor.monoms[0].coefficient.sign() === 1 ? '+' : '-')
+        } else {
+            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
@@ -285,6 +303,7 @@ export class Rational {
 
         }
 
+
         oneLine.push('')
 
         return oneLine

package/tests/algebra/polynom.test.ts

@@ -76,7 +76,19 @@ describe('Polynom tests', () => {
         let P2 = new Polynom('x^4-32x^2+256')
         P2.factorize()
         expect(P2.factors.map(x => x.tex)).to.have.all.members(['x-4', 'x-4', 'x+4', 'x+4'])
-    })
+
+        let P3 = new Polynom('6x^2-48x-8')
+        P3.factorize()
+        expect(P3.factors.map(x => x.tex)).to.have.all.members(['2', '3x^{2}-24x-4'])
+    });
+
+    it('should factorize special polynom', function () {
+        let P = new Polynom('x^6-16x^5-58x^4+1592x^3-1207x^2-37576x+94864')
+
+        P.factorize()
+
+        console.log(P.factors.map(x=>x.tex))
+    });
 })
 
 describe('Polynom parsing with rational power', () => {

package/tests/algebra/rationnal.test.ts

@@ -93,4 +93,10 @@ describe('Rational tests', () => {
 
         FR.derivative()
     });
+
+    it('should test', function () {
+        let P = new Rational('245', '3x-5')
+        console.log(P.tex)
+        console.log(P.makeTableOfSigns())
+    });
 })