math-exercises 3.0.202 → 3.0.204

package/lib/tree/utilities/nodeComparator.js

@@ -1,11 +1,14 @@
+import { nodeBySubstitutingVar } from "../../math/utils/functions/functionComposition.js";
 import { randfloat } from "../../math/utils/random/randfloat.js";
 import { zip } from "../../utils/arrays/arrayZip.js";
 import { isInfiniteNode } from "../nodes/numbers/constantNode.js";
 import { frac } from "../nodes/operators/fractionNode.js";
 import { substract } from "../nodes/operators/substractNode.js";
+import { VariableNode } from "../nodes/variables/variableNode.js";
 import { NodeRewriter } from "./nodeRewriter.js";
 import { NodeSimplifier } from "./nodeSimplifier.js";
 import { round } from "../../math/utils/round.js";
+import { isIDontKnowNode } from "../nodes/student/iDontKnowNode.js";
 export class NodeComparator {
     //via sub
     static compareViaSub = (node1, node2) => {
@@ -71,10 +74,16 @@ export class NodeComparator {
         }
     };
     static isEqualViaSub = (node1, node2) => {
+        if (isIDontKnowNode(node1) || isIDontKnowNode(node2)) {
+            return false;
+        }
         return this.compareViaSub(node1, node2) === 0;
     };
     //via frac
     static isEqualViaFrac = (node1, node2) => {
+        if (isIDontKnowNode(node1) || isIDontKnowNode(node2)) {
+            return false;
+        }
         const [arrNode1, arrNode2] = [node1, node2].map((node) => NodeRewriter.getArrNodeEquivalent(node));
         return arrNode1.some((node1Equivalent) => {
             return arrNode2.some((node2Equivalent) => {
@@ -90,27 +99,37 @@ export class NodeComparator {
         });
     };
     //via random evaluations
-    static isEqualViaRandomEvaluations(node1, node2, nbRandomEvaluations, precision = 8) {
-        const getSafeEvaluationDictForEqualityCheck = (node1, node2, nbSafeX = 4) => {
+    /*
+      Spoiler alert: (-2)^1.96 = NaN
+      Be sure to always use positive integer exponents when dealing with negative numbers
+    */
+    static isEqualViaRandomEvaluations(node1, node2, nbRandomEvaluations, precision = 8, nodeVar = new VariableNode("x"), randFunc = () => randfloat(-20, 100, 3)) {
+        if (isIDontKnowNode(node1) || isIDontKnowNode(node2)) {
+            return false;
+        }
+        const getSafeEvaluationDictForEqualityCheck = (node1, node2, nbSafeX = nbRandomEvaluations) => {
             const dict = {};
             let counter = -1;
             while (Object.keys(dict).length < nbSafeX && counter < 1000) {
                 counter++;
-                const x = randfloat(-20, 100, 3);
+                const x = randFunc();
                 let value1;
                 let value2;
                 try {
-                    value1 = node1.evaluate({ x });
+                    value1 = node1.evaluate({ [nodeVar.name]: x });
                 }
                 catch (_) {
                     continue;
                 }
                 try {
-                    value2 = node2.evaluate({ x });
+                    value2 = node2.evaluate({ [nodeVar.name]: x });
                 }
                 catch (_) {
                     continue;
                 }
+                // console.log("x", x);
+                // console.log("value1", value1);
+                // console.log("value2", value2);
                 const [isValidValue1, isValidValue2] = [value1, value2].map((value) => value !== undefined &&
                     !isNaN(value) &&
                     !isInfiniteNode(value.toTree()));
@@ -128,10 +147,49 @@ export class NodeComparator {
         return Object.values(getSafeEvaluationDictForEqualityCheck(node1, node2, nbRandomEvaluations)).every((arrSafeEval) => {
             return arrSafeEval.slice(1).every((safeEval) => {
                 const valueSubRounded = round(substract(arrSafeEval[0].value, safeEval.value).evaluate(), precision);
+                // console.log("valueSubRounded", valueSubRounded);
                 return valueSubRounded === 0;
             });
         });
     }
+    //via random substitutions
+    static isEqualViaRandomSubstitutions(node1, node2, nbRandomEvaluations, nodeVar = new VariableNode("x")) {
+        if (isIDontKnowNode(node1) || isIDontKnowNode(node2)) {
+            return false;
+        }
+        const getSafeEvaluationDictForEqualityCheck = (node1, node2, nbSafeX = nbRandomEvaluations) => {
+            const dict = {};
+            let counter = -1;
+            while (Object.keys(dict).length < nbSafeX && counter < 1000) {
+                counter++;
+                const x = randfloat(-20, 100, 3);
+                const [nodeSubstituted1, nodeSubstituted2] = [node1, node2].map((node) => nodeBySubstitutingVar(node, x.toTree(), nodeVar));
+                const [isValidValue1, isValidValue2] = [
+                    nodeSubstituted1,
+                    nodeSubstituted2,
+                ].map((nodeSubstituted) => {
+                    const value = nodeSubstituted.evaluate();
+                    return value !== undefined && !isInfiniteNode(value.toTree());
+                });
+                const isValidEvaluation = isValidValue1 && isValidValue2;
+                if (isValidEvaluation) {
+                    dict[x] = [nodeSubstituted1, nodeSubstituted2].map((nodeSubstituted) => {
+                        return {
+                            x,
+                            nodeSubstituted,
+                        };
+                    });
+                }
+            }
+            return dict;
+        };
+        return Object.values(getSafeEvaluationDictForEqualityCheck(node1, node2, nbRandomEvaluations)).every((arrSafeEval) => {
+            return arrSafeEval.slice(1).every((safeEval) => {
+                const isEqualNodes = NodeComparator.isEqualViaSub(arrSafeEval[0].nodeSubstituted, safeEval.nodeSubstituted);
+                return isEqualNodes;
+            });
+        });
+    }
     //discreteSets, etc.
     static isNodeInDiscreteSet = (node, nodeDiscreteSet) => nodeDiscreteSet.elements.some((nodeInSet) => NodeComparator.isEqualViaSub(node, nodeInSet));
     static isTupleInCartesianProductOfDiscreteSets = (tuple, arrDiscreteSet) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.202",
+  "version": "3.0.204",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [