math-exercises 3.0.183 → 3.0.185

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.183",
+  "version": "3.0.185",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [