math-exercises 3.0.182 → 3.0.184

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

@@ -0,0 +1,9 @@
+import { AlgebraicNode } from "../nodes/algebraicNode.js";
+export declare abstract class NodeRewriter {
+    static rewriteTopLevel: <T extends AlgebraicNode>(algebraicNode: T, indexIn?: number, shuffleArrayIn?: number[]) => AlgebraicNode;
+    static getCreateNodeFromChildrenFunction: <T extends AlgebraicNode>(algebraicNode: T, indexIn?: number) => (children: AlgebraicNode[]) => AlgebraicNode;
+    static getArrCreateNodeFromChildrenFunction: (algebraicNode: AlgebraicNode) => ((children: AlgebraicNode[]) => AlgebraicNode)[];
+    static getArrRewriteTopLevel(algebraicNode: AlgebraicNode): AlgebraicNode[];
+    static getArrNodeEquivalent(algebraicNode: AlgebraicNode, isDistinctTex?: boolean): AlgebraicNode[];
+}
+//# sourceMappingURL=nodeRewriter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeRewriter.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeRewriter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAkC1D,8BAAsB,YAAY;IAChC,MAAM,CAAC,eAAe,GAAI,CAAC,SAAS,aAAa,EAC/C,eAAe,CAAC,EAChB,UAAU,MAAM,EAChB,iBAAiB,MAAM,EAAE,KACxB,aAAa,CAUd;IAEF,MAAM,CAAC,iCAAiC,GAAI,CAAC,SAAS,aAAa,EACjE,eAAe,CAAC,EAChB,UAAU,MAAM,gBAgBH,aAAa,EAAE,KAAK,aAAa,CAP9C;IAKF,MAAM,CAAC,oCAAoC,GACzC,eAAe,aAAa,KAC3B,CAAC,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,aAAa,CAAC,EAAE,CA2HjD;IAEF,MAAM,CAAC,qBAAqB,CAAC,aAAa,EAAE,aAAa,GAAG,aAAa,EAAE;IAW3E,MAAM,CAAC,oBAAoB,CACzB,aAAa,EAAE,aAAa,EAC5B,aAAa,GAAE,OAAc,GAC5B,aAAa,EAAE;CAwCnB"}

package/lib/tree/utilities/nodeRewriter.js

@@ -0,0 +1,172 @@
+import { abs } from "../nodes/functions/absNode.js";
+import { arccos } from "../nodes/functions/arccosNode.js";
+import { CosNode } from "../nodes/functions/cosNode.js";
+import { FunctionsIds, isFunctionNode, } from "../nodes/functions/functionNode.js";
+import { AddNode } from "../nodes/operators/addNode.js";
+import { BinomialCoefficientNode } from "../nodes/operators/binomialCoefficientNode.js";
+import { DivideNode } from "../nodes/operators/divideNode.js";
+import { frac } from "../nodes/operators/fractionNode.js";
+import { multiply } from "../nodes/operators/multiplyNode.js";
+import { power } from "../nodes/operators/powerNode.js";
+import { substract } from "../nodes/operators/substractNode.js";
+import { sin } from "../nodes/functions/sinNode.js";
+import { sqrt } from "../nodes/functions/sqrtNode.js";
+import { tan } from "../nodes/functions/tanNode.js";
+import { ArcsinNode } from "../nodes/functions/arcSinNode.js";
+import { ArctanNode } from "../nodes/functions/arctanNode.js";
+import { exp } from "../nodes/functions/expNode.js";
+import { LogNode } from "../nodes/functions/logNode.js";
+import { Log10Node } from "../nodes/functions/log10Node.js";
+import { NodeConstructor } from "../nodes/nodeConstructor.js";
+import { isOperatorNode, OperatorIds, } from "../nodes/operators/operatorNode.js";
+import { opposite } from "../nodes/functions/oppositeNode.js";
+import { facto } from "../nodes/functions/factorialNode.js";
+import { getCartesiansProducts } from "../../utils/arrays/cartesianProducts.js";
+import { randint } from "../../math/utils/random/randint.js";
+import { NodeInspector } from "./nodeInspector.js";
+export class NodeRewriter {
+    static rewriteTopLevel = (algebraicNode, indexIn, shuffleArrayIn) => {
+        const children = NodeInspector.getChildren(algebraicNode);
+        const shuffleArray = shuffleArrayIn ?? [...Array(children.length).keys()];
+        const shuffledChildren = shuffleArray.map((iTo) => children[iTo]);
+        const funcCreateNodeFromChildren = this.getCreateNodeFromChildrenFunction(algebraicNode, indexIn);
+        return funcCreateNodeFromChildren(shuffledChildren);
+    };
+    static getCreateNodeFromChildrenFunction = (algebraicNode, indexIn) => {
+        const arrFuncCreateNodeFromChildren = this.getArrCreateNodeFromChildrenFunction(algebraicNode);
+        const nbRewritings = arrFuncCreateNodeFromChildren.length;
+        const index = indexIn
+            ? Math.max(nbRewritings - 1, indexIn)
+            : randint(0, nbRewritings);
+        return arrFuncCreateNodeFromChildren[index];
+    };
+    /*
+      commutation is managed as any other rewriting
+    */
+    static getArrCreateNodeFromChildrenFunction = (algebraicNode) => {
+        if (isOperatorNode(algebraicNode)) {
+            switch (algebraicNode.id) {
+                case OperatorIds.binomialCoefficient:
+                    return [
+                        (children) => new BinomialCoefficientNode(children[0], children[1], algebraicNode.opts),
+                    ];
+                case OperatorIds.divide:
+                    return [
+                        (children) => new DivideNode(children[0], children[1]),
+                    ];
+                case OperatorIds.fraction: {
+                    return [
+                        (children) => frac(children[0], children[1], algebraicNode.opts),
+                        (children) => multiply(children[0], frac((1).toTree(), children[1], algebraicNode.opts), algebraicNode.opts),
+                        (children) => multiply(frac((1).toTree(), children[1], algebraicNode.opts), children[0], algebraicNode.opts),
+                    ];
+                }
+                case OperatorIds.integral:
+                    return [
+                        () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers()),
+                    ];
+                case OperatorIds.limit:
+                    return [
+                        () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers()),
+                    ];
+                case OperatorIds.multiply:
+                    return [
+                        (children) => multiply(children[0], children[1], algebraicNode.opts),
+                        (children) => multiply(children[1], children[0], algebraicNode.opts),
+                    ];
+                case OperatorIds.power:
+                case OperatorIds.square: //this is so nice
+                    return [
+                        (children) => power(children[0], children[1], algebraicNode.opts),
+                    ];
+                case OperatorIds.substract:
+                    return [
+                        (children) => substract(children[0], children[1], algebraicNode.opts),
+                    ];
+                case OperatorIds.add:
+                    return [
+                        (children) => new AddNode(children[0], children[1], algebraicNode.opts),
+                        (children) => new AddNode(children[1], children[0], algebraicNode.opts),
+                    ];
+            }
+        }
+        else if (isFunctionNode(algebraicNode)) {
+            switch (algebraicNode.id) {
+                case FunctionsIds.arccos:
+                    return [(children) => arccos(children[0])];
+                case FunctionsIds.arcsin:
+                    return [(children) => new ArcsinNode(children[0])];
+                case FunctionsIds.arctan:
+                    return [(children) => new ArctanNode(children[0])];
+                case FunctionsIds.cos:
+                    return [(children) => new CosNode(children[0])];
+                case FunctionsIds.exp:
+                    return [
+                        (children) => exp(children[0], algebraicNode.opts),
+                    ];
+                case FunctionsIds.log:
+                    return [
+                        (children) => new LogNode(children[0], algebraicNode.opts),
+                    ];
+                case FunctionsIds.log10:
+                    return [
+                        (children) => new Log10Node(children[0], algebraicNode.opts),
+                    ];
+                case FunctionsIds.opposite:
+                    return [(children) => opposite(children[0])];
+                case FunctionsIds.sin:
+                    return [(children) => sin(children[0])];
+                case FunctionsIds.sqrt:
+                    return [
+                        (children) => sqrt(children[0]),
+                        (children) => power(children[0], frac(1, 2)),
+                    ];
+                case FunctionsIds.tan:
+                    return [(children) => tan(children[0])];
+                case FunctionsIds.abs:
+                    return [(children) => abs(children[0])];
+                case FunctionsIds.factorial:
+                    return [(children) => facto(children[0])];
+            }
+        }
+        else {
+            return [
+                () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers()),
+            ];
+        }
+    };
+    static getArrRewriteTopLevel(algebraicNode) {
+        const children = NodeInspector.getChildren(algebraicNode);
+        if (children.length === 0) {
+            return [algebraicNode];
+        }
+        const arrFunc = this.getArrCreateNodeFromChildrenFunction(algebraicNode);
+        return arrFunc.map((funcCreateNodeFromChildren) => funcCreateNodeFromChildren(children));
+    }
+    static getArrNodeEquivalent(algebraicNode, isDistinctTex = true) {
+        const children = NodeInspector.getChildren(algebraicNode);
+        if (children.length === 0) {
+            return [algebraicNode];
+        }
+        //get all valid combinations of topLevel-equivalent children
+        const arrChildrenRefined = getCartesiansProducts(children.map((nodeChild) => this.getArrNodeEquivalent(nodeChild).flatMap((nodeChild) => this.getArrRewriteTopLevel(nodeChild))));
+        const arrNodeEquivalentRaw = arrChildrenRefined.flatMap((childrenRefined) => {
+            const arrFuncCreateNodeFromChildren = this.getArrCreateNodeFromChildrenFunction(algebraicNode);
+            return arrFuncCreateNodeFromChildren.map((funcCreateNodeFromChildren) => funcCreateNodeFromChildren(childrenRefined));
+        });
+        if (isDistinctTex) {
+            return arrNodeEquivalentRaw
+                .reduce((acc, node) => {
+                const tex = node.toTex();
+                if (!acc.some(({ tex: texExisting }) => tex === texExisting)) {
+                    acc.push({ node, tex });
+                }
+                return acc;
+            }, [])
+                .map(({ node }) => node);
+        }
+        else {
+            return arrNodeEquivalentRaw;
+        }
+    }
+}

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

@@ -4,9 +4,7 @@ export type DeepShuffleOpts = {
     nodeTypesNoFurther: string[];
 };
 export declare abstract class NodeShuffler {
-    static shuffle: <T extends AlgebraicNode>(algebraicNode: T, shuffleArrayIn?: number[]) => AlgebraicNode;
-    static deepShuffle: <T extends AlgebraicNode>(algebraicNode: T, deepShuffleOpts?: DeepShuffleOpts, shuffleArrayIn?: number[]) => AlgebraicNode;
-    private static getCreateNodeFromChildrenFunction;
-    static getChildren(algebraicNode: AlgebraicNode): AlgebraicNode[];
+    static shuffle: <T extends AlgebraicNode>(algebraicNode: T, shuffleArrayIn?: number[], indexIn?: number) => AlgebraicNode;
+    static deepShuffle: <T extends AlgebraicNode>(algebraicNode: T, deepShuffleOpts?: DeepShuffleOpts, shuffleArrayIn?: number[], indexIn?: number) => AlgebraicNode;
 }
 //# sourceMappingURL=nodeShuffler.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"nodeShuffler.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeShuffler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AA+B1D,MAAM,MAAM,eAAe,GAAG;IAC5B,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,8BAAsB,YAAY;IAChC,MAAM,CAAC,OAAO,GAAI,CAAC,SAAS,aAAa,EACvC,eAAe,CAAC,EAChB,iBAAiB,MAAM,EAAE,KACxB,aAAa,CAQd;IAGF,MAAM,CAAC,WAAW,GAAI,CAAC,SAAS,aAAa,EAC3C,eAAe,CAAC,EAChB,kBAAiB,eAGhB,EACD,iBAAiB,MAAM,EAAE,KACxB,aAAa,CAyBd;IAEF,OAAO,CAAC,MAAM,CAAC,iCAAiC,CAkF9C;IAEF,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,aAAa;CAShD"}
+{"version":3,"file":"nodeShuffler.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeShuffler.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAI1D,MAAM,MAAM,eAAe,GAAG;IAC5B,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,8BAAsB,YAAY;IAChC,MAAM,CAAC,OAAO,GAAI,CAAC,SAAS,aAAa,EACvC,eAAe,CAAC,EAChB,iBAAiB,MAAM,EAAE,EACzB,UAAU,MAAM,KACf,aAAa,CAUd;IAGF,MAAM,CAAC,WAAW,GAAI,CAAC,SAAS,aAAa,EAC3C,eAAe,CAAC,EAChB,kBAAiB,eAGhB,EACD,iBAAiB,MAAM,EAAE,EACzB,UAAS,MAAU,KAClB,aAAa,CA0Bd;CACH"}

package/lib/tree/utilities/nodeShuffler.js

@@ -1,126 +1,35 @@
 import { shuffle } from "../../utils/alea/shuffle.js";
-import { abs } from "../nodes/functions/absNode.js";
-import { arccos } from "../nodes/functions/arccosNode.js";
-import { CosNode } from "../nodes/functions/cosNode.js";
-import { FunctionsIds, isFunctionNode, } from "../nodes/functions/functionNode.js";
-import { AddNode } from "../nodes/operators/addNode.js";
-import { BinomialCoefficientNode } from "../nodes/operators/binomialCoefficientNode.js";
-import { DivideNode } from "../nodes/operators/divideNode.js";
-import { FractionNode } from "../nodes/operators/fractionNode.js";
-import { MultiplyNode } from "../nodes/operators/multiplyNode.js";
-import { PowerNode } from "../nodes/operators/powerNode.js";
-import { SubstractNode } from "../nodes/operators/substractNode.js";
-import { sin } from "../nodes/functions/sinNode.js";
-import { sqrt } from "../nodes/functions/sqrtNode.js";
-import { tan } from "../nodes/functions/tanNode.js";
-import { ArcsinNode } from "../nodes/functions/arcSinNode.js";
-import { ArctanNode } from "../nodes/functions/arctanNode.js";
-import { ExpNode } from "../nodes/functions/expNode.js";
-import { LogNode } from "../nodes/functions/logNode.js";
-import { Log10Node } from "../nodes/functions/log10Node.js";
-import { NodeConstructor } from "../nodes/nodeConstructor.js";
-import { isOperatorNode, OperatorIds, } from "../nodes/operators/operatorNode.js";
-import { opposite } from "../nodes/functions/oppositeNode.js";
-import { facto } from "../nodes/functions/factorialNode.js";
+import { NodeInspector } from "./nodeInspector.js";
+import { NodeRewriter } from "./nodeRewriter.js";
 export class NodeShuffler {
-    static shuffle = (algebraicNode, shuffleArrayIn) => {
-        const children = this.getChildren(algebraicNode);
+    static shuffle = (algebraicNode, shuffleArrayIn, indexIn) => {
+        const children = NodeInspector.getChildren(algebraicNode);
         const shuffleArray = shuffleArrayIn ?? shuffle([...Array(children.length).keys()]);
         const shuffledChildren = shuffleArray.map((iTo) => children[iTo]);
-        return this.getCreateNodeFromChildrenFunction(algebraicNode)(shuffledChildren);
+        const funcCreateNodeFromChildren = NodeRewriter.getCreateNodeFromChildrenFunction(algebraicNode, indexIn);
+        return funcCreateNodeFromChildren(shuffledChildren);
     };
     //commutative by default
     static deepShuffle = (algebraicNode, deepShuffleOpts = {
         nodeTypesToShuffle: ["AddNode", "MultiplyNode"],
         nodeTypesNoFurther: [],
-    }, shuffleArrayIn) => {
+    }, shuffleArrayIn, indexIn = 0) => {
         const isCanBeTraversed = !deepShuffleOpts.nodeTypesNoFurther.includes(algebraicNode.constructor.name);
-        const children = this.getChildren(algebraicNode).map((childNode) => isCanBeTraversed
+        const children = NodeInspector.getChildren(algebraicNode).map((childNode) => isCanBeTraversed
             ? this.deepShuffle(childNode, deepShuffleOpts, shuffleArrayIn)
             : childNode);
-        const createNodeFromChildren = this.getCreateNodeFromChildrenFunction(algebraicNode);
-        if (children.length > 0) {
+        const funcCreateNodeFromChildren = NodeRewriter.getCreateNodeFromChildrenFunction(algebraicNode, indexIn);
+        if (children.length > 1) {
             const isCanBeShuffled = (deepShuffleOpts?.nodeTypesToShuffle ?? []).includes(algebraicNode.constructor.name);
             if (isCanBeShuffled) {
                 const shuffleArray = shuffleArrayIn ?? shuffle([...Array(children.length).keys()]);
                 const shuffledChildren = shuffleArray.map((iTo) => children[iTo]);
-                return createNodeFromChildren(shuffledChildren);
+                return funcCreateNodeFromChildren(shuffledChildren);
             }
             else {
-                createNodeFromChildren(children);
+                funcCreateNodeFromChildren(children);
             }
         }
-        return createNodeFromChildren(children);
+        return funcCreateNodeFromChildren(children);
     };
-    static getCreateNodeFromChildrenFunction = (algebraicNode) => {
-        if (isOperatorNode(algebraicNode)) {
-            switch (algebraicNode.id) {
-                case OperatorIds.binomialCoefficient:
-                    return (children) => new BinomialCoefficientNode(children[0], children[1], algebraicNode.opts);
-                case OperatorIds.divide:
-                    return (children) => new DivideNode(children[0], children[1]);
-                case OperatorIds.fraction:
-                    return (children) => new FractionNode(children[0], children[1], algebraicNode.opts);
-                case OperatorIds.integral:
-                    //   throw new Error("unsupported node type: integral");  //need to do intelligent shuffle here
-                    return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
-                case OperatorIds.limit:
-                    //   throw new Error("unsupported node type: limit");   //need to do intelligent shuffle here
-                    return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
-                case OperatorIds.multiply:
-                    return (children) => new MultiplyNode(children[0], children[1], algebraicNode.opts);
-                case OperatorIds.power:
-                case OperatorIds.square: //this is so nice
-                    return (children) => new PowerNode(children[0], children[1], algebraicNode.opts);
-                case OperatorIds.substract:
-                    return (children) => new SubstractNode(children[0], children[1], algebraicNode.opts);
-                case OperatorIds.add:
-                    return (children) => new AddNode(children[0], children[1], algebraicNode.opts);
-            }
-        }
-        else if (isFunctionNode(algebraicNode)) {
-            switch (algebraicNode.id) {
-                case FunctionsIds.arccos:
-                    return (children) => arccos(children[0]);
-                case FunctionsIds.arcsin:
-                    return (children) => new ArcsinNode(children[0]);
-                case FunctionsIds.arctan:
-                    return (children) => new ArctanNode(children[0]);
-                case FunctionsIds.cos:
-                    return (children) => new CosNode(children[0]);
-                case FunctionsIds.exp:
-                    return (children) => new ExpNode(children[0], algebraicNode.opts);
-                case FunctionsIds.log:
-                    return (children) => new LogNode(children[0], algebraicNode.opts);
-                case FunctionsIds.log10:
-                    return (children) => new Log10Node(children[0], algebraicNode.opts);
-                case FunctionsIds.opposite:
-                    return (children) => opposite(children[0]);
-                case FunctionsIds.sin:
-                    return (children) => sin(children[0]);
-                case FunctionsIds.sqrt:
-                    return (children) => sqrt(children[0]);
-                case FunctionsIds.tan:
-                    return (children) => tan(children[0]);
-                case FunctionsIds.abs:
-                    return (children) => abs(children[0]);
-                case FunctionsIds.factorial:
-                    return (children) => facto(children[0]);
-            }
-        }
-        else {
-            return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
-        }
-    };
-    static getChildren(algebraicNode) {
-        if (isOperatorNode(algebraicNode)) {
-            return [algebraicNode.leftChild, algebraicNode.rightChild];
-        }
-        else if (isFunctionNode(algebraicNode)) {
-            return [algebraicNode.child];
-        }
-        else {
-            return [];
-        }
-    }
 }

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

@@ -10,7 +10,6 @@ export declare abstract class NodeSimplifier {
     static arrTexStepByStep: (node: AlgebraicNode, simplifyOpts?: SimplifyOptions, simplifierOpts?: {
         isMultiTopLevel: boolean;
     }, toTexOpts?: ToTexOptions) => string[];
-    private static getCreateNodeFromChildrenFunction;
-    static getChildren(algebraicNode: AlgebraicNode): AlgebraicNode[];
+    static simplifyByVibrating(algebraicNode: AlgebraicNode, nbVibrations?: number, isTowardsDistribute?: boolean): 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;AAmC3E,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIhD,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,OAAO,CAAC,MAAM,CAAC,iCAAiC,CAkF9C;IAEF,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,aAAa;CAShD"}
+{"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"}

package/lib/tree/utilities/nodeSimplifier.js

@@ -1,34 +1,20 @@
 import { abs } from "../nodes/functions/absNode.js";
-import { arccos } from "../nodes/functions/arccosNode.js";
-import { CosNode } from "../nodes/functions/cosNode.js";
-import { FunctionsIds, isFunctionNode, } from "../nodes/functions/functionNode.js";
+import { isFunctionNode } from "../nodes/functions/functionNode.js";
 import { AddNode, isAddNode } from "../nodes/operators/addNode.js";
-import { BinomialCoefficientNode } from "../nodes/operators/binomialCoefficientNode.js";
 import { DivideNode, isDivideNode } from "../nodes/operators/divideNode.js";
-import { FractionNode } from "../nodes/operators/fractionNode.js";
 import { isMultiplyNode, MultiplyNode, } from "../nodes/operators/multiplyNode.js";
-import { PowerNode } from "../nodes/operators/powerNode.js";
 import { isSubstractNode, SubstractNode, } from "../nodes/operators/substractNode.js";
-import { sin } from "../nodes/functions/sinNode.js";
-import { sqrt } from "../nodes/functions/sqrtNode.js";
-import { tan } from "../nodes/functions/tanNode.js";
-import { ArcsinNode } from "../nodes/functions/arcSinNode.js";
-import { ArctanNode } from "../nodes/functions/arctanNode.js";
-import { ExpNode } from "../nodes/functions/expNode.js";
-import { LogNode } from "../nodes/functions/logNode.js";
-import { Log10Node } from "../nodes/functions/log10Node.js";
-import { NodeConstructor } from "../nodes/nodeConstructor.js";
 import { isOperatorNode, OperatorIds, } from "../nodes/operators/operatorNode.js";
-import { opposite } from "../nodes/functions/oppositeNode.js";
 import { isNumberNode } from "../nodes/numbers/numberNode.js";
-import { facto } from "../nodes/functions/factorialNode.js";
+import { NodeInspector } from "./nodeInspector.js";
+import { NodeRewriter } from "./nodeRewriter.js";
 export class NodeSimplifier {
     static getDepth = (algebraicNode, simplifyOpts, toTexOptions = {
         forceTimesSign: true,
         forceParenthesis: true,
         forceNoSimplification: true,
     }) => {
-        const children = this.getChildren(algebraicNode);
+        const children = NodeInspector.getChildren(algebraicNode);
         if (children.length === 0) {
             return 0;
         }
@@ -98,7 +84,7 @@ export class NodeSimplifier {
             default:
                 return [
                     ...(() => {
-                        const arrArrChild = this.getChildren(algebraicNode).map((nodeChild) => this.nodesStepByStep(nodeChild, simplifyOpts, simplifierOpts));
+                        const arrArrChild = NodeInspector.getChildren(algebraicNode).map((nodeChild) => this.nodesStepByStep(nodeChild, simplifyOpts, simplifierOpts));
                         const maxLength = Math.max(...arrArrChild.map((nodesSByS) => nodesSByS.length));
                         //multi or single here
                         let arrChildren;
@@ -191,11 +177,11 @@ export class NodeSimplifier {
                                     return new DivideNode(new MultiplyNode(childrenRefined[0], divNode.leftChild), divNode.rightChild);
                                 }
                                 else {
-                                    return this.getCreateNodeFromChildrenFunction(algebraicNode)(childrenRefined);
+                                    return NodeRewriter.getCreateNodeFromChildrenFunction(algebraicNode)(childrenRefined);
                                 }
                             }
                             else {
-                                return this.getCreateNodeFromChildrenFunction(algebraicNode)(childrenRefined);
+                                return NodeRewriter.getCreateNodeFromChildrenFunction(algebraicNode)(childrenRefined);
                             }
                         });
                     })(),
@@ -212,75 +198,15 @@ export class NodeSimplifier {
     }) => {
         return this.nodesStepByStep(node, simplifyOpts, simplifierOpts, toTexOpts).map((node) => node.toTex(toTexOpts));
     };
-    static getCreateNodeFromChildrenFunction = (algebraicNode) => {
-        if (isOperatorNode(algebraicNode)) {
-            switch (algebraicNode.id) {
-                case OperatorIds.binomialCoefficient:
-                    return (children) => new BinomialCoefficientNode(children[0], children[1], algebraicNode.opts);
-                case OperatorIds.divide:
-                    return (children) => new DivideNode(children[0], children[1]);
-                case OperatorIds.fraction:
-                    return (children) => new FractionNode(children[0], children[1], algebraicNode.opts);
-                case OperatorIds.integral:
-                    //   throw new Error("unsupported node type: integral");  //need to do intelligent shuffle here
-                    return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
-                case OperatorIds.limit:
-                    //   throw new Error("unsupported node type: limit");   //need to do intelligent shuffle here
-                    return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
-                case OperatorIds.multiply:
-                    return (children) => new MultiplyNode(children[0], children[1], algebraicNode.opts);
-                case OperatorIds.power:
-                case OperatorIds.square: //this is so nice
-                    return (children) => new PowerNode(children[0], children[1], algebraicNode.opts);
-                case OperatorIds.substract:
-                    return (children) => new SubstractNode(children[0], children[1], algebraicNode.opts);
-                case OperatorIds.add:
-                    return (children) => new AddNode(children[0], children[1], algebraicNode.opts);
-            }
-        }
-        else if (isFunctionNode(algebraicNode)) {
-            switch (algebraicNode.id) {
-                case FunctionsIds.arccos:
-                    return (children) => arccos(children[0]);
-                case FunctionsIds.arcsin:
-                    return (children) => new ArcsinNode(children[0]);
-                case FunctionsIds.arctan:
-                    return (children) => new ArctanNode(children[0]);
-                case FunctionsIds.cos:
-                    return (children) => new CosNode(children[0]);
-                case FunctionsIds.exp:
-                    return (children) => new ExpNode(children[0], algebraicNode.opts);
-                case FunctionsIds.log:
-                    return (children) => new LogNode(children[0], algebraicNode.opts);
-                case FunctionsIds.log10:
-                    return (children) => new Log10Node(children[0], algebraicNode.opts);
-                case FunctionsIds.opposite:
-                    return (children) => opposite(children[0]);
-                case FunctionsIds.sin:
-                    return (children) => sin(children[0]);
-                case FunctionsIds.sqrt:
-                    return (children) => sqrt(children[0]);
-                case FunctionsIds.tan:
-                    return (children) => tan(children[0]);
-                case FunctionsIds.abs:
-                    return (children) => abs(children[0]);
-                case FunctionsIds.factorial:
-                    return (children) => facto(children[0]);
-            }
-        }
-        else {
-            return () => NodeConstructor.fromIdentifiers(algebraicNode.toIdentifiers());
-        }
-    };
-    static getChildren(algebraicNode) {
-        if (isOperatorNode(algebraicNode)) {
-            return [algebraicNode.leftChild, algebraicNode.rightChild];
-        }
-        else if (isFunctionNode(algebraicNode)) {
-            return [algebraicNode.child];
+    static simplifyByVibrating(algebraicNode, nbVibrations = 5, isTowardsDistribute = true) {
+        if (nbVibrations === 0) {
+            return algebraicNode;
         }
         else {
-            return [];
+            const nodeSimplified = algebraicNode.simplify({
+                towardsDistribute: isTowardsDistribute,
+            });
+            return this.simplifyByVibrating(nodeSimplified, nbVibrations - 1, !isTowardsDistribute);
         }
     }
 }

package/package.json

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