math-exercises 1.3.4 → 1.3.5

package/lib/sets/intervals/intervals.js

@@ -18,35 +18,35 @@ class Interval {
     /**
      * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
      */
-    constructor(tex = "[-10; 10]") {
+    constructor(tex = '[-10; 10]') {
+        if (!tex.includes(';'))
+            throw Error('wrong interval format');
         this.tex = tex;
-        const isInt = tex[1] === "[" || tex[1] === "]";
+        const isInt = tex[1] === '[' || tex[1] === ']';
         this.type = isInt ? nombre_1.NumberType.Integer : nombre_1.NumberType.Real;
         const left = tex[0];
         const right = tex[tex.length - 1];
-        const [a, b] = tex
-            .slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1)
-            .split(";");
+        const [a, b] = tex.slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1).split(';');
         switch (`${left}a;b${right}`) {
-            case "[a;b]":
+            case '[a;b]':
                 this.boundType = BoundType.FF;
                 break;
-            case "]a;b[":
+            case ']a;b[':
                 this.boundType = BoundType.OO;
                 break;
-            case "[a;b[":
+            case '[a;b[':
                 this.boundType = BoundType.FO;
                 break;
-            case "]a;b]":
+            case ']a;b]':
                 this.boundType = BoundType.OF;
                 break;
             default:
-                throw console.error("wrong interval");
+                throw console.error('wrong interval format');
         }
         function getBound(bound) {
-            return bound === "-\\infty"
+            return bound === '-\\infty'
                 ? Number.NEGATIVE_INFINITY
-                : bound === "+\\infty"
+                : bound === '+\\infty'
                     ? Number.POSITIVE_INFINITY
                     : Number(bound);
         }
@@ -90,12 +90,8 @@ class Interval {
     getRandomElement(precision = this.type === nombre_1.NumberType.Integer ? 0 : 2) {
         if (this.min === -Infinity || this.max === Infinity)
             throw Error("Can't chose amongst infinity");
-        let min = this.boundType === BoundType.OO || this.boundType === BoundType.OF
-            ? this.min + epsilon_1.EPSILON
-            : this.min;
-        let max = this.boundType === BoundType.OO || this.boundType === BoundType.FO
-            ? this.max - epsilon_1.EPSILON
-            : this.max;
+        let min = this.boundType === BoundType.OO || this.boundType === BoundType.OF ? this.min + epsilon_1.EPSILON : this.min;
+        let max = this.boundType === BoundType.OO || this.boundType === BoundType.FO ? this.max - epsilon_1.EPSILON : this.max;
         const value = (0, round_1.round)(min + Math.random() * (max - this.min), precision);
         switch (this.type) {
             case nombre_1.NumberType.Integer:

package/lib/tree/nodes/functions/cosNode.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosNode = void 0;
+const node_1 = require("../node");
+const functionNode_1 = require("./functionNode");
+class CosNode extends functionNode_1.FunctionNode {
+    constructor(child) {
+        super(functionNode_1.FunctionsIds.cos, child, '\\cos');
+        this.type = node_1.NodeType.function;
+    }
+    toMathString() {
+        return `cos(${this.child.toMathString()})`;
+    }
+    toTex() {
+        return `\\cos\\left(${this.child.toTex()}\\right)`;
+    }
+    simplify() {
+        return this;
+    }
+}
+exports.CosNode = CosNode;

package/lib/tree/nodes/functions/functionNode.js

@@ -6,6 +6,8 @@ var FunctionsIds;
 (function (FunctionsIds) {
     FunctionsIds[FunctionsIds["opposite"] = 0] = "opposite";
     FunctionsIds[FunctionsIds["sqrt"] = 1] = "sqrt";
+    FunctionsIds[FunctionsIds["cos"] = 2] = "cos";
+    FunctionsIds[FunctionsIds["sin"] = 3] = "sin";
 })(FunctionsIds = exports.FunctionsIds || (exports.FunctionsIds = {}));
 class FunctionNode {
     constructor(id, child, tex) {

package/lib/tree/nodes/functions/oppositeNode.js

@@ -1,13 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OppositeNode = void 0;
+const node_1 = require("../node");
+const operatorNode_1 = require("../operators/operatorNode");
 const functionNode_1 = require("./functionNode");
 class OppositeNode extends functionNode_1.FunctionNode {
     constructor(child) {
-        super(functionNode_1.FunctionsIds.opposite, child, "-");
+        super(functionNode_1.FunctionsIds.opposite, child, '-');
     }
-    toString() {
-        return `-(${this.child})`;
+    toMathString() {
+        return `-(${this.child.toMathString()})`;
+    }
+    toTex() {
+        let childTex = this.child.toTex();
+        let needBrackets = childTex[0] === '-';
+        if (this.child.type === node_1.NodeType.operator) {
+            const operatorChild = this.child;
+            needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorChild.id));
+        }
+        if (needBrackets)
+            childTex = `(${childTex})`;
+        return `-${childTex}`;
     }
 }
 exports.OppositeNode = OppositeNode;

package/lib/tree/nodes/functions/sinNode.js

@@ -0,0 +1 @@
+"use strict";

package/lib/tree/nodes/functions/sqrtNode.js

@@ -5,11 +5,14 @@ const node_1 = require("../node");
 const functionNode_1 = require("./functionNode");
 class SqrtNode extends functionNode_1.FunctionNode {
     constructor(child) {
-        super(functionNode_1.FunctionsIds.sqrt, child, "\\sqrt");
+        super(functionNode_1.FunctionsIds.sqrt, child, '\\sqrt');
         this.type = node_1.NodeType.function;
     }
-    toString() {
-        return `sqrt(${this.child})`;
+    toMathString() {
+        return `sqrt(${this.child.toMathString()})`;
+    }
+    toTex() {
+        return `\\sqrt{${this.child.toTex()}}`;
     }
 }
 exports.SqrtNode = SqrtNode;

package/lib/tree/nodes/node.js

@@ -4,7 +4,8 @@ exports.NodeType = void 0;
 var NodeType;
 (function (NodeType) {
     NodeType[NodeType["number"] = 0] = "number";
-    NodeType[NodeType["variable"] = 1] = "variable";
-    NodeType[NodeType["operator"] = 2] = "operator";
-    NodeType[NodeType["function"] = 3] = "function";
+    NodeType[NodeType["constant"] = 1] = "constant";
+    NodeType[NodeType["variable"] = 2] = "variable";
+    NodeType[NodeType["operator"] = 3] = "operator";
+    NodeType[NodeType["function"] = 4] = "function";
 })(NodeType = exports.NodeType || (exports.NodeType = {}));

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantNode = void 0;
+const node_1 = require("../node");
+class ConstantNode {
+    constructor(tex, mathString) {
+        this.type = node_1.NodeType.constant;
+        this.tex = tex;
+        this.mathString = mathString;
+    }
+    toMathString() {
+        return `${this.mathString}`;
+    }
+    toTex() {
+        return `${this.tex}`;
+    }
+}
+exports.ConstantNode = ConstantNode;

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

@@ -3,12 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NumberNode = void 0;
 const node_1 = require("../node");
 class NumberNode {
-    constructor(value, tex) {
+    constructor(value, tex, mathString) {
         this.type = node_1.NodeType.number;
         this.value = value;
-        this.tex = tex || value + "";
+        this.tex = tex || value + '';
+        this.mathString = mathString || this.tex;
     }
-    toString() {
+    toMathString() {
+        return `${this.mathString ? this.mathString : this.tex}`;
+    }
+    toTex() {
         return `${this.tex}`;
     }
 }

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PiNode = void 0;
+const constantNode_1 = require("./constantNode");
+exports.PiNode = new constantNode_1.ConstantNode('\\pi', 'pi');

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

@@ -4,12 +4,16 @@ exports.AddNode = void 0;
 const operatorNode_1 = require("./operatorNode");
 class AddNode extends operatorNode_1.OperatorNode {
     constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.add, leftChild, rightChild, true, "+");
+        super(operatorNode_1.OperatorIds.add, leftChild, rightChild, true, '+');
         this.leftChild = leftChild;
         this.rightChild = rightChild;
     }
-    toString() {
-        return `${this.leftChild} + ${this.rightChild}`;
+    toMathString() {
+        return `${this.leftChild.toMathString()} + (${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        const rightTex = this.rightChild.toTex();
+        return `${this.leftChild.toTex()} ${rightTex[0] === '-' ? '' : '+ '}${rightTex}`;
     }
 }
 exports.AddNode = AddNode;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DivideNode = void 0;
+const node_1 = require("../node");
 const operatorNode_1 = require("./operatorNode");
 class DivideNode extends operatorNode_1.OperatorNode {
     /**
@@ -8,10 +9,26 @@ class DivideNode extends operatorNode_1.OperatorNode {
      * @param rightChild denum
      */
     constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.divide, leftChild, rightChild, false, "\\div");
+        super(operatorNode_1.OperatorIds.divide, leftChild, rightChild, false, '\\div');
     }
-    toString() {
-        return `(${this.leftChild}) \\div (${this.rightChild})`;
+    toMathString() {
+        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        if (this.leftChild.type === node_1.NodeType.operator) {
+            if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].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})`;
+        return `${leftTex} \\div ${rightTex}`;
     }
 }
 exports.DivideNode = DivideNode;

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

@@ -4,10 +4,13 @@ exports.EqualNode = void 0;
 const operatorNode_1 = require("./operatorNode");
 class EqualNode extends operatorNode_1.OperatorNode {
     constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.equal, leftChild, rightChild, true, "=");
+        super(operatorNode_1.OperatorIds.equal, leftChild, rightChild, true, '=');
     }
-    toString() {
-        return `${this.leftChild} = ${this.rightChild}`;
+    toMathString() {
+        return `${this.leftChild.toMathString()} = ${this.rightChild.toMathString()}`;
+    }
+    toTex() {
+        return `${this.leftChild.toTex()} = ${this.rightChild.toTex()}`;
     }
 }
 exports.EqualNode = EqualNode;

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

@@ -8,10 +8,13 @@ class FractionNode extends operatorNode_1.OperatorNode {
      * @param rightChild denum
      */
     constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.fraction, leftChild, rightChild, false, "\\frac");
+        super(operatorNode_1.OperatorIds.fraction, leftChild, rightChild, false, '\\frac');
     }
-    toString() {
-        return `\\frac{${this.leftChild}}{${this.rightChild}}`;
+    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.js

@@ -1,13 +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) {
-        super(operatorNode_1.OperatorIds.multiply, leftChild, rightChild, true, "\\times");
+        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');
     }
-    toString() {
-        return `(${this.leftChild})*(${this.rightChild})`;
+    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.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperatorNode = exports.OperatorIds = void 0;
-const coin_1 = require("../../../utils/coin");
+const coinFlip_1 = require("../../../utils/coinFlip");
 const node_1 = require("../node");
 var OperatorIds;
 (function (OperatorIds) {
@@ -25,11 +25,11 @@ class OperatorNode {
     /**shuffles in place */
     shuffle() {
         if (!this.isCommutative)
-            return this;
-        if ((0, coin_1.coin)())
-            return this;
+            return;
+        if ((0, coinFlip_1.coinFlip)())
+            return;
         [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
-        return this;
+        return;
     }
 }
 exports.OperatorNode = OperatorNode;

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

@@ -1,13 +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, "^");
+        super(operatorNode_1.OperatorIds.power, leftChild, rightChild, false, '^');
     }
-    toString() {
-        return `(${this.leftChild})^{${this.rightChild}}`;
+    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.js

@@ -1,13 +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, "-");
+        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, '-');
     }
-    toString() {
-        return `${this.leftChild}-(${this.rightChild})`;
+    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.js

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

package/lib/tree/parsers/derivateParser.js

@@ -1,60 +1,62 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.derivateParser = void 0;
-const node_1 = require("../nodes/node");
-const numberNode_1 = require("../nodes/numbers/numberNode");
-const powerNode_1 = require("../nodes/operators/powerNode");
-const addNode_1 = require("../nodes/operators/addNode");
-const fractionNode_1 = require("../nodes/operators/fractionNode");
-const multiplyNode_1 = require("../nodes/operators/multiplyNode");
-const operatorNode_1 = require("../nodes/operators/operatorNode");
-const substractNode_1 = require("../nodes/operators/substractNode");
-const functionNode_1 = require("../nodes/functions/functionNode");
-const sqrtNode_1 = require("../nodes/functions/sqrtNode");
-const oppositeNode_1 = require("../nodes/functions/oppositeNode");
-function derivateParser(node) {
-    if (!node)
-        throw Error("encountered a null node ??");
-    switch (node.type) {
-        case node_1.NodeType.variable:
-            return new numberNode_1.NumberNode(1);
-        case node_1.NodeType.number:
-            return new numberNode_1.NumberNode(0);
-        case node_1.NodeType.operator:
-            const operatorNode = node;
-            const u = operatorNode.leftChild;
-            const v = operatorNode.rightChild;
-            switch (operatorNode.id) {
-                case operatorNode_1.OperatorIds.add:
-                    return new addNode_1.AddNode(derivateParser(u), derivateParser(v));
-                case operatorNode_1.OperatorIds.substract: {
-                    return new substractNode_1.SubstractNode(derivateParser(u), derivateParser(v));
-                }
-                case operatorNode_1.OperatorIds.multiply: {
-                    return new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(derivateParser(u), v), new multiplyNode_1.MultiplyNode(u, derivateParser(v)));
-                }
-                case operatorNode_1.OperatorIds.divide:
-                case operatorNode_1.OperatorIds.fraction:
-                    return new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(derivateParser(u), v), new multiplyNode_1.MultiplyNode(u, derivateParser(v))), new powerNode_1.PowerNode(v, new numberNode_1.NumberNode(2)));
-                case operatorNode_1.OperatorIds.power: {
-                    const operatorNode = node;
-                    const n = operatorNode.rightChild;
-                    const u = operatorNode.leftChild;
-                    return new multiplyNode_1.MultiplyNode(n, new multiplyNode_1.MultiplyNode(derivateParser(u), new powerNode_1.PowerNode(u, new numberNode_1.NumberNode(n.value - 1))));
-                }
-            }
-        case node_1.NodeType.function: {
-            const functionNode = node;
-            const child = functionNode.child;
-            switch (functionNode.id) {
-                case functionNode_1.FunctionsIds.sqrt: {
-                    return new fractionNode_1.FractionNode(derivateParser(child), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), new sqrtNode_1.SqrtNode(child)));
-                }
-                case functionNode_1.FunctionsIds.opposite: {
-                    return new oppositeNode_1.OppositeNode(derivateParser(child));
-                }
-            }
-        }
-    }
-}
-exports.derivateParser = derivateParser;
+// 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));
+//         }
+//       }
+//     }
+//   }
+// }