pimath 0.0.101 → 0.0.102

package/src/maths/algebra/linearSystem.ts

@@ -13,7 +13,7 @@ export class LinearSystem {
 
     constructor(...equationStrings: string[]) {
         this._equations = [];
-        this._letters = 'xy'.split('');
+        this._letters = 'xyz'.split('');
 
         if (equationStrings !== undefined && equationStrings.length > 0) {
             this.parse(...equationStrings);
@@ -96,9 +96,7 @@ export class LinearSystem {
             equArray.push(equStr.join('&'));
         }
 
-
         return `\\left\\{\\begin{array}{${"r".repeat(letters.length)}cl}${equArray.join('\\\\\ ')}\\end{array}\\right.`;
-        //return `\\left\\{\\begin{array}{rrrcl}${this._equations.map(equ => `${equ.tex}`).join('\\\\\ \n')}\\end{array}\\right.`;
     }
 
     get solution(): string {
@@ -118,9 +116,9 @@ export class LinearSystem {
                 return;
             }
 
-            tex.push(this._solutions[letter].value.frac);
+            tex.push(this._solutions[letter].value.tex);
         }
-        return `(${tex.join(';')})`;
+        return `\\left(${tex.join(';')}\\right)`;
     }
 
     // ------------------------------------------
@@ -227,6 +225,7 @@ export class LinearSystem {
         let c1 = eq1.left.monomByDegree(1, letter).coefficient.clone(),
             c2 = eq2.left.monomByDegree(1, letter).coefficient.clone().opposed();
 
+        console.log('reduction: ', letter, eq1.tex, eq2.tex, c2.tex, c1.tex)
         return this.mergeEquations(eq1, eq2, c2, c1);
     }
 
@@ -236,10 +235,16 @@ export class LinearSystem {
         let eq1multiplied = eq1.clone().multiply(new Fraction(factor1)),
             eq2multiplied = eq2.clone().multiply(new Fraction(factor2));
 
+        // @ts-ignore
+        console.log(eq1.tex, eq1multiplied.tex, factor1.tex)
+        // @ts-ignore
+        console.log(eq2.tex, eq2multiplied.tex, factor2.tex)
+
         // Add both equations together.
         eq1multiplied.left.add(eq2multiplied.left);
         eq1multiplied.right.add(eq2multiplied.right);
 
+        console.log('resulting reduction', eq1multiplied.tex)
         return eq1multiplied;
     }
 
@@ -266,6 +271,7 @@ export class LinearSystem {
         let V = this.variables.sort();
 
         for (let letter of V) {
+            console.log('SOLVING FOR', letter)
             this._solutions[letter] = this._solveOneLetter(letter, V)
         }
 
@@ -278,6 +284,12 @@ export class LinearSystem {
         return true;
     };
 
+    /**
+     * Linear reduction of the equations to have only one letter
+     * @param letter    letter to isolate
+     * @param V         list of variables in the linear system.
+     * @private
+     */
     private _solveOneLetter(letter: string, V: string[]): { value: Fraction, isReal: boolean, isVarnothing: boolean } {
         // list of equations.
         let LE: Equation[] = this.clone().equations,
@@ -291,12 +303,15 @@ export class LinearSystem {
                 continue;
             }
 
+            console.log('Removing the variable:  ', L)
             // Linear reduction.
             // TODO: Search for better association
             for (let i = 0; i < LE.length - 1; i++) {
                 reducedEquations.push(this._linearReduction(LE[i], LE[i + 1], L));
             }
 
+            console.log(reducedEquations.map(x=>x.tex))
+
             // Keep track of each steps.
             this._resolutionSteps.push(new LinearSystem().parse(...reducedEquations));
 
@@ -309,8 +324,8 @@ export class LinearSystem {
 
         // Solve the equations
         let E = this._resolutionSteps[this._resolutionSteps.length - 1].equations[0];
-        E.solve();
-
+        E.solve()
+        console.log('Solutions for ', letter, ': ', E.solutions[0].tex)
         return {
             value: new Fraction(E.solutions[0].value),
             isReal: E.isReal,

package/src/maths/algebra/monom.ts

@@ -525,7 +525,7 @@ export class Monom {
                 }
                 this._coefficient.add(m.coefficient);
             } else {
-                console.log('Add: Is not similar: ', m.display);
+                console.log('Add monom: ' + this.display + ' is not similar with ', m.display);
             }
         }
         return this;

package/src/maths/algebra/polynom.ts

@@ -401,6 +401,7 @@ export class Polynom {
     add = (...values: unknown[]): Polynom => {
         this.mark_as_dirty()
 
+        // @ts-ignore
         for (let value of values) {
             if (value instanceof Polynom) {
                 this._monoms = this._monoms.concat(value.monoms);
@@ -473,7 +474,6 @@ export class Polynom {
                 quotient: this.clone().divide(P),
                 reminder: new Polynom().zero()
             }
-
         }
 
         // Get at least a letter
@@ -634,7 +634,7 @@ export class Polynom {
 
         for (let x of polynomStringNormalized.matchAll(/\(([a-z0-9+\-]+)\)(\^[0-9]*)?/g)) {
             if (x[2] !== undefined) {
-                for (let i = 0; i < +x[2].substr(1); i++) {
+                for (let i = 0; i < +x[2].substring(1); i++) {
                     factors.push(x[1])
                 }
             } else {
@@ -650,9 +650,19 @@ export class Polynom {
         // Factorize the current polynom.
         this.factorize();
 
+        // console.log('RESULT BEFORE COMPARE')
+        // console.log(polynomString, polynomStringNormalized)
+        // console.log(factors)
+        // console.log(this.factors.map(x=>x.display))
+
         // Compare the given factors with the generated factors
         let sign = 1;
         for (let f of this.factors) {
+            if(f.degree().isZero()){
+                if(f.monoms[0].coefficient.isNegativeOne()){
+                    sign=-sign
+                }
+            }
             for (let i = 0; i < polyFactors.length; i++) {
                 if (f.isEqual(polyFactors[i])) {
                     polyFactors.splice(i, 1);
@@ -724,13 +734,38 @@ export class Polynom {
 
     // -------------------------------------
     reduce = (): Polynom => {
-        for (let i = 0; i < this._monoms.length; i++) {
-            for (let j = i + 1; j < this._monoms.length; j++) {
-                if (this._monoms[i].isSameAs(this.monoms[j])) {
-                    this._monoms[i].add(this.monoms[j]);
-                    this._monoms.splice(j, 1);
+        // Reduce the polynom
+        let values = [...this._monoms],
+            vars = [...this.variables]
+
+        this._monoms = []
+
+        let coeffs = values.filter(x=>x.variables.length===0)
+
+        if(coeffs.length>0){
+            this._monoms.push(coeffs.reduce((a, b)=>a.add(b)))
+        }
+
+        // Build the new monoms
+        for(let letter of vars){
+            // Monom with same letters, but might be of different degrees
+            let M = values.filter(x=>x.hasLetter(letter))
+
+            while(M.length>0){
+                // Take the first element
+                const m = M.shift(), degree=m.degree(letter)
+
+                for(let a of M.filter(x=>x.degree(letter).isEqual(degree))){
+                    m.add(a)
                 }
+
+                this._monoms.push(m)
+
+                // Make the new array.
+                M = M.filter(x=>x.degree(letter).isNotEqual(degree))
             }
+            // reduce the monom
+
         }
 
         // Remove all null monoms
@@ -746,7 +781,7 @@ export class Polynom {
         if (this.length === 0) {
             return new Polynom().zero();
         }
-        return this;
+        return this.reorder();
     };
 
     reorder = (letter: string = 'x'): Polynom => {
@@ -754,7 +789,7 @@ export class Polynom {
         this._monoms.sort(function (a, b) {
             return b.degree(letter).clone().subtract(a.degree(letter)).value
         });
-        return this.reduce();
+        return this;
     };
 
     degree = (letter?: string): Fraction => {
@@ -871,7 +906,6 @@ export class Polynom {
             return this._factors
         }
 
-
         let factors: Polynom[] = [];
         let P = this.clone().reorder()
 
@@ -879,7 +913,7 @@ export class Polynom {
         // 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()){
+        if(P.monomByDegree().coefficient.isStrictlyNegative() && M.coefficient.isStrictlyPositive() && !M.isOne()){
             M.opposed()
         }
 
@@ -1264,7 +1298,7 @@ export class Polynom {
             this.add(stack[0])
         }
 
-        return this
+        return this.reorder()
     }
 
     private multiplyByPolynom = (P: Polynom): Polynom => {

package/tests/algebra/linear.test.ts

@@ -0,0 +1,54 @@
+import {describe} from "mocha";
+import {expect} from "chai";
+import {Equation} from "../../src/maths/algebra/equation";
+import {PiMath} from "../../src";
+import exp = require("constants");
+import {LinearSystem} from "../../src/maths/algebra/linearSystem";
+import {Polynom} from "../../src/maths/algebra/polynom";
+
+describe('Linear systems tests', () => {
+    it('should solve a 2x2 equations', () => {
+        let LS = new LinearSystem(
+            '4x+5y=11',
+            '7y-24=3x'
+        )
+        LS.solve()
+        expect(LS.solution).to.be.equal('(-1;3)')
+    })
+    it('should solve a 3x3 equations', () => {
+        let LS = new LinearSystem(
+            '2x+7y-z=-3',
+            '-3x+2y+3z=12',
+            '-5x-3y+2z=5'
+        )
+
+        LS.solve()
+        console.log(LS.solution)
+    })
+
+    it('should solve a 3x3 equations II ', () => {
+        let LS = new LinearSystem(
+            '-x+y-z=-6',
+            '3x+2y+z=14',
+            '5x+y+3z=7'
+        )
+
+        LS.solve()
+        console.log(LS.solution)
+    })
+
+    it('should calculate the reduction', function () {
+        let E1 = new Polynom('6x+21y-3z'),
+            E2 = new Polynom('-6x+21y-3z')
+
+        // Start from hre
+        console.log('------------')
+        console.log(E1.tex, E2.tex)
+
+        console.log(E1.monoms.map(x=>x.tex))
+        console.log(E2.monoms.map(x=>x.tex))
+        E1.add(E2);
+
+        console.log(E1.tex)
+    });
+})

package/tests/algebra/polynom.test.ts

@@ -9,7 +9,7 @@ import exp = require("constants");
 describe('Polynom tests', () => {
     it('Parse polynom', () => {
         const options = new Polynom('2x(x+3)^2(x-1)');
-        options.reorder().reduce();
+        options.reorder();
         expect(options.tex).to.be.equal('2x^{4}+10x^{3}+6x^{2}-18x');
     });
 
@@ -102,14 +102,20 @@ describe('Polynom tests', () => {
 
     it('should detect if a polynom is factorized', function (){
         let P = new Polynom('x-1')
-
         expect(P.isFactorized('x-1')).to.be.true
         expect(P.isFactorized('x-2')).to.be.false
 
-        let Q = new Polynom('(x-1)(x+2)')
+        let R = new Polynom('(x+2)^2')
+        expect(R.isFactorized('(x+2)^2')).to.be.true
 
+        let Q = new Polynom('(x-1)(x+2)')
         expect(Q.isFactorized('(x+2)(x-1)')).to.be.true
         expect(Q.isFactorized('x^2+x-2')).to.be.false
+
+        let T = new Polynom('(x-3)(1-x)')
+        expect(T.isFactorized('(x-1)(3-x)')).to.be.true
+        expect(T.isFactorized('(x-1)(x-3)')).to.be.false
+        expect(T.isFactorized('-1(x-1)(x-3)')).to.be.false
     })
 })