do not compare math-series as equations

Author: CarlaCostea

src/fixtures/latex-equal/symbolic/math-series.ts

@@ -9,7 +9,7 @@ export default {
     {
       target: "a_{i}=1/2i[2s+(i-1)d]",
       eq: ["a_{i}=0.5i(2s+di-d)"],
-     // ne: ["a_{i-1}=0.5i(2s+di-d)"],
+      ne: ["a_{i-1}=0.5i(2s+di-d)", "0.5i(2s+di-d)=a_{i-1}", "0.5i(2s+di-d)=a"],
     },
     {
       target: "a_{n}=(-1/(2i))^n",

src/symbolic/compare-equations.ts

@@ -13,10 +13,7 @@ import {
 
 const m: any = mathjs;
 
-const compareCoefficients = (
-  firstEqCoeff: number[],
-  secondEqCoeff: number[]
-) =>
+const compareCoefficients = (firstEqCoeff: number[], secondEqCoeff: number[]) =>
   Array.isArray(firstEqCoeff) &&
   Array.isArray(secondEqCoeff) &&
   firstEqCoeff.length === secondEqCoeff.length &&
@@ -62,12 +59,12 @@ export const compareEquations = (
         isInequality
       );
 
-
       // if coefficients are equal, there is no need for further calculations => equations are equivalent
-      if (compareCoefficients(
-        firstEquationCoefficients,
-        secondEquationCoefficients
-      )
+      if (
+        compareCoefficients(
+          firstEquationCoefficients,
+          secondEquationCoefficients
+        )
       ) {
         return true;
       }
@@ -112,9 +109,9 @@ export const compareEquations = (
           rootsFirstEquation[0].re === rootsSecondEquation[0].re &&
           rootsFirstEquation[1].re === rootsSecondEquation[1].re &&
           rootsFirstEquation[0].im.toFixed(13) ===
-          rootsSecondEquation[0].im.toFixed(13) &&
+            rootsSecondEquation[0].im.toFixed(13) &&
           rootsFirstEquation[1].im.toFixed(13) ===
-          rootsSecondEquation[1].im.toFixed(13)
+            rootsSecondEquation[1].im.toFixed(13)
         );
       }
 

src/symbolic/utils.ts

@@ -16,19 +16,23 @@ let simplifyRules = [
 const customRound = (number: number) =>
   Math.round(number * 10000000000000) / 10000000000000;
 
-// expressions can be compared if we have at least one symbol node and has no function node or array
+// expressions can be compared if we have at least one symbol node and has no function node or array; do not treat math series as equations
 export const expressionsCanBeCompared = (
   firstEquation: MathNode,
   secondEquation: MathNode
 ): boolean => {
   let noFunctionOrArray: boolean = true;
   let firstSymbolNode: boolean = false;
   let symbolNode: boolean = false;
+  let seriesNode: boolean = false;
 
   firstEquation.traverse(function (node, path, parent) {
+    if (node.isSymbolNode) {
+      firstSymbolNode = true
+      seriesNode = seriesNode || node.name.includes("[")
+    }
     noFunctionOrArray =
       noFunctionOrArray || node.isFunctionNode || node.isArrayNode;
-    firstSymbolNode = firstSymbolNode || node.isSymbolNode;
   });
 
   secondEquation.traverse(function (node, path, parent) {
@@ -39,7 +43,7 @@ export const expressionsCanBeCompared = (
     if (node.isSymbolNode && firstSymbolNode) symbolNode = true;
   });
 
-  return noFunctionOrArray && symbolNode;
+  return noFunctionOrArray && symbolNode && !seriesNode;
 };
 
 // move the terms of the equations to the left hand side