math-exercises 2.2.9 → 2.2.11

package/lib/tree/nodes/nodeConstructor.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeConstructor = void 0;
+const point_1 = require("../../math/geometry/point");
+const complexNode_1 = require("./complex/complexNode");
+const equalNode_1 = require("./equations/equalNode");
+const equationSolutionNode_1 = require("./equations/equationSolutionNode");
+const multiEqualNode_1 = require("./equations/multiEqualNode");
+const absNode_1 = require("./functions/absNode");
+const arcSinNode_1 = require("./functions/arcSinNode");
+const arccosNode_1 = require("./functions/arccosNode");
+const arctanNode_1 = require("./functions/arctanNode");
+const cosNode_1 = require("./functions/cosNode");
+const expNode_1 = require("./functions/expNode");
+const integralNode_1 = require("./functions/integralNode");
+const log10Node_1 = require("./functions/log10Node");
+const logNode_1 = require("./functions/logNode");
+const oppositeNode_1 = require("./functions/oppositeNode");
+const sinNode_1 = require("./functions/sinNode");
+const sqrtNode_1 = require("./functions/sqrtNode");
+const tanNode_1 = require("./functions/tanNode");
+const degree_1 = require("./geometry/degree");
+const lengthNode_1 = require("./geometry/lengthNode");
+const pointNode_1 = require("./geometry/pointNode");
+const vectorNode_1 = require("./geometry/vectorNode");
+const inequationNode_1 = require("./inequations/inequationNode");
+const inequationSolutionNode_1 = require("./inequations/inequationSolutionNode");
+const node_1 = require("./node");
+const constantNode_1 = require("./numbers/constantNode");
+const numberNode_1 = require("./numbers/numberNode");
+const percentNode_1 = require("./numbers/percentNode");
+const addNode_1 = require("./operators/addNode");
+const divideNode_1 = require("./operators/divideNode");
+const fractionNode_1 = require("./operators/fractionNode");
+const limitNode_1 = require("./operators/limitNode");
+const multiplyNode_1 = require("./operators/multiplyNode");
+const powerNode_1 = require("./operators/powerNode");
+const substractNode_1 = require("./operators/substractNode");
+const belongsNode_1 = require("./sets/belongsNode");
+const discreteSetNode_1 = require("./sets/discreteSetNode");
+const intervalNode_1 = require("./sets/intervalNode");
+const unionIntervalNode_1 = require("./sets/unionIntervalNode");
+const variableNode_1 = require("./variables/variableNode");
+class NodeConstructor {
+    static fromIdentifiers(identifiers) {
+        switch (identifiers.id) {
+            case node_1.NodeIds.variable: {
+                return new variableNode_1.VariableNode(identifiers.name);
+            }
+            case node_1.NodeIds.number: {
+                return new numberNode_1.NumberNode(identifiers.value);
+            }
+            case node_1.NodeIds.constant: {
+                return new constantNode_1.ConstantNode(identifiers.tex, identifiers.mathString, identifiers.value);
+            }
+            case node_1.NodeIds.complex: {
+                return new complexNode_1.ComplexNode(NodeConstructor.fromIdentifiers(identifiers.re), NodeConstructor.fromIdentifiers(identifiers.im));
+            }
+            case node_1.NodeIds.percent: {
+                return new percentNode_1.PercentNode(identifiers.value);
+            }
+            /**Equations */
+            case node_1.NodeIds.equal: {
+                return new equalNode_1.EqualNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild));
+            }
+            case node_1.NodeIds.equationSolution: {
+                return new equationSolutionNode_1.EquationSolutionNode(NodeConstructor.fromIdentifiers(identifiers.solutionsSet));
+            }
+            case node_1.NodeIds.multiEqual: {
+                return new multiEqualNode_1.MultiEqualNode(identifiers.children.map((e) => NodeConstructor.fromIdentifiers(e)));
+            }
+            /**Inequations */
+            case node_1.NodeIds.inequation: {
+                return new inequationNode_1.InequationNode(identifiers.children.map((e) => NodeConstructor.fromIdentifiers(e)), identifiers.symbols);
+            }
+            case node_1.NodeIds.inequationSolution: {
+                return new inequationSolutionNode_1.InequationSolutionNode(NodeConstructor.fromIdentifiers(identifiers.intervalSolution));
+            }
+            /**Geométrie */
+            case node_1.NodeIds.degree: {
+                return new degree_1.DegreeNode(identifiers.value);
+            }
+            case node_1.NodeIds.point: {
+                return new pointNode_1.PointNode(new point_1.Point(identifiers.point.name, NodeConstructor.fromIdentifiers(identifiers.point.x), NodeConstructor.fromIdentifiers(identifiers.point.y)));
+            }
+            case node_1.NodeIds.length: {
+                return new lengthNode_1.LengthNode(identifiers.name);
+            }
+            case node_1.NodeIds.vector: {
+                return new vectorNode_1.VectorNode(identifiers.name);
+            }
+            /**Functions */
+            case node_1.NodeIds.abs: {
+                return new absNode_1.AbsNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.arccos: {
+                return new arccosNode_1.ArccosNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.arcsin: {
+                return new arcSinNode_1.ArcsinNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.arctan: {
+                return new arctanNode_1.ArctanNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.cos: {
+                return new cosNode_1.CosNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.sin: {
+                return new sinNode_1.SinNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.tan: {
+                return new tanNode_1.TanNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.exp: {
+                return new expNode_1.ExpNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.integral: {
+                return new integralNode_1.IntegralNode(NodeConstructor.fromIdentifiers(identifiers.functionNode), NodeConstructor.fromIdentifiers(identifiers.lowerBound), NodeConstructor.fromIdentifiers(identifiers.upperBound), identifiers.variable);
+            }
+            case node_1.NodeIds.log10: {
+                return new log10Node_1.Log10Node(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.log: {
+                return new logNode_1.LogNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.opposite: {
+                return new oppositeNode_1.OppositeNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            case node_1.NodeIds.sqrt: {
+                return new sqrtNode_1.SqrtNode(NodeConstructor.fromIdentifiers(identifiers.child));
+            }
+            /**Sets */
+            case node_1.NodeIds.discreteSet: {
+                return new discreteSetNode_1.DiscreteSetNode(identifiers.children.map((e) => NodeConstructor.fromIdentifiers(e)));
+            }
+            case node_1.NodeIds.belongs: {
+                return new belongsNode_1.BelongsNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild));
+            }
+            case node_1.NodeIds.interval: {
+                return new intervalNode_1.IntervalNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild), identifiers.closure);
+            }
+            case node_1.NodeIds.union: {
+                return new unionIntervalNode_1.UnionIntervalNode(identifiers.children.map((e) => NodeConstructor.fromIdentifiers(e)));
+            }
+            /**Operators */
+            case node_1.NodeIds.add: {
+                return new addNode_1.AddNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild));
+            }
+            case node_1.NodeIds.substract: {
+                return new substractNode_1.SubstractNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild));
+            }
+            case node_1.NodeIds.multiply: {
+                return new multiplyNode_1.MultiplyNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild));
+            }
+            case node_1.NodeIds.divide: {
+                return new divideNode_1.DivideNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild));
+            }
+            case node_1.NodeIds.fraction: {
+                return new fractionNode_1.FractionNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild));
+            }
+            case node_1.NodeIds.power: {
+                return new powerNode_1.PowerNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild));
+            }
+            case node_1.NodeIds.limit: {
+                return new limitNode_1.LimitNode(NodeConstructor.fromIdentifiers(identifiers.leftChild), NodeConstructor.fromIdentifiers(identifiers.rightChild), identifiers.from);
+            }
+        }
+    }
+}
+exports.NodeConstructor = NodeConstructor;

package/lib/tree/nodes/numbers/constantNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeType } from "../node";
+import { Node, NodeIds, NodeType } from "../node";
 import { AlgebraicNode } from "../algebraicNode";
 export declare function isConstantNode(a: Node): a is ConstantNode;
 export declare class ConstantNode implements AlgebraicNode {
@@ -11,6 +11,12 @@ export declare class ConstantNode implements AlgebraicNode {
     toMathString(): string;
     toTex(): string;
     toAllValidTexs(): string[];
+    toIdentifiers(): {
+        id: NodeIds;
+        mathString: string;
+        tex: string;
+        value: number;
+    };
     toEquivalentNodes(): this[];
     evaluate(vars: Record<string, number>): number;
     simplify(): this;

package/lib/tree/nodes/numbers/constantNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constantNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/constantNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAqB;IACnC,SAAS,EAAE,OAAO,CAAC;gBACP,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAO1D,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAMf,cAAc;IAGd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}
+{"version":3,"file":"constantNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/constantNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAQ1D,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAMf,cAAc;IAGd,aAAa;;;;;;IAQb,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}

package/lib/tree/nodes/numbers/constantNode.js

@@ -9,11 +9,11 @@ function isConstantNode(a) {
 exports.isConstantNode = isConstantNode;
 class ConstantNode {
     constructor(tex, mathString, value) {
-        this.type = node_1.NodeType.constant;
         this.tex = tex;
         this.mathString = mathString;
         this.value = value;
         this.isNumeric = true;
+        this.type = node_1.NodeType.constant;
     }
     toMathString() {
         return `${this.mathString}`;
@@ -27,6 +27,14 @@ class ConstantNode {
     toAllValidTexs() {
         return this.toEquivalentNodes().map((node) => node.toTex());
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.constant,
+            mathString: this.mathString,
+            tex: this.tex,
+            value: this.value,
+        };
+    }
     toEquivalentNodes() {
         return [this];
     }

package/lib/tree/nodes/numbers/numberNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeType } from "../node";
+import { Node, NodeIds, NodeType } from "../node";
 import { AlgebraicNode } from "../algebraicNode";
 export declare function isNumberNode(a: Node): a is NumberNode;
 export declare abstract class NumberNodeConstructor {
@@ -14,6 +14,10 @@ export declare class NumberNode implements AlgebraicNode {
     toMathString(): string;
     toTex(): string;
     toMathjs(): string;
+    toIdentifiers(): {
+        id: NodeIds;
+        value: number;
+    };
     toAllValidTexs(): string[];
     toEquivalentNodes(): this[];
     evaluate(vars: Record<string, number>): number;

package/lib/tree/nodes/numbers/numberNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numberNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/numberNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,EAAO;CAGhE;AACD,qBAAa,UAAW,YAAW,aAAa;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAmB;IACjC,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAO5D,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAGR,cAAc;IAOd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}
+{"version":3,"file":"numberNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/numberNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,EAAO;CAGhE;AACD,qBAAa,UAAW,YAAW,aAAa;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAmB;IACjC,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAO5D,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAGR,aAAa;;;;IAMb,cAAc;IAOd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}

package/lib/tree/nodes/numbers/numberNode.js

@@ -30,6 +30,12 @@ class NumberNode {
     toMathjs() {
         return this.toMathString();
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.number,
+            value: this.value,
+        };
+    }
     toAllValidTexs() {
         const res = [];
         res.push(this.tex);

package/lib/tree/nodes/numbers/percentNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeType } from "../node";
+import { Node, NodeIds, NodeType } from "../node";
 export declare class PercentNode implements Node {
     value: number;
     type: NodeType;
@@ -7,6 +7,10 @@ export declare class PercentNode implements Node {
     toTex(): string;
     toMathjs(): string;
     toAllValidTexs(): string[];
+    toIdentifiers(): {
+        id: NodeIds;
+        value: number;
+    };
     toEquivalentNodes(): this[];
 }
 //# sourceMappingURL=percentNode.d.ts.map

package/lib/tree/nodes/numbers/percentNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"percentNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/percentNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzC,qBAAa,WAAY,YAAW,IAAI;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAC;gBAEH,KAAK,EAAE,MAAM;IAKzB,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAGR,cAAc;IAGd,iBAAiB;CAGlB"}
+{"version":3,"file":"percentNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/percentNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAElD,qBAAa,WAAY,YAAW,IAAI;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAC;gBAEH,KAAK,EAAE,MAAM;IAKzB,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAGf,QAAQ;IAGR,cAAc;IAGd,aAAa;;;;IAMb,iBAAiB;CAGlB"}

package/lib/tree/nodes/numbers/percentNode.js

@@ -19,6 +19,12 @@ class PercentNode {
     toAllValidTexs() {
         return [this.toTex()];
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.percent,
+            value: this.value,
+        };
+    }
     toEquivalentNodes() {
         return [this];
     }

package/lib/tree/nodes/operators/addNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeOptions, NodeType } from "../node";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { CommutativeOperatorNode, OperatorIds } from "./operatorNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 export declare function isAddNode(a: Node): a is AddNode;
@@ -18,6 +18,15 @@ export declare class AddNode implements CommutativeOperatorNode {
     toTex(): string;
     evaluate(vars: Record<string, number>): number;
     simplify(opts?: SimplifyOptions): AlgebraicNode;
+    toIdentifiers(): {
+        id: NodeIds;
+        leftChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+        rightChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+    };
     equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=addNode.d.ts.map

package/lib/tree/nodes/operators/addNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAOlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAMD,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,IAAI,MAAM;IAIf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA2K/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAUrC"}
+{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAgB,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAOlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,IAAI,MAAM;IAUf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA0K/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAUrC"}

package/lib/tree/nodes/operators/addNode.js

@@ -17,11 +17,6 @@ function isAddNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.add;
 }
 exports.isAddNode = isAddNode;
-const addNodeToTex = (leftTex, rightTex) => {
-    if (rightTex === "0")
-        return leftTex;
-    return `${leftTex}${rightTex[0] === "-" ? "" : "+"}${rightTex}`;
-};
 class AddNode {
     constructor(leftChild, rightChild, opts) {
         this.shuffle = () => {
@@ -79,7 +74,15 @@ class AddNode {
     }
     toTex() {
         const rightTex = this.rightChild.toTex();
-        return addNodeToTex(this.leftChild.toTex(), rightTex);
+        const leftTex = this.leftChild.toTex();
+        if (rightTex === "0")
+            return leftTex;
+        const tex = `${leftTex}${rightTex[0] === "-" ? "" : "+"}${rightTex}`;
+        if (this.opts?.forceParenthesis) {
+            return `\\left(${tex}\\right)`;
+        }
+        else
+            return tex;
     }
     evaluate(vars) {
         return this.leftChild.evaluate(vars) + this.rightChild.evaluate(vars);
@@ -245,6 +248,13 @@ class AddNode {
             return externals[0];
         return (0, operatorComposition_1.operatorComposition)(AddNode, externals);
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.add,
+            leftChild: this.leftChild.toIdentifiers(),
+            rightChild: this.rightChild.toIdentifiers(),
+        };
+    }
     equals(node) {
         //!incorrect, il faut plutot vérifier qu'ils ont les meme externals
         return (isAddNode(node) &&

package/lib/tree/nodes/operators/divideNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeOptions, NodeType } from "../node";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { OperatorIds, OperatorNode } from "./operatorNode";
 import { AlgebraicNode } from "../algebraicNode";
 export declare function isDivideNode(a: Node): a is DivideNode;
@@ -14,6 +14,16 @@ export declare class DivideNode implements OperatorNode {
      */
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode);
     toMathString(): string;
+    dangerouslyShuffle(): void;
+    toIdentifiers(): {
+        id: NodeIds;
+        leftChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+        rightChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+    };
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
     toAllValidTexs(): string[];
     toTex(): string;

package/lib/tree/nodes/operators/divideNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"divideNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/divideNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AA0BD,qBAAa,UAAW,YAAW,YAAY;IAC7C,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;gBAES,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa;IAQ/D,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAYpC,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAGf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAO3B"}
+{"version":3,"file":"divideNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/divideNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AA0BD,qBAAa,UAAW,YAAW,YAAY;IAC7C,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;gBAES,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa;IAQ/D,YAAY,IAAI,MAAM;IAGtB,kBAAkB;IAIlB,aAAa;;;;;;;;;IAQb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAYpC,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAGf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAO3B"}

package/lib/tree/nodes/operators/divideNode.js

@@ -4,6 +4,7 @@ exports.DivideNode = exports.isDivideNode = void 0;
 // import { divide } from "mathjs";
 const node_1 = require("../node");
 const operatorNode_1 = require("./operatorNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
 function isDivideNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.divide;
 }
@@ -43,6 +44,17 @@ class DivideNode {
     toMathString() {
         return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
     }
+    dangerouslyShuffle() {
+        if ((0, coinFlip_1.coinFlip)())
+            [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+    }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.divide,
+            leftChild: this.leftChild.toIdentifiers(),
+            rightChild: this.rightChild.toIdentifiers(),
+        };
+    }
     toEquivalentNodes(opts) {
         const res = [];
         const rightNodes = this.rightChild.toEquivalentNodes();

package/lib/tree/nodes/operators/fractionNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeOptions, NodeType } from "../node";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { OperatorIds, OperatorNode } from "./operatorNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 export declare function isFractionNode(a: Node): a is FractionNode;
@@ -15,6 +15,15 @@ export declare class FractionNode implements OperatorNode {
     isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
+    toIdentifiers(): {
+        id: NodeIds;
+        leftChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+        rightChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+    };
     toInversed(): FractionNode;
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
     toAllValidTexs(opts?: NodeOptions): string[];

package/lib/tree/nodes/operators/fractionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAgJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,aAAa;;;;;;;;;IAQb,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAgJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}

package/lib/tree/nodes/operators/fractionNode.js

@@ -27,6 +27,13 @@ class FractionNode {
     toMathString() {
         return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.fraction,
+            leftChild: this.leftChild.toIdentifiers(),
+            rightChild: this.rightChild.toIdentifiers(),
+        };
+    }
     toInversed() {
         return new FractionNode(this.rightChild, this.leftChild);
     }

package/lib/tree/nodes/operators/limitNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeOptions, NodeType, ToTexOptions } from "../node";
+import { Node, NodeIds, NodeOptions, NodeType, ToTexOptions } from "../node";
 import { OperatorIds, OperatorNode } from "./operatorNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 export declare function isLimitNode(a: Node): a is LimitNode;
@@ -20,6 +20,16 @@ export declare class LimitNode implements OperatorNode {
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, from?: "+" | "-", opts?: NodeOptions);
     toMathString(): string;
     toEquivalentNodes(opts?: NodeOptions | undefined): this[];
+    toIdentifiers(): {
+        id: NodeIds;
+        leftChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+        rightChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+        from: "-" | "+" | undefined;
+    };
     toAllValidTexs(): string[];
     toTex(opts?: ToTexOptions): string;
     evaluate(vars: Record<string, number>): number;

package/lib/tree/nodes/operators/limitNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"limitNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/limitNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAElE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,SAAS,CAAC;IAE5B;;;;;;OAMG;gBAED,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,EAChB,IAAI,CAAC,EAAE,WAAW;IAWpB,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAIhD,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IAWlC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;IAI9C,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAG/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}
+{"version":3,"file":"limitNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/limitNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAElE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,SAAS,CAAC;IAE5B;;;;;;OAMG;gBAED,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,EAChB,IAAI,CAAC,EAAE,WAAW;IAWpB,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAGhD,aAAa;;;;;;;;;;IAQb,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IAWlC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;IAI9C,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAG/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}

package/lib/tree/nodes/operators/limitNode.js

@@ -31,6 +31,14 @@ class LimitNode {
     toEquivalentNodes(opts) {
         return [this];
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.limit,
+            leftChild: this.leftChild.toIdentifiers(),
+            rightChild: this.rightChild.toIdentifiers(),
+            from: this.from,
+        };
+    }
     toAllValidTexs() {
         return this.toEquivalentNodes().map((node) => node.toTex());
     }

package/lib/tree/nodes/operators/multiplyNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeOptions, NodeType, ToTexOptions } from "../node";
+import { Node, NodeIds, NodeOptions, NodeType, ToTexOptions } from "../node";
 import { CommutativeOperatorNode, OperatorIds } from "./operatorNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 export declare function isMultiplyNode(a: Node): a is MultiplyNode;
@@ -17,6 +17,15 @@ export declare class MultiplyNode implements CommutativeOperatorNode {
     toAllTexs(): string[];
     toEquivalentNodes(opts?: NodeOptions): MultiplyNode[];
     toAllValidTexs(opts?: NodeOptions): string[];
+    toIdentifiers(): {
+        id: NodeIds;
+        leftChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+        rightChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+    };
     evaluate(vars: Record<string, number>): number;
     copy(): MultiplyNode;
     simplify(opts?: SimplifyOptions): AlgebraicNode;

package/lib/tree/nodes/operators/multiplyNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAOlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IA4DlC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAwFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAIrC,IAAI;IAGJ,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA0H/C,MAAM,CAAC,IAAI,EAAE,aAAa;CAU3B"}
+{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAOlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM;IA4DlC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAwFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAIrC,IAAI;IAGJ,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA0H/C,MAAM,CAAC,IAAI,EAAE,aAAa;CAU3B"}

package/lib/tree/nodes/operators/multiplyNode.js

@@ -202,6 +202,13 @@ class MultiplyNode {
     toAllValidTexs(opts) {
         return this.toEquivalentNodes(opts).flatMap((node) => node.toAllTexs());
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.multiply,
+            leftChild: this.leftChild.toIdentifiers(),
+            rightChild: this.rightChild.toIdentifiers(),
+        };
+    }
     // toMathjs() {
     //   return multiply(this.leftChild.toMathjs(), this.rightChild.toMathjs());
     // }

package/lib/tree/nodes/operators/powerNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeOptions, NodeType } from "../node";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { OperatorIds, OperatorNode } from "./operatorNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 export declare function isPowerNode(a: Node): a is PowerNode;
@@ -11,6 +11,15 @@ export declare class PowerNode implements OperatorNode {
     isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
+    toIdentifiers(): {
+        id: NodeIds;
+        left: {
+            id: NodeIds;
+        } & Record<string, any>;
+        right: {
+            id: NodeIds;
+        } & Record<string, any>;
+    };
     toEquivalentNodes(): AlgebraicNode[];
     toAllValidTexs(): string[];
     toTex(): string;

package/lib/tree/nodes/operators/powerNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAElE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAuBf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IA+FrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAqC/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAGrD"}
+{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAElE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAuBf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IA+FrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAqC/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAGrD"}

package/lib/tree/nodes/operators/powerNode.js

@@ -22,6 +22,13 @@ class PowerNode {
     toMathString() {
         return `(${this.leftChild.toMathString()})^(${this.rightChild.toMathString()})`;
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.power,
+            left: this.leftChild.toIdentifiers(),
+            right: this.rightChild.toIdentifiers(),
+        };
+    }
     toEquivalentNodes() {
         const res = [];
         const rightNodes = this.rightChild.toEquivalentNodes();

package/lib/tree/nodes/operators/substractNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeType } from "../node";
+import { Node, NodeIds, NodeType } from "../node";
 import { OperatorIds, OperatorNode } from "./operatorNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
 export declare function isSubstractNode(a: Node): a is SubstractNode;
@@ -10,8 +10,18 @@ export declare class SubstractNode implements OperatorNode {
     isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode);
     toMathString(): string;
+    toIdentifiers(): {
+        id: NodeIds;
+        left: {
+            id: NodeIds;
+        } & Record<string, any>;
+        right: {
+            id: NodeIds;
+        } & Record<string, any>;
+    };
     toEquivalentNodes(): AlgebraicNode[];
     toAllValidTexs(): string[];
+    dangerouslyShuffle(): void;
     toTex(): string;
     evaluate(vars: Record<string, number>): number;
     simplify(opts?: SimplifyOptions): AlgebraicNode;