math-exercises 1.3.2 → 1.3.3

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

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqrtNode = void 0;
-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');
-        this.type = node_1.NodeType.function;
-    }
-    toMathString() {
-        return `sqrt(${this.child.toMathString()})`;
-    }
-    toTex() {
-        return `\\sqrt{${this.child.toTex()}}`;
-    }
-}
-exports.SqrtNode = SqrtNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqrtNode = void 0;
+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");
+        this.type = node_1.NodeType.function;
+    }
+    toString() {
+        return `sqrt(${this.child})`;
+    }
+}
+exports.SqrtNode = SqrtNode;

package/lib/tree/nodes/node.js

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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 = exports.NodeType || (exports.NodeType = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = exports.NodeType || (exports.NodeType = {}));

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

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

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

@@ -1,19 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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, '+');
-        this.leftChild = leftChild;
-        this.rightChild = 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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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, "+");
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+    }
+    toString() {
+        return `${this.leftChild} + ${this.rightChild}`;
+    }
+}
+exports.AddNode = AddNode;

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

@@ -1,34 +1,17 @@
-"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 {
-    /**
-     * @param leftChild num
-     * @param rightChild denum
-     */
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.divide, leftChild, rightChild, false, '\\div');
-    }
-    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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DivideNode = void 0;
+const operatorNode_1 = require("./operatorNode");
+class DivideNode extends operatorNode_1.OperatorNode {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.divide, leftChild, rightChild, false, "\\div");
+    }
+    toString() {
+        return `(${this.leftChild}) \\div (${this.rightChild})`;
+    }
+}
+exports.DivideNode = DivideNode;

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

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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, '=');
-    }
-    toMathString() {
-        return `${this.leftChild.toMathString()} = ${this.rightChild.toMathString()}`;
-    }
-    toTex() {
-        return `${this.leftChild.toTex()} = ${this.rightChild.toTex()}`;
-    }
-}
-exports.EqualNode = EqualNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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, "=");
+    }
+    toString() {
+        return `${this.leftChild} = ${this.rightChild}`;
+    }
+}
+exports.EqualNode = EqualNode;

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

@@ -1,20 +1,17 @@
-"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");
+    }
+    toString() {
+        return `\\frac{${this.leftChild}}{${this.rightChild}}`;
+    }
+}
+exports.FractionNode = FractionNode;

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

@@ -1,36 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiplyNode = void 0;
-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');
-    }
-    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 operatorNode_1 = require("./operatorNode");
+class MultiplyNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.multiply, leftChild, rightChild, true, "\\times");
+    }
+    toString() {
+        return `(${this.leftChild})*(${this.rightChild})`;
+    }
+}
+exports.MultiplyNode = MultiplyNode;

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 coin_1 = require("../../../utils/coin");
-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, coin_1.coin)())
-            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 coin_1 = require("../../../utils/coin");
+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 this;
+        if ((0, coin_1.coin)())
+            return this;
+        [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+        return this;
+    }
+}
+exports.OperatorNode = OperatorNode;

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

@@ -1,33 +1,13 @@
-"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 operatorNode_1 = require("./operatorNode");
+class PowerNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.power, leftChild, rightChild, false, "^");
+    }
+    toString() {
+        return `(${this.leftChild})^{${this.rightChild}}`;
+    }
+}
+exports.PowerNode = PowerNode;

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

@@ -1,24 +1,13 @@
-"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 operatorNode_1 = require("./operatorNode");
+class SubstractNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, "-");
+    }
+    toString() {
+        return `${this.leftChild}-(${this.rightChild})`;
+    }
+}
+exports.SubstractNode = SubstractNode;

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

@@ -1,19 +1,16 @@
-"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(tex) {
+        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;
+    }
+    toString() {
+        return `${this.tex}`;
+    }
+}
+exports.VariableNode = VariableNode;

package/lib/tree/parsers/derivateParser.js

@@ -1,62 +1,60 @@
-"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";
+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;