math-exercises 1.3.11 → 1.3.13

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

@@ -1,12 +1,12 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class FractionNode extends OperatorNode implements Node {
-    /**
-     * @param leftChild num
-     * @param rightChild denum
-     */
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class FractionNode extends OperatorNode implements Node {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+}
 //# sourceMappingURL=fractionNode.d.ts.map

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

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FractionNode = void 0;
-const operatorNode_1 = require("./operatorNode");
-class FractionNode extends operatorNode_1.OperatorNode {
-    /**
-     * @param leftChild num
-     * @param rightChild denum
-     */
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.fraction, leftChild, rightChild, false, '\\frac');
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        return `\\frac{${this.leftChild.toTex()}}{${this.rightChild.toTex()}}`;
-    }
-}
-exports.FractionNode = FractionNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FractionNode = void 0;
+const operatorNode_1 = require("./operatorNode");
+class FractionNode extends operatorNode_1.OperatorNode {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.fraction, leftChild, rightChild, false, '\\frac');
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        return `\\frac{${this.leftChild.toTex()}}{${this.rightChild.toTex()}}`;
+    }
+}
+exports.FractionNode = FractionNode;

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

@@ -1,8 +1,8 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class MultiplyNode extends OperatorNode implements Node {
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class MultiplyNode extends OperatorNode implements Node {
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+}
 //# sourceMappingURL=multiplyNode.d.ts.map

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

@@ -1,43 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiplyNode = void 0;
-const functionNode_1 = require("../functions/functionNode");
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-class MultiplyNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild) {
-        let [left, right] = [leftChild, rightChild];
-        const shouldSwitch = (rightChild.type === node_1.NodeType.function && rightChild.id === functionNode_1.FunctionsIds.opposite) ||
-            (leftChild.type === node_1.NodeType.constant && rightChild.type === node_1.NodeType.number);
-        if (shouldSwitch) {
-            [left, right] = [rightChild, leftChild];
-        }
-        super(operatorNode_1.OperatorIds.multiply, left, right, true, '\\times');
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()})*(${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        let leftTex = this.leftChild.toTex();
-        let rightTex = this.rightChild.toTex();
-        if (this.leftChild.type === node_1.NodeType.operator) {
-            if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(this.leftChild.id))
-                leftTex = `(${leftTex})`;
-        }
-        let needBrackets = rightTex[0] === '-';
-        if (this.rightChild.type === node_1.NodeType.operator) {
-            const operatorRightChild = this.rightChild;
-            needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
-        }
-        if (needBrackets)
-            rightTex = `(${rightTex})`;
-        //  permet de gérer le cas 3*2^x par ex
-        let showTimesSign = !isNaN(+rightTex[0]) || this.rightChild.type === node_1.NodeType.number;
-        if (this.rightChild.type === node_1.NodeType.operator) {
-            const operatorRightChild = this.rightChild;
-            showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
-        }
-        return `${leftTex}${showTimesSign ? '\\times ' : ''}${rightTex}`;
-    }
-}
-exports.MultiplyNode = MultiplyNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiplyNode = void 0;
+const functionNode_1 = require("../functions/functionNode");
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+class MultiplyNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        let [left, right] = [leftChild, rightChild];
+        const shouldSwitch = (rightChild.type === node_1.NodeType.function && rightChild.id === functionNode_1.FunctionsIds.opposite) ||
+            (leftChild.type === node_1.NodeType.constant && rightChild.type === node_1.NodeType.number);
+        if (shouldSwitch) {
+            [left, right] = [rightChild, leftChild];
+        }
+        super(operatorNode_1.OperatorIds.multiply, left, right, true, '\\times');
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()})*(${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let leftTex = this.leftChild.toTex();
+        let rightTex = this.rightChild.toTex();
+        if (this.leftChild.type === node_1.NodeType.operator) {
+            if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(this.leftChild.id))
+                leftTex = `(${leftTex})`;
+        }
+        let needBrackets = rightTex[0] === '-';
+        if (this.rightChild.type === node_1.NodeType.operator) {
+            const operatorRightChild = this.rightChild;
+            needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
+        }
+        if (needBrackets)
+            rightTex = `(${rightTex})`;
+        //  permet de gérer le cas 3*2^x par ex
+        let showTimesSign = !isNaN(+rightTex[0]) || this.rightChild.type === node_1.NodeType.number;
+        if (this.rightChild.type === node_1.NodeType.operator) {
+            const operatorRightChild = this.rightChild;
+            showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
+        }
+        return `${leftTex}${showTimesSign ? '\\times ' : ''}${rightTex}`;
+    }
+}
+exports.MultiplyNode = MultiplyNode;

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

@@ -1,22 +1,22 @@
-import { Node, NodeType } from '../node';
-export declare enum OperatorIds {
-    add = 0,
-    substract = 1,
-    multiply = 2,
-    fraction = 3,
-    divide = 4,
-    power = 5,
-    equal = 6
-}
-export declare abstract class OperatorNode {
-    id: OperatorIds;
-    leftChild: Node;
-    rightChild: Node;
-    isCommutative: boolean;
-    type: NodeType;
-    tex: string;
-    constructor(id: OperatorIds, leftChild: Node, rightChild: Node, isCommutative: boolean, tex: string);
-    /**shuffles in place */
-    shuffle(): void;
-}
+import { Node, NodeType } from '../node';
+export declare enum OperatorIds {
+    add = 0,
+    substract = 1,
+    multiply = 2,
+    fraction = 3,
+    divide = 4,
+    power = 5,
+    equal = 6
+}
+export declare abstract class OperatorNode {
+    id: OperatorIds;
+    leftChild: Node;
+    rightChild: Node;
+    isCommutative: boolean;
+    type: NodeType;
+    tex: string;
+    constructor(id: OperatorIds, leftChild: Node, rightChild: Node, isCommutative: boolean, tex: string);
+    /**shuffles in place */
+    shuffle(): void;
+}
 //# sourceMappingURL=operatorNode.d.ts.map

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

@@ -1,35 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperatorNode = exports.OperatorIds = void 0;
-const coinFlip_1 = require("../../../utils/coinFlip");
-const node_1 = require("../node");
-var OperatorIds;
-(function (OperatorIds) {
-    OperatorIds[OperatorIds["add"] = 0] = "add";
-    OperatorIds[OperatorIds["substract"] = 1] = "substract";
-    OperatorIds[OperatorIds["multiply"] = 2] = "multiply";
-    OperatorIds[OperatorIds["fraction"] = 3] = "fraction";
-    OperatorIds[OperatorIds["divide"] = 4] = "divide";
-    OperatorIds[OperatorIds["power"] = 5] = "power";
-    OperatorIds[OperatorIds["equal"] = 6] = "equal";
-})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
-class OperatorNode {
-    constructor(id, leftChild, rightChild, isCommutative, tex) {
-        this.type = node_1.NodeType.operator;
-        this.id = id;
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-        this.isCommutative = isCommutative;
-        this.tex = tex;
-    }
-    /**shuffles in place */
-    shuffle() {
-        if (!this.isCommutative)
-            return;
-        if ((0, coinFlip_1.coinFlip)())
-            return;
-        [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
-        return;
-    }
-}
-exports.OperatorNode = OperatorNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorNode = exports.OperatorIds = void 0;
+const coinFlip_1 = require("../../../utils/coinFlip");
+const node_1 = require("../node");
+var OperatorIds;
+(function (OperatorIds) {
+    OperatorIds[OperatorIds["add"] = 0] = "add";
+    OperatorIds[OperatorIds["substract"] = 1] = "substract";
+    OperatorIds[OperatorIds["multiply"] = 2] = "multiply";
+    OperatorIds[OperatorIds["fraction"] = 3] = "fraction";
+    OperatorIds[OperatorIds["divide"] = 4] = "divide";
+    OperatorIds[OperatorIds["power"] = 5] = "power";
+    OperatorIds[OperatorIds["equal"] = 6] = "equal";
+})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
+class OperatorNode {
+    constructor(id, leftChild, rightChild, isCommutative, tex) {
+        this.type = node_1.NodeType.operator;
+        this.id = id;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.isCommutative = isCommutative;
+        this.tex = tex;
+    }
+    /**shuffles in place */
+    shuffle() {
+        if (!this.isCommutative)
+            return;
+        if ((0, coinFlip_1.coinFlip)())
+            return;
+        [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+        return;
+    }
+}
+exports.OperatorNode = OperatorNode;

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

@@ -1,8 +1,8 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class PowerNode extends OperatorNode implements Node {
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class PowerNode extends OperatorNode implements Node {
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+}
 //# sourceMappingURL=powerNode.d.ts.map

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

@@ -1,33 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PowerNode = void 0;
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-class PowerNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.power, leftChild, rightChild, false, '^');
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()})^(${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        let needBrackets = leftTex[0] === '-';
-        if (this.leftChild.type === node_1.NodeType.operator) {
-            const childOperator = this.leftChild;
-            needBrackets || (needBrackets = [
-                operatorNode_1.OperatorIds.add,
-                operatorNode_1.OperatorIds.substract,
-                operatorNode_1.OperatorIds.multiply,
-                operatorNode_1.OperatorIds.divide,
-                operatorNode_1.OperatorIds.fraction,
-                operatorNode_1.OperatorIds.power,
-            ].includes(childOperator.id));
-        }
-        if (needBrackets)
-            leftTex = `(${leftTex})`;
-        return `${leftTex}^{${rightTex}}`;
-    }
-}
-exports.PowerNode = PowerNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerNode = void 0;
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+class PowerNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.power, leftChild, rightChild, false, '^');
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()})^(${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        let needBrackets = leftTex[0] === '-';
+        if (this.leftChild.type === node_1.NodeType.operator) {
+            const childOperator = this.leftChild;
+            needBrackets || (needBrackets = [
+                operatorNode_1.OperatorIds.add,
+                operatorNode_1.OperatorIds.substract,
+                operatorNode_1.OperatorIds.multiply,
+                operatorNode_1.OperatorIds.divide,
+                operatorNode_1.OperatorIds.fraction,
+                operatorNode_1.OperatorIds.power,
+            ].includes(childOperator.id));
+        }
+        if (needBrackets)
+            leftTex = `(${leftTex})`;
+        return `${leftTex}^{${rightTex}}`;
+    }
+}
+exports.PowerNode = PowerNode;

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

@@ -1,8 +1,8 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class SubstractNode extends OperatorNode implements Node {
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class SubstractNode extends OperatorNode implements Node {
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+}
 //# sourceMappingURL=substractNode.d.ts.map

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

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubstractNode = void 0;
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-class SubstractNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, '-');
-    }
-    toMathString() {
-        return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        const needBrackets = (this.rightChild.type === node_1.NodeType.operator &&
-            [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
-            rightTex[0] === '-';
-        if (needBrackets)
-            rightTex = `(${rightTex})`;
-        return `${leftTex} - ${rightTex}`;
-    }
-}
-exports.SubstractNode = SubstractNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstractNode = void 0;
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+class SubstractNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, '-');
+    }
+    toMathString() {
+        return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        const needBrackets = (this.rightChild.type === node_1.NodeType.operator &&
+            [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
+            rightTex[0] === '-';
+        if (needBrackets)
+            rightTex = `(${rightTex})`;
+        return `${leftTex} - ${rightTex}`;
+    }
+}
+exports.SubstractNode = SubstractNode;

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

@@ -1,9 +1,9 @@
-import { Node, NodeType } from '../node';
-export declare class VariableNode implements Node {
-    name: string;
-    type: NodeType;
-    constructor(name: string);
-    toTex(): string;
-    toMathString(): string;
-}
+import { Node, NodeType } from '../node';
+export declare class VariableNode implements Node {
+    name: string;
+    type: NodeType;
+    constructor(name: string);
+    toTex(): string;
+    toMathString(): string;
+}
 //# sourceMappingURL=variableNode.d.ts.map

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

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VariableNode = void 0;
-const node_1 = require("../node");
-class VariableNode {
-    constructor(name) {
-        this.type = node_1.NodeType.variable;
-        if (name.length !== 1 || !name.match('[a-zA-Z]'))
-            throw Error('variable must be a letter');
-        this.name = name;
-    }
-    toTex() {
-        return `${this.name}`;
-    }
-    toMathString() {
-        return `${this.name}`;
-    }
-}
-exports.VariableNode = VariableNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableNode = void 0;
+const node_1 = require("../node");
+class VariableNode {
+    constructor(name) {
+        this.type = node_1.NodeType.variable;
+        if (name.length !== 1 || !name.match('[a-zA-Z]'))
+            throw Error('variable must be a letter');
+        this.name = name;
+    }
+    toTex() {
+        return `${this.name}`;
+    }
+    toMathString() {
+        return `${this.name}`;
+    }
+}
+exports.VariableNode = VariableNode;

package/lib/tree/parsers/derivateParser.js

@@ -1,62 +1,62 @@
-"use strict";
-// import { Node, NodeType } from "../nodes/node";
-// import { NumberNode } from "../nodes/numbers/numberNode";
-// import { PowerNode } from "../nodes/operators/powerNode";
-// import { AddNode } from "../nodes/operators/addNode";
-// import { FractionNode } from "../nodes/operators/fractionNode";
-// import { MultiplyNode } from "../nodes/operators/multiplyNode";
-// import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
-// import { SubstractNode } from "../nodes/operators/substractNode";
-// import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
-// import { SqrtNode } from "../nodes/functions/sqrtNode";
-// import { OppositeNode } from "../nodes/functions/oppositeNode";
-// export function derivateParser(node: Node): Node {
-//   if (!node) throw Error("encountered a null node ??");
-//   switch (node.type) {
-//     case NodeType.variable:
-//       return new NumberNode(1);
-//     case NodeType.number:
-//       return new NumberNode(0);
-//     case NodeType.operator:
-//       const operatorNode = node as OperatorNode;
-//       const u = operatorNode.leftChild;
-//       const v = operatorNode.rightChild;
-//       switch (operatorNode.id) {
-//         case OperatorIds.add:
-//           return new AddNode(derivateParser(u), derivateParser(v));
-//         case OperatorIds.substract: {
-//           return new SubstractNode(derivateParser(u), derivateParser(v));
-//         }
-//         case OperatorIds.multiply: {
-//           return new AddNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v)));
-//         }
-//         case OperatorIds.divide:
-//         case OperatorIds.fraction:
-//           return new FractionNode(
-//             new SubstractNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v))),
-//             new PowerNode(v, new NumberNode(2))
-//           );
-//         case OperatorIds.power: {
-//           const operatorNode = node as OperatorNode;
-//           const n = operatorNode.rightChild as NumberNode;
-//           const u = operatorNode.leftChild;
-//           return new MultiplyNode(
-//             n,
-//             new MultiplyNode(derivateParser(u), new PowerNode(u, new NumberNode(n.value - 1)))
-//           );
-//         }
-//       }
-//     case NodeType.function: {
-//       const functionNode = node as FunctionNode;
-//       const child = functionNode.child;
-//       switch (functionNode.id) {
-//         case FunctionsIds.sqrt: {
-//           return new FractionNode(derivateParser(child), new MultiplyNode(new NumberNode(2), new SqrtNode(child)));
-//         }
-//         case FunctionsIds.opposite: {
-//           return new OppositeNode(derivateParser(child));
-//         }
-//       }
-//     }
-//   }
-// }
+"use strict";
+// import { Node, NodeType } from "../nodes/node";
+// import { NumberNode } from "../nodes/numbers/numberNode";
+// import { PowerNode } from "../nodes/operators/powerNode";
+// import { AddNode } from "../nodes/operators/addNode";
+// import { FractionNode } from "../nodes/operators/fractionNode";
+// import { MultiplyNode } from "../nodes/operators/multiplyNode";
+// import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
+// import { SubstractNode } from "../nodes/operators/substractNode";
+// import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
+// import { SqrtNode } from "../nodes/functions/sqrtNode";
+// import { OppositeNode } from "../nodes/functions/oppositeNode";
+// export function derivateParser(node: Node): Node {
+//   if (!node) throw Error("encountered a null node ??");
+//   switch (node.type) {
+//     case NodeType.variable:
+//       return new NumberNode(1);
+//     case NodeType.number:
+//       return new NumberNode(0);
+//     case NodeType.operator:
+//       const operatorNode = node as OperatorNode;
+//       const u = operatorNode.leftChild;
+//       const v = operatorNode.rightChild;
+//       switch (operatorNode.id) {
+//         case OperatorIds.add:
+//           return new AddNode(derivateParser(u), derivateParser(v));
+//         case OperatorIds.substract: {
+//           return new SubstractNode(derivateParser(u), derivateParser(v));
+//         }
+//         case OperatorIds.multiply: {
+//           return new AddNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v)));
+//         }
+//         case OperatorIds.divide:
+//         case OperatorIds.fraction:
+//           return new FractionNode(
+//             new SubstractNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v))),
+//             new PowerNode(v, new NumberNode(2))
+//           );
+//         case OperatorIds.power: {
+//           const operatorNode = node as OperatorNode;
+//           const n = operatorNode.rightChild as NumberNode;
+//           const u = operatorNode.leftChild;
+//           return new MultiplyNode(
+//             n,
+//             new MultiplyNode(derivateParser(u), new PowerNode(u, new NumberNode(n.value - 1)))
+//           );
+//         }
+//       }
+//     case NodeType.function: {
+//       const functionNode = node as FunctionNode;
+//       const child = functionNode.child;
+//       switch (functionNode.id) {
+//         case FunctionsIds.sqrt: {
+//           return new FractionNode(derivateParser(child), new MultiplyNode(new NumberNode(2), new SqrtNode(child)));
+//         }
+//         case FunctionsIds.opposite: {
+//           return new OppositeNode(derivateParser(child));
+//         }
+//       }
+//     }
+//   }
+// }