pimath 0.0.100 → 0.0.102

package/dist/pi.js

@@ -941,9 +941,14 @@ class LinearSystem {
         this.mergeEquations = (eq1, eq2, factor1, factor2) => {
             // Set and clone the equations.
             let eq1multiplied = eq1.clone().multiply(new fraction_1.Fraction(factor1)), eq2multiplied = eq2.clone().multiply(new fraction_1.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;
         };
         // ------------------------------------------
@@ -964,6 +969,7 @@ class LinearSystem {
             // Get all variables in the linear system
             let V = this.variables.sort();
             for (let letter of V) {
+                console.log('SOLVING FOR', letter);
                 this._solutions[letter] = this._solveOneLetter(letter, V);
             }
             // TODO: LinearSystem - solve: optimization and handle undetermined and undefined systems.
@@ -983,7 +989,7 @@ class LinearSystem {
             return str;
         };
         this._equations = [];
-        this._letters = 'xy'.split('');
+        this._letters = 'xyz'.split('');
         if (equationStrings !== undefined && equationStrings.length > 0) {
             this.parse(...equationStrings);
         }
@@ -1046,7 +1052,6 @@ 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() {
         let tex = [];
@@ -1062,9 +1067,9 @@ class LinearSystem {
                 console.log(`Undefined (letter ${letter})`);
                 return;
             }
-            tex.push(this._solutions[letter].value.frac);
+            tex.push(this._solutions[letter].value.tex);
         }
-        return `(${tex.join(';')})`;
+        return `\\left(${tex.join(';')}\\right)`;
     }
     // ------------------------------------------
     // Mathematical operations
@@ -1073,8 +1078,15 @@ class LinearSystem {
         // TODO: handle other signs for equations ?
         // Get the monom for the particular letter.
         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);
     }
+    /**
+     * 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
+     */
     _solveOneLetter(letter, V) {
         // list of equations.
         let LE = this.clone().equations, reducedEquations = [];
@@ -1085,11 +1097,13 @@ class LinearSystem {
             if (L === letter) {
                 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));
             // Set the list of equations to the new version.
@@ -1100,6 +1114,7 @@ class LinearSystem {
         // Solve the equations
         let E = this._resolutionSteps[this._resolutionSteps.length - 1].equations[0];
         E.solve();
+        console.log('Solutions for ', letter, ': ', E.solutions[0].tex);
         return {
             value: new fraction_1.Fraction(E.solutions[0].value),
             isReal: E.isReal,
@@ -1477,7 +1492,7 @@ 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;
@@ -2378,6 +2393,7 @@ class Polynom {
         // Mathematical operations
         this.add = (...values) => {
             this.mark_as_dirty();
+            // @ts-ignore
             for (let value of values) {
                 if (value instanceof Polynom) {
                     this._monoms = this._monoms.concat(value.monoms);
@@ -2573,7 +2589,7 @@ class Polynom {
             let polynomStringNormalized = polynomString.replaceAll('*', ''), polynomStringReduced = '' + polynomStringNormalized, factors = [];
             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]);
                     }
                 }
@@ -2588,9 +2604,18 @@ class Polynom {
             let polyFactors = factors.map(x => new Polynom(x));
             // 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);
@@ -2654,13 +2679,28 @@ class Polynom {
         };
         // -------------------------------------
         this.reduce = () => {
-            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
             this._monoms = this._monoms.filter((m) => {
@@ -2673,14 +2713,14 @@ class Polynom {
             if (this.length === 0) {
                 return new Polynom().zero();
             }
-            return this;
+            return this.reorder();
         };
         this.reorder = (letter = 'x') => {
             // TODO: Must handle multiple setLetter reorder system
             this._monoms.sort(function (a, b) {
                 return b.degree(letter).clone().subtract(a.degree(letter)).value;
             });
-            return this.reduce();
+            return this;
         };
         this.degree = (letter) => {
             let d = new fraction_1.Fraction().zero();
@@ -2779,7 +2819,7 @@ 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();
             }
             if (!M.isOne()) {
@@ -3054,7 +3094,7 @@ class Polynom {
             if (stack.length === 1) {
                 this.add(stack[0]);
             }
-            return this;
+            return this.reorder();
         };
         this.multiplyByPolynom = (P) => {
             const M = [];