math-exercises 3.0.201 → 3.0.203

package/lib/tree/nodes/student/iDontKnowNode.js

@@ -0,0 +1,63 @@
+import { NodeIds, NodeType } from "../node.js";
+export function isIDontKnowNode(a) {
+    return a.type === NodeType.iDontKnow;
+}
+export class IDontKnowNode {
+    tex;
+    type;
+    isNumeric;
+    constructor(tex) {
+        this.tex = tex;
+        this.isNumeric = false;
+        this.type = NodeType.iDontKnow;
+    }
+    static keyword() {
+        return "N.S.P";
+    }
+    toMathString() {
+        throw new Error("can't create mathString from IDontKnowNode");
+    }
+    toTex() {
+        return `${this.tex}`;
+    }
+    // toMathjs() {
+    //   return parse(this.mathString);
+    // }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    toIdentifiers() {
+        return {
+            id: NodeIds.constant,
+            tex: this.tex,
+        };
+    }
+    toEquivalentNodes() {
+        return [this];
+    }
+    evaluate() {
+        return NaN;
+    }
+    simplify(_opts) {
+        return this;
+    }
+    toSimplificationTex(opts) {
+        const simp = this.simplify(opts);
+        if (simp.toTex() !== this.toTex())
+            return this.toTex() + "=" + simp.toTex();
+        return this.toTex();
+    }
+    equals(node) {
+        return isIDontKnowNode(node) && node.tex === this.tex;
+    }
+    toDetailedEvaluation(vars) {
+        //?utile pour des trucs genre 3Pi+4 --> 3*3.14+4
+        return vars[this.tex] ?? this;
+    }
+    derivative() {
+        return this;
+    }
+    toSignInequationTex() {
+        return "";
+    }
+}

package/lib/tree/parsers/latexParser.d.ts

@@ -1,11 +1,12 @@
 import { AlgebraicNode } from "../nodes/algebraicNode.js";
 import { EqualNode } from "../nodes/equations/equalNode.js";
 import { InequationNode } from "../nodes/inequations/inequationNode.js";
+import { IDontKnowNode } from "../nodes/student/iDontKnowNode.js";
 export declare const tokenize: (latex: string) => string[];
 type ParserOptions = {
     allowStartingPower?: boolean;
 };
-export declare const parseAlgebraic: (latex: string, opts?: ParserOptions) => AlgebraicNode;
-export declare const parseLatex: (latex: string) => AlgebraicNode | EqualNode | InequationNode;
+export declare const parseAlgebraic: (latex: string, opts?: ParserOptions) => AlgebraicNode | IDontKnowNode;
+export declare const parseLatex: (latex: string) => AlgebraicNode | EqualNode | InequationNode | IDontKnowNode;
 export {};
 //# sourceMappingURL=latexParser.d.ts.map

package/lib/tree/parsers/latexParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAQ5D,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AA0ExE,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,aAwDrC,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AACF,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,EAAE,OAAO,aAAa,kBAuBjE,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,+CAyCvC,CAAC"}
+{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAQ5D,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAgBxE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AA2DlE,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,aAwDrC,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AACF,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,EAAE,OAAO,aAAa,kCA4BjE,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,+DA6CvC,CAAC"}

package/lib/tree/parsers/latexParser.js

@@ -16,6 +16,7 @@ import { FractionNode } from "../nodes/operators/fractionNode.js";
 import { MultiplyNode, isMultiplyNode, } from "../nodes/operators/multiplyNode.js";
 import { PowerNode } from "../nodes/operators/powerNode.js";
 import { SubstractNode } from "../nodes/operators/substractNode.js";
+import { IDontKnowNode } from "../nodes/student/iDontKnowNode.js";
 import { VariableNode } from "../nodes/variables/variableNode.js";
 //cmds that needs a child, like \exp{3}
 const functions = [
@@ -125,6 +126,9 @@ export const tokenize = (latex) => {
 };
 export const parseAlgebraic = (latex, opts) => {
     // console.log("parsingAlg ", latex);
+    if (latex.includes(IDontKnowNode.keyword())) {
+        return new IDontKnowNode(latex);
+    }
     let formatedLatex = latex;
     if (!opts?.allowStartingPower && latex.startsWith("^")) {
         if (latex[1] === "{") {
@@ -151,6 +155,9 @@ export const parseAlgebraic = (latex, opts) => {
 };
 export const parseLatex = (latex) => {
     // console.log("parsingLatex ", latex);
+    if (latex.includes(IDontKnowNode.keyword())) {
+        return new IDontKnowNode(latex);
+    }
     const formattedLatex = latex
         .replaceAll("\\left", "")
         .replaceAll("\\right", "");

package/lib/tree/parsers/monomParser.d.ts

@@ -3,6 +3,6 @@ type Opts = {
     maxDegree?: number;
     minDegree?: number;
 };
-export declare const monomParser: (str: string, { variable, maxDegree, minDegree }?: Opts) => false | import("../nodes/algebraicNode.js").AlgebraicNode;
+export declare const monomParser: (str: string, { variable, maxDegree, minDegree }?: Opts) => false | import("../nodes/algebraicNode.js").AlgebraicNode | import("../nodes/student/iDontKnowNode.js").IDontKnowNode;
 export {};
 //# sourceMappingURL=monomParser.d.ts.map

package/lib/tree/parsers/monomParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"monomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/monomParser.ts"],"names":[],"mappings":"AAIA,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AACF,eAAO,MAAM,WAAW,GACtB,KAAK,MAAM,EACX,qCAAoC,IAInC,8DAaF,CAAC"}
+{"version":3,"file":"monomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/monomParser.ts"],"names":[],"mappings":"AAIA,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AACF,eAAO,MAAM,WAAW,GACtB,KAAK,MAAM,EACX,qCAAoC,IAInC,0HAaF,CAAC"}

package/lib/tree/parsers/polynomialParser.d.ts

@@ -2,6 +2,6 @@ import { AlgebraicNode } from "../nodes/algebraicNode.js";
 type Opts = {
     variable?: string;
 };
-export declare const polynomialParser: (ans: string, opts?: Opts) => false | AlgebraicNode | import("../nodes/numbers/constantNode.js").ConstantNode | import("../nodes/numbers/numberNode.js").NumberNode | import("../nodes/operators/substractNode.js").SubstractNode | import("../nodes/operators/addNode.js").AddNode;
+export declare const polynomialParser: (ans: string, opts?: Opts) => false | AlgebraicNode | import("../nodes/numbers/constantNode.js").ConstantNode | import("../nodes/numbers/numberNode.js").NumberNode | import("../nodes/operators/substractNode.js").SubstractNode | import("../nodes/operators/addNode.js").AddNode | import("../nodes/student/iDontKnowNode.js").IDontKnowNode;
 export {};
 //# sourceMappingURL=polynomialParser.d.ts.map

package/lib/tree/parsers/polynomialParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomialParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/polynomialParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAS1D,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAIF,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,EAAE,OAAO,IAAI,0PAkCxD,CAAC"}
+{"version":3,"file":"polynomialParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/polynomialParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAS1D,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAIF,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,EAAE,OAAO,IAAI,sTAkCxD,CAAC"}

package/lib/tree/parsers/trinomParser.d.ts

@@ -1,2 +1,2 @@
-export declare const trinomParser: (ans: string, variable?: string) => false | import("../nodes/algebraicNode.js").AlgebraicNode | undefined;
+export declare const trinomParser: (ans: string, variable?: string) => false | import("../nodes/algebraicNode.js").AlgebraicNode | import("../nodes/student/iDontKnowNode.js").IDontKnowNode | undefined;
 //# sourceMappingURL=trinomParser.d.ts.map

package/lib/tree/parsers/trinomParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trinomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/trinomParser.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,EAAE,WAAU,MAAY,0EAgC/D,CAAC"}
+{"version":3,"file":"trinomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/trinomParser.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,EAAE,WAAU,MAAY,sIAgC/D,CAAC"}

package/lib/tree/utilities/nodeComparator.d.ts

@@ -1,11 +1,13 @@
 import { Tuple } from "../../math/sets/tuple.js";
 import { AlgebraicNode } from "../nodes/algebraicNode.js";
 import { DiscreteSetNode } from "../nodes/sets/discreteSetNode.js";
+import { VariableNode } from "../nodes/variables/variableNode.js";
 export declare abstract class NodeComparator {
     static compareViaSub: <T extends AlgebraicNode>(node1: T, node2: T) => -1 | 0 | 1;
     static isEqualViaSub: (node1: AlgebraicNode, node2: AlgebraicNode) => boolean;
     static isEqualViaFrac: (node1: AlgebraicNode, node2: AlgebraicNode) => boolean;
-    static isEqualViaRandomEvaluations(node1: AlgebraicNode, node2: AlgebraicNode, nbRandomEvaluations: number): boolean;
+    static isEqualViaRandomEvaluations(node1: AlgebraicNode, node2: AlgebraicNode, nbRandomEvaluations: number, precision?: number, nodeVar?: VariableNode, randFunc?: () => number): boolean;
+    static isEqualViaRandomSubstitutions(node1: AlgebraicNode, node2: AlgebraicNode, nbRandomEvaluations: number, nodeVar?: VariableNode): boolean;
     static isNodeInDiscreteSet: (node: AlgebraicNode, nodeDiscreteSet: DiscreteSetNode) => boolean;
     static isTupleInCartesianProductOfDiscreteSets: (tuple: Tuple, arrDiscreteSet: DiscreteSetNode[]) => boolean;
     static isEqualTuple: (tuple1: Tuple, tuple2: Tuple) => boolean;

package/lib/tree/utilities/nodeComparator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeComparator.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeComparator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAGjD,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAI1D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAInE,8BAAsB,cAAc;IAGlC,MAAM,CAAC,aAAa,GAAI,CAAC,SAAS,aAAa,EAC7C,OAAO,CAAC,EACR,OAAO,CAAC,KACP,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CA4DX;IAEF,MAAM,CAAC,aAAa,GAClB,OAAO,aAAa,EACpB,OAAO,aAAa,KACnB,OAAO,CAER;IAIF,MAAM,CAAC,cAAc,GACnB,OAAO,aAAa,EACpB,OAAO,aAAa,KACnB,OAAO,CAgBR;IAIF,MAAM,CAAC,2BAA2B,CAChC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,aAAa,EACpB,mBAAmB,EAAE,MAAM;IA+D7B,MAAM,CAAC,mBAAmB,GACxB,MAAM,aAAa,EACnB,iBAAiB,eAAe,aAI9B;IAEJ,MAAM,CAAC,uCAAuC,GAC5C,OAAO,KAAK,EACZ,gBAAgB,eAAe,EAAE,aAQjC;IAIF,MAAM,CAAC,YAAY,GAAI,QAAQ,KAAK,EAAE,QAAQ,KAAK,aAIjD;IAEF,MAAM,CAAC,iBAAiB,GAAI,OAAO,KAAK,EAAE,UAAU,KAAK,EAAE,aAMzD;CACH"}
+{"version":3,"file":"nodeComparator.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeComparator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAIjD,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAI1D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAMlE,8BAAsB,cAAc;IAGlC,MAAM,CAAC,aAAa,GAAI,CAAC,SAAS,aAAa,EAC7C,OAAO,CAAC,EACR,OAAO,CAAC,KACP,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CA4DX;IAEF,MAAM,CAAC,aAAa,GAClB,OAAO,aAAa,EACpB,OAAO,aAAa,KACnB,OAAO,CAMR;IAIF,MAAM,CAAC,cAAc,GACnB,OAAO,aAAa,EACpB,OAAO,aAAa,KACnB,OAAO,CAoBR;IASF,MAAM,CAAC,2BAA2B,CAChC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,aAAa,EACpB,mBAAmB,EAAE,MAAM,EAC3B,SAAS,GAAE,MAAU,EACrB,OAAO,GAAE,YAAoC,EAC7C,QAAQ,GAAE,MAAM,MAAqC;IA2EvD,MAAM,CAAC,6BAA6B,CAClC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,aAAa,EACpB,mBAAmB,EAAE,MAAM,EAC3B,OAAO,GAAE,YAAoC;IAmE/C,MAAM,CAAC,mBAAmB,GACxB,MAAM,aAAa,EACnB,iBAAiB,eAAe,aAI9B;IAEJ,MAAM,CAAC,uCAAuC,GAC5C,OAAO,KAAK,EACZ,gBAAgB,eAAe,EAAE,aAQjC;IAIF,MAAM,CAAC,YAAY,GAAI,QAAQ,KAAK,EAAE,QAAQ,KAAK,aAIjD;IAEF,MAAM,CAAC,iBAAiB,GAAI,OAAO,KAAK,EAAE,UAAU,KAAK,EAAE,aAMzD;CACH"}

package/lib/tree/utilities/nodeComparator.js

@@ -1,10 +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) => {
@@ -70,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) => {
@@ -89,27 +99,37 @@ export class NodeComparator {
         });
     };
     //via random evaluations
-    static isEqualViaRandomEvaluations(node1, node2, nbRandomEvaluations) {
-        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()));
@@ -125,9 +145,49 @@ export class NodeComparator {
             return dict;
         };
         return Object.values(getSafeEvaluationDictForEqualityCheck(node1, node2, nbRandomEvaluations)).every((arrSafeEval) => {
-            return arrSafeEval
-                .slice(1)
-                .every((safeEval) => substract(arrSafeEval[0].value, safeEval.value).evaluate() === 0);
+            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.

package/lib/tree/utilities/nodeSimplifier.d.ts

@@ -11,5 +11,6 @@ export declare abstract class NodeSimplifier {
         isMultiTopLevel: boolean;
     }, toTexOpts?: ToTexOptions) => string[];
     static simplifyByVibrating(algebraicNode: AlgebraicNode, nbVibrations?: number, isTowardsDistribute?: boolean): AlgebraicNode;
+    static simplifyByInfiltrating(algebraicNode: AlgebraicNode, simplifyOpts: SimplifyOptions): AlgebraicNode;
 }
 //# sourceMappingURL=nodeSimplifier.d.ts.map

package/lib/tree/utilities/nodeSimplifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeSimplifier.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeSimplifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAiB3E,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAKhD,8BAAsB,cAAc;IAClC,MAAM,CAAC,QAAQ,GAAI,CAAC,SAAS,aAAa,EACxC,eAAe,CAAC,EAChB,cAAc,eAAe,EAC7B,eAAc,YAIb,KACA,MAAM,CAsBP;IAEF,MAAM,CAAC,iBAAiB,GAAI,eAAe,aAAa,sCAmCtD;IAEF,MAAM,CAAC,8BAA8B,GAAI,OAAO,aAAa,EAAE,qBAK7D;IAEF,MAAM,CAAC,eAAe,GAAI,CAAC,SAAS,aAAa,EAC/C,eAAe,CAAC,EAChB,cAAc,eAAe,EAC7B,iBAAgB;QACd,eAAe,EAAE,OAAO,CAAC;KAG1B,EACD,YAAW,YAIV,KACA,aAAa,EAAE,CA4JhB;IAEF,MAAM,CAAC,gBAAgB,GACrB,MAAM,aAAa,EACnB,eAAc,eAAoB,EAClC,iBAAgB;QACd,eAAe,EAAE,OAAO,CAAC;KAG1B,EACD,YAAW,YAIV,cAQD;IAEF,MAAM,CAAC,mBAAmB,CACxB,aAAa,EAAE,aAAa,EAC5B,YAAY,GAAE,MAAU,EACxB,mBAAmB,GAAE,OAAc,GAClC,aAAa;CAcjB"}
+{"version":3,"file":"nodeSimplifier.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeSimplifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAiB3E,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAKhD,8BAAsB,cAAc;IAClC,MAAM,CAAC,QAAQ,GAAI,CAAC,SAAS,aAAa,EACxC,eAAe,CAAC,EAChB,cAAc,eAAe,EAC7B,eAAc,YAIb,KACA,MAAM,CAsBP;IAEF,MAAM,CAAC,iBAAiB,GAAI,eAAe,aAAa,sCAmCtD;IAEF,MAAM,CAAC,8BAA8B,GAAI,OAAO,aAAa,EAAE,qBAK7D;IAEF,MAAM,CAAC,eAAe,GAAI,CAAC,SAAS,aAAa,EAC/C,eAAe,CAAC,EAChB,cAAc,eAAe,EAC7B,iBAAgB;QACd,eAAe,EAAE,OAAO,CAAC;KAG1B,EACD,YAAW,YAIV,KACA,aAAa,EAAE,CA4JhB;IAEF,MAAM,CAAC,gBAAgB,GACrB,MAAM,aAAa,EACnB,eAAc,eAAoB,EAClC,iBAAgB;QACd,eAAe,EAAE,OAAO,CAAC;KAG1B,EACD,YAAW,YAIV,cAQD;IAEF,MAAM,CAAC,mBAAmB,CACxB,aAAa,EAAE,aAAa,EAC5B,YAAY,GAAE,MAAU,EACxB,mBAAmB,GAAE,OAAc,GAClC,aAAa;IAehB,MAAM,CAAC,sBAAsB,CAC3B,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,eAAe,GAC5B,aAAa;CAyDjB"}

package/lib/tree/utilities/nodeSimplifier.js

@@ -209,4 +209,44 @@ export class NodeSimplifier {
             return this.simplifyByVibrating(nodeSimplified, nbVibrations - 1, !isTowardsDistribute);
         }
     }
+    static simplifyByInfiltrating(algebraicNode, simplifyOpts) {
+        const outNode = (() => {
+            if (isOperatorNode(algebraicNode)) {
+                const [nodeLeft, nodeRight] = [
+                    algebraicNode.leftChild,
+                    algebraicNode.rightChild,
+                ];
+                const isCanDiveDeeper = [nodeLeft, nodeRight].every((nodeChild) => isOperatorNode(nodeChild) || isFunctionNode(nodeChild));
+                if (isCanDiveDeeper) {
+                    const [nodeLeftSimplified, nodeRightSimplified] = [
+                        nodeLeft,
+                        nodeRight,
+                    ].map((nodeChild) => this.simplifyByInfiltrating(nodeChild, simplifyOpts));
+                    const funcMother = NodeRewriter.getArrCreateNodeFromChildrenFunction(algebraicNode).find(() => true);
+                    return funcMother([nodeLeftSimplified, nodeRightSimplified]).simplify(simplifyOpts);
+                }
+                else {
+                    return algebraicNode.simplify(simplifyOpts);
+                }
+            }
+            else if (isFunctionNode(algebraicNode)) {
+                const nodeChild = algebraicNode.child;
+                const isCanDiveDeeper = [nodeChild].every((nodeChild) => isOperatorNode(nodeChild) || isFunctionNode(nodeChild));
+                if (isCanDiveDeeper) {
+                    const [nodeChildSimplified] = [nodeChild].map((nodeChild) => this.simplifyByInfiltrating(nodeChild, simplifyOpts));
+                    const funcMother = NodeRewriter.getArrCreateNodeFromChildrenFunction(algebraicNode).find(() => true);
+                    return funcMother([nodeChildSimplified]).simplify(simplifyOpts);
+                }
+                else {
+                    return algebraicNode.simplify(simplifyOpts);
+                }
+            }
+            else {
+                return algebraicNode.simplify(simplifyOpts);
+            }
+        })();
+        // console.log("simplifyByInfiltrating", "nodeIn:", algebraicNode.toTex());
+        // console.log("simplifyByInfiltrating", "nodeOut:", outNode.toTex());
+        return outNode;
+    }
 }

package/package.json

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