math-exercises 2.0.1 → 2.0.2

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

@@ -1,6 +1,11 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class SubstractNode extends OperatorNode implements Node {
+import { Node, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
+export declare function isSubstractNode(a: Node): a is SubstractNode;
+export declare class SubstractNode implements OperatorNode {
+    id: OperatorIds;
+    leftChild: Node;
+    rightChild: Node;
+    type: NodeType;
     constructor(leftChild: Node, rightChild: Node);
     toMathString(): string;
     toEquivalentNodes(): Node[];

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

@@ -1 +1 @@
-{"version":3,"file":"substractNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/substractNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AACzC,OAAO,EAAe,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3D,qBAAa,aAAc,SAAQ,YAAa,YAAW,IAAI;gBACjD,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI;IAG7C,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,IAAI,EAAE;IAY3B,cAAc,IAAI,MAAM,EAAE;IAG1B,KAAK,IAAI,MAAM;IAaf,QAAQ;CAGT"}
+{"version":3,"file":"substractNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/substractNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AACD,qBAAa,aAAc,YAAW,YAAY;IAChD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI;IAO7C,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,IAAI,EAAE;IAa3B,cAAc,IAAI,MAAM,EAAE;IAG1B,KAAK,IAAI,MAAM;IAef,QAAQ;CAGT"}

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

@@ -1,12 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubstractNode = void 0;
+exports.SubstractNode = exports.isSubstractNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const operatorNode_1 = require("./operatorNode");
-class SubstractNode extends operatorNode_1.OperatorNode {
+const oppositeNode_1 = require("../functions/oppositeNode");
+const addNode_1 = require("./addNode");
+function isSubstractNode(a) {
+    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.substract;
+}
+exports.isSubstractNode = isSubstractNode;
+class SubstractNode {
     constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, '-');
+        this.id = operatorNode_1.OperatorIds.substract;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.type = node_1.NodeType.operator;
     }
     toMathString() {
         return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
@@ -18,6 +27,7 @@ class SubstractNode extends operatorNode_1.OperatorNode {
         rightNodes.forEach((rightNode) => {
             leftNodes.forEach((leftNode) => {
                 res.push(new SubstractNode(leftNode, rightNode));
+                res.push(new addNode_1.AddNode(new oppositeNode_1.OppositeNode(rightNode), leftNode));
             });
         });
         return res;
@@ -28,9 +38,9 @@ class SubstractNode extends operatorNode_1.OperatorNode {
     toTex() {
         let rightTex = this.rightChild.toTex();
         let leftTex = this.leftChild.toTex();
-        const needBrackets = (this.rightChild.type === node_1.NodeType.operator &&
+        const needBrackets = ((0, operatorNode_1.isOperatorNode)(this.rightChild) &&
             [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
-            rightTex[0] === '-';
+            rightTex[0] === "-";
         if (needBrackets)
             rightTex = `(${rightTex})`;
         return `${leftTex}-${rightTex}`;

package/lib/tree/nodes/sets/belongsNode.d.ts

@@ -0,0 +1,15 @@
+import { Node, NodeOptions, NodeType } from "../node";
+import { SetNode } from "./setNode";
+export declare class BelongsNode implements Node {
+    type: NodeType;
+    opts?: NodeOptions | undefined;
+    leftChild: Node;
+    rightChild: SetNode;
+    constructor(leftChild: Node, rightChild: SetNode, opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): Node[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+//# sourceMappingURL=belongsNode.d.ts.map

package/lib/tree/nodes/sets/belongsNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"belongsNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/belongsNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,qBAAa,WAAY,YAAW,IAAI;IACtC,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;gBACR,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW;IAMpE,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,EAAE;IAc7C,YAAY;IAGZ,QAAQ;IAGR,KAAK;CAGN"}

package/lib/tree/nodes/sets/belongsNode.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsNode = void 0;
+const node_1 = require("../node");
+class BelongsNode {
+    constructor(leftChild, rightChild, opts) {
+        this.type = node_1.NodeType.belongs;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.opts = opts;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).map((node) => node.toTex());
+    }
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
+        const rightEquivs = this.rightChild.toEquivalentNodes(options);
+        if (options?.allowRawRightChildAsSolution)
+            return rightEquivs.flatMap((equiv) => [
+                new BelongsNode(this.leftChild, equiv, options),
+                equiv,
+            ]);
+        else
+            return rightEquivs.map((equiv) => new BelongsNode(this.leftChild, equiv, options));
+    }
+    toMathString() {
+        return this.toTex();
+    }
+    toMathjs() {
+        return this.toTex();
+    }
+    toTex() {
+        return `${this.leftChild.toTex()}\\in${this.rightChild.toTex()}`;
+    }
+}
+exports.BelongsNode = BelongsNode;

package/lib/tree/nodes/sets/discreteSetNode.d.ts

@@ -0,0 +1,15 @@
+import { Node, NodeOptions, NodeType } from "../node";
+import { SetNode } from "./setNode";
+export declare class DiscreteSetNode implements SetNode {
+    type: NodeType;
+    opts?: NodeOptions | undefined;
+    elements: Node[];
+    constructor(elements: Node[], opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): DiscreteSetNode[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+export declare const EmptySet: DiscreteSetNode;
+//# sourceMappingURL=discreteSetNode.d.ts.map

package/lib/tree/nodes/sets/discreteSetNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discreteSetNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/discreteSetNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,qBAAa,eAAgB,YAAW,OAAO;IAC7C,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,IAAI,EAAE,CAAC;gBACL,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAKhD,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAyBpC,YAAY;IAGZ,QAAQ;IAGR,KAAK;CAMN;AAED,eAAO,MAAM,QAAQ,iBAA0B,CAAC"}

package/lib/tree/nodes/sets/discreteSetNode.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptySet = exports.DiscreteSetNode = void 0;
+const cartesianProducts_1 = require("../../../utils/cartesianProducts");
+const permutations_1 = require("../../../utils/permutations");
+const node_1 = require("../node");
+class DiscreteSetNode {
+    constructor(elements, opts) {
+        this.type = node_1.NodeType.set;
+        this.elements = elements;
+        this.opts = opts;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).map((node) => node.toTex());
+    }
+    toEquivalentNodes(opts) {
+        if (this.elements.length === 0)
+            return [this];
+        if (this.elements.length === 1) {
+            return this.elements[0]
+                .toEquivalentNodes(opts ?? this.opts)
+                .map((node) => new DiscreteSetNode([node]));
+        }
+        //produits cartésiens
+        else {
+            const res = [];
+            const equivNodesArr = this.elements.map((node) => node.toEquivalentNodes(opts ?? this.opts));
+            //!pas opti car si [2,3,3] alors les 3 se permutent et donc double sortie [2,3_1,3_2], [2,3_2,3_1]
+            let equivNodesPermutations = (0, permutations_1.permute)(equivNodesArr);
+            equivNodesPermutations.forEach((permutation) => {
+                const cartesiansProducts = (0, cartesianProducts_1.getCartesiansProducts)(permutation);
+                cartesiansProducts.forEach((product) => {
+                    res.push(new DiscreteSetNode(product));
+                });
+            });
+            return res;
+        }
+    }
+    toMathString() {
+        return `{${this.elements.map((el) => el.toTex()).join(";")}}`;
+    }
+    toMathjs() {
+        return `{${this.elements.map((el) => el.toTex()).join(";")}}`;
+    }
+    toTex() {
+        if (!this.elements.length)
+            return `\\emptyset`;
+        return `\\left\\{${this.elements
+            .map((el) => el.toTex())
+            .join(";")}\\right\\}`;
+    }
+}
+exports.DiscreteSetNode = DiscreteSetNode;
+exports.EmptySet = new DiscreteSetNode([]);

package/lib/tree/nodes/sets/intervalNode.d.ts

@@ -0,0 +1,24 @@
+import { InequationNode } from "../inequations/inequationNode";
+import { Node, NodeOptions, NodeType } from "../node";
+import { SetNode } from "./setNode";
+export declare enum ClosureType {
+    FF = 0,
+    FO = 1,
+    OF = 2,
+    OO = 3
+}
+export declare class IntervalNode implements SetNode {
+    type: NodeType;
+    opts?: NodeOptions | undefined;
+    closure: ClosureType;
+    a: Node;
+    b: Node;
+    constructor(a: Node, b: Node, closure: ClosureType, opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): IntervalNode[];
+    toInequality(middleChild?: Node): InequationNode;
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+//# sourceMappingURL=intervalNode.d.ts.map

package/lib/tree/nodes/sets/intervalNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/intervalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGtD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AAED,qBAAa,YAAa,YAAW,OAAO;IAC1C,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW;IAQtE,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAoBpC,YAAY,CAAC,WAAW,CAAC,EAAE,IAAI;IA4B/B,YAAY;IAIZ,QAAQ;IAIR,KAAK;CAWN"}

package/lib/tree/nodes/sets/intervalNode.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntervalNode = exports.ClosureType = void 0;
+const cartesianProducts_1 = require("../../../utils/cartesianProducts");
+const inequationNode_1 = require("../inequations/inequationNode");
+const node_1 = require("../node");
+const constantNode_1 = require("../numbers/constantNode");
+const variableNode_1 = require("../variables/variableNode");
+var ClosureType;
+(function (ClosureType) {
+    ClosureType[ClosureType["FF"] = 0] = "FF";
+    ClosureType[ClosureType["FO"] = 1] = "FO";
+    ClosureType[ClosureType["OF"] = 2] = "OF";
+    ClosureType[ClosureType["OO"] = 3] = "OO";
+})(ClosureType = exports.ClosureType || (exports.ClosureType = {}));
+class IntervalNode {
+    constructor(a, b, closure, opts) {
+        this.type = node_1.NodeType.set;
+        this.closure = closure;
+        this.a = a;
+        this.b = b;
+        this.opts = opts;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).map((node) => node.toTex());
+    }
+    toEquivalentNodes(opts) {
+        const res = [];
+        const equivs = [
+            this.a.toEquivalentNodes(opts ?? this.opts),
+            this.b.toEquivalentNodes(opts ?? this.opts),
+        ];
+        const cartesians = (0, cartesianProducts_1.getCartesiansProducts)(equivs);
+        cartesians.forEach((product) => {
+            res.push(new IntervalNode(product[0], product[1], this.closure, opts ?? this.opts));
+        });
+        return res;
+    }
+    toInequality(middleChild) {
+        let middle = middleChild ?? new variableNode_1.VariableNode("x");
+        if ((0, constantNode_1.isConstantNode)(this.a) && this.a.tex.includes("infty")) {
+            return new inequationNode_1.InequationNode([middle, this.b], this.closure === ClosureType.OF ? "\\le" : "<");
+        }
+        if ((0, constantNode_1.isConstantNode)(this.b) && this.b.tex.includes("infty")) {
+            return new inequationNode_1.InequationNode([middle, this.a], this.closure === ClosureType.FO ? "\\ge" : ">");
+        }
+        const leftSymbol = this.closure === ClosureType.FO || this.closure === ClosureType.FF
+            ? "\\le"
+            : "<";
+        const rightSymbol = this.closure === ClosureType.FF || this.closure === ClosureType.OF
+            ? "\\le"
+            : "<";
+        return new inequationNode_1.InequationNode([this.a, middle, this.b], [leftSymbol, rightSymbol]);
+    }
+    toMathString() {
+        return this.toTex();
+    }
+    toMathjs() {
+        return this.toTex();
+    }
+    toTex() {
+        const left = this.closure === ClosureType.FF || this.closure === ClosureType.FO
+            ? "["
+            : "]";
+        const right = this.closure === ClosureType.FF || this.closure === ClosureType.OF
+            ? "]"
+            : "[";
+        return `${left}${this.a.toTex()};${this.b.toTex()}${right}`;
+    }
+}
+exports.IntervalNode = IntervalNode;

package/lib/tree/nodes/sets/setNode.d.ts

@@ -0,0 +1,4 @@
+import { Node } from "../node";
+export interface SetNode extends Node {
+}
+//# sourceMappingURL=setNode.d.ts.map

package/lib/tree/nodes/sets/setNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/setNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B,MAAM,WAAW,OAAQ,SAAQ,IAAI;CAAG"}

package/lib/tree/nodes/sets/setNode.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/tree/nodes/sets/unionIntervalNode.d.ts

@@ -0,0 +1,20 @@
+import { Node, NodeOptions, NodeType } from "../node";
+import { SetNode } from "./setNode";
+export declare enum ClosureType {
+    FF = 0,
+    FO = 1,
+    OF = 2,
+    OO = 3
+}
+export declare class UnionIntervalNode implements Node {
+    type: NodeType;
+    opts?: NodeOptions | undefined;
+    sets: SetNode[];
+    constructor(sets: SetNode[], opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): UnionIntervalNode[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+//# sourceMappingURL=unionIntervalNode.d.ts.map

package/lib/tree/nodes/sets/unionIntervalNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unionIntervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/unionIntervalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AAED,qBAAa,iBAAkB,YAAW,IAAI;IAC5C,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,OAAO,EAAE,CAAC;gBACJ,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAM/C,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAcpC,YAAY;IAIZ,QAAQ;IAIR,KAAK;CAGN"}

package/lib/tree/nodes/sets/unionIntervalNode.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionIntervalNode = exports.ClosureType = void 0;
+const cartesianProducts_1 = require("../../../utils/cartesianProducts");
+const permutations_1 = require("../../../utils/permutations");
+const node_1 = require("../node");
+var ClosureType;
+(function (ClosureType) {
+    ClosureType[ClosureType["FF"] = 0] = "FF";
+    ClosureType[ClosureType["FO"] = 1] = "FO";
+    ClosureType[ClosureType["OF"] = 2] = "OF";
+    ClosureType[ClosureType["OO"] = 3] = "OO";
+})(ClosureType = exports.ClosureType || (exports.ClosureType = {}));
+class UnionIntervalNode {
+    constructor(sets, opts) {
+        this.type = node_1.NodeType.set;
+        this.sets = sets;
+        this.opts = opts;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).map((node) => node.toTex());
+    }
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
+        const res = [];
+        const equivs = this.sets.map((s) => s.toEquivalentNodes(options));
+        const cartesians = (0, cartesianProducts_1.getCartesiansProducts)(equivs);
+        cartesians.forEach((product) => {
+            const permutations = (0, permutations_1.permute)(product);
+            permutations.forEach((permutation) => res.push(new UnionIntervalNode(permutation, options)));
+        });
+        return res;
+    }
+    toMathString() {
+        return this.toTex();
+    }
+    toMathjs() {
+        return this.toTex();
+    }
+    toTex() {
+        return this.sets.map((set) => set.toTex()).join("\\cup");
+    }
+}
+exports.UnionIntervalNode = UnionIntervalNode;

package/lib/tree/nodes/variables/variableNode.d.ts

@@ -1,4 +1,5 @@
-import { Node, NodeType } from '../node';
+import { Node, NodeType } from "../node";
+export declare function isVariableNode(a: Node): a is VariableNode;
 export declare class VariableNode implements Node {
     name: string;
     type: NodeType;

package/lib/tree/nodes/variables/variableNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variableNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/variables/variableNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzC,qBAAa,YAAa,YAAW,IAAI;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,WAAqB;gBAEb,IAAI,EAAE,MAAM;IAIxB,KAAK,IAAI,MAAM;IAGf,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,cAAc;IAGd,iBAAiB;CAMlB"}
+{"version":3,"file":"variableNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/variables/variableNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzC,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,IAAI;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,WAAqB;gBAEb,IAAI,EAAE,MAAM;IAIxB,KAAK,IAAI,MAAM;IAGf,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,cAAc;IAGd,iBAAiB;CAMlB"}

package/lib/tree/nodes/variables/variableNode.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VariableNode = void 0;
+exports.VariableNode = exports.isVariableNode = void 0;
 const node_1 = require("../node");
+function isVariableNode(a) {
+    return a.type === node_1.NodeType.variable;
+}
+exports.isVariableNode = isVariableNode;
 class VariableNode {
     constructor(name) {
         this.type = node_1.NodeType.variable;

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

@@ -1,4 +1,4 @@
-import { Node } from '../nodes/node';
+import { Node } from "../nodes/node";
 export declare const simplifyComplex: (node: Node) => Node;
 export declare const simplifyNode: (node: Node) => Node;
 //# sourceMappingURL=simplify.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"simplify.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/simplify.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AA0BrC,eAAO,MAAM,eAAe,SAAU,IAAI,KAAG,IAE5C,CAAC;AAMF,eAAO,MAAM,YAAY,SAAU,IAAI,KAAG,IAEzC,CAAC"}
+{"version":3,"file":"simplify.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/simplify.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AA0BrC,eAAO,MAAM,eAAe,SAAU,IAAI,KAAG,IAE5C,CAAC;AASF,eAAO,MAAM,YAAY,SAAU,IAAI,KAAG,IAIzC,CAAC"}

package/lib/tree/parsers/simplify.js

@@ -22,7 +22,7 @@ const simplifyComplex = (node) => {
 };
 exports.simplifyComplex = simplifyComplex;
 const mathjsComplexToNode = (complex) => {
-    return new complexNode_1.ComplexNode(complex.re, complex.im);
+    return new complexNode_1.ComplexNode(new numberNode_1.NumberNode(complex.re), new numberNode_1.NumberNode(complex.im));
 };
 const simplifyNode = (node) => {
     return mathjsNodeToNode((0, mathjs_1.simplify)(node.toMathString()));
@@ -30,7 +30,7 @@ const simplifyNode = (node) => {
 exports.simplifyNode = simplifyNode;
 const mathjsNodeToNode = (mathjsNode) => {
     if (mathjsNode.isSymbolNode) {
-        if (mathjsNode.name === 'pi')
+        if (mathjsNode.name === "pi")
             return piNode_1.PiNode;
         return new variableNode_1.VariableNode(mathjsNode.name);
     }
@@ -39,17 +39,17 @@ const mathjsNodeToNode = (mathjsNode) => {
     }
     else if (mathjsNode.isOperatorNode) {
         switch (mathjsNode.fn) {
-            case 'add':
+            case "add":
                 return new addNode_1.AddNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'subtract':
+            case "subtract":
                 return new substractNode_1.SubstractNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'unaryMinus':
+            case "unaryMinus":
                 return new oppositeNode_1.OppositeNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'divide':
+            case "divide":
                 return new fractionNode_1.FractionNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'multiply':
+            case "multiply":
                 return new multiplyNode_1.MultiplyNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'pow':
+            case "pow":
                 return new powerNode_1.PowerNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
         }
     }
@@ -57,20 +57,20 @@ const mathjsNodeToNode = (mathjsNode) => {
         const fn = mathjsNode.fn;
         switch (fn.name) {
             //mathjs arrondit les racines carrées, on truc avec sqr pour bypass
-            case 'sqr':
+            case "sqr":
                 return new sqrtNode_1.SqrtNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'sqrt':
+            case "sqrt":
                 return new sqrtNode_1.SqrtNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'log':
+            case "log":
                 return new logNode_1.LogNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'exp':
+            case "exp":
                 return new expNode_1.ExpNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'cos':
+            case "cos":
                 return new cosNode_1.CosNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'sin':
+            case "sin":
                 return new sinNode_1.SinNode(mathjsNodeToNode(mathjsNode.args[0]));
         }
     }
     console.log(mathjsNode);
-    throw Error('unrecognized mathjs node');
+    throw Error("unrecognized mathjs node");
 };

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

@@ -0,0 +1,5 @@
+import { Class } from '../../types/class';
+import { FunctionNode } from '../nodes/functions/functionNode';
+import { Node } from '../nodes/node';
+export declare const functionComposition: <T extends Class<FunctionNode>>(Compositor: T, arr: Node[]) => FunctionNode;
+//# sourceMappingURL=functionComposition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,eAAO,MAAM,mBAAmB,sDAAuD,IAAI,EAAE,iBAU5F,CAAC"}

package/lib/tree/utilities/functionComposition.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionComposition = void 0;
+const functionComposition = (Compositor, arr) => {
+    let res;
+    if (arr.length < 1)
+        throw Error(`received ${arr.length} nodes for operator composition`);
+    res = new Compositor(arr[0]);
+    for (let i = 1; i < arr.length; i++) {
+        res = new Compositor(res, arr[i]);
+    }
+    return res;
+};
+exports.functionComposition = functionComposition;

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

@@ -0,0 +1,5 @@
+import { Class } from "../../types/class";
+import { Node } from "../nodes/node";
+import { CommutativeOperatorNode } from "../nodes/operators/operatorNode";
+export declare const operatorComposition: <T extends Class<CommutativeOperatorNode>>(Compositor: T, arr: Node[]) => InstanceType<T>;
+//# sourceMappingURL=operatorComposition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operatorComposition.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/operatorComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACrC,OAAO,EACL,uBAAuB,EAExB,MAAM,iCAAiC,CAAC;AAEzC,eAAO,MAAM,mBAAmB,iEAEzB,IAAI,EAAE,oBAYZ,CAAC"}

package/lib/tree/utilities/operatorComposition.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operatorComposition = void 0;
+const operatorComposition = (Compositor, arr) => {
+    let res;
+    if (arr.length < 2)
+        throw Error(`received ${arr.length} nodes for operator composition`);
+    res = new Compositor(arr[0], arr[1]);
+    for (let i = 2; i < arr.length; i++) {
+        res = new Compositor(res, arr[i]);
+    }
+    return res;
+};
+exports.operatorComposition = operatorComposition;

package/lib/types/class.d.ts

@@ -0,0 +1,4 @@
+export interface Class<T> extends Function {
+    new (...args: any[]): T;
+}
+//# sourceMappingURL=class.d.ts.map

package/lib/types/class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class.d.ts","sourceRoot":"","sources":["../../src/types/class.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,KAAK,CAAC,CAAC,CAAE,SAAQ,QAAQ;IACxC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;CACzB"}

package/lib/types/class.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/cartesianProducts.d.ts

@@ -0,0 +1,13 @@
+/**
+ * exp [[1,2],[3],[4,5]] donnera [[1,3,4], [1,3,5], [2,3,4],[2,3,5]]
+ * @param arr
+ * @returns
+ */
+export declare function getCartesiansProducts<T>(arr: T[][]): T[][];
+/**
+ * exp [[1], [[5, 5], 6], [7, [8, 9]]]  -> [1,5,5,7] [1,5,5,8,9] [1,6,7] [1,6,8,9]
+ * @param arr
+ * @returns
+ */
+export declare function getFlatCartesianProducts<T>(arr: (T | T[])[][]): T[][];
+//# sourceMappingURL=cartesianProducts.d.ts.map

package/lib/utils/cartesianProducts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianProducts.d.ts","sourceRoot":"","sources":["../../src/utils/cartesianProducts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,SAkBlD;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,SA8B7D"}