math-exercises 1.2.10 → 1.3.0

package/lib/exercises/powers/scientificToDecimal.js

@@ -4,7 +4,6 @@ exports.getScientificToDecimalQuestion = exports.scientificToDecimal = void 0;
 const randint_1 = require("../../mathutils/random/randint");
 const decimal_1 = require("../../numbers/decimals/decimal");
 const integer_1 = require("../../numbers/integer/integer");
-const latexParser_1 = require("../../tree/parsers/latexParser");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const powerNode_1 = require("../../tree/nodes/operators/powerNode");
@@ -13,12 +12,12 @@ const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
  * a*10^x vers décimal
  *  */
 exports.scientificToDecimal = {
-    id: "scientificToDecimal",
-    connector: "=",
+    id: 'scientificToDecimal',
+    connector: '=',
     instruction: "Donner l'écriture décimale de :",
-    label: "Ecriture décimale de $a\\times 10^x$",
-    levels: ["5", "4", "3", "2"],
-    section: "Puissances",
+    label: 'Ecriture décimale de $a\\times 10^x$',
+    levels: ['5', '4', '3', '2'],
+    section: 'Puissances',
     isSingleStep: true,
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getScientificToDecimalQuestion, nb),
 };
@@ -26,12 +25,12 @@ function getScientificToDecimalQuestion() {
     const randPower = (0, randint_1.randint)(-6, 8);
     const int = integer_1.IntegerConstructor.random((0, randint_1.randint)(1, 4));
     const fracPart = decimal_1.DecimalConstructor.randomFracPart((0, randint_1.randint)(0, 4));
-    const randDecimal = decimal_1.DecimalConstructor.fromParts(int + "", fracPart);
+    const randDecimal = decimal_1.DecimalConstructor.fromParts(int + '', fracPart);
     const statement = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(randDecimal.value), new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(randPower)));
     const answerTree = randDecimal.multiplyByPowerOfTen(randPower).toTree();
     const question = {
-        startStatement: (0, latexParser_1.latexParser)(statement),
-        answer: (0, latexParser_1.latexParser)(answerTree),
+        startStatement: statement.toTex(),
+        answer: answerTree.toTex(),
     };
     return question;
 }

package/lib/exercises/squareRoots/simpifySquareRoot.js

@@ -2,16 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSimplifySquareRoot = exports.simplifySquareRoot = void 0;
 const squareRoot_1 = require("../../numbers/reals/squareRoot");
-const latexParser_1 = require("../../tree/parsers/latexParser");
 const getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
 exports.simplifySquareRoot = {
-    id: "simplifySqrt",
-    connector: "=",
-    instruction: "Simplifier :",
-    label: "Simplification de racines carrées",
-    levels: ["3", "2", "1"],
+    id: 'simplifySqrt',
+    connector: '=',
+    instruction: 'Simplifier :',
+    label: 'Simplification de racines carrées',
+    levels: ['3', '2', '1'],
     isSingleStep: false,
-    section: "Racines carrées",
+    section: 'Racines carrées',
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSimplifySquareRoot, nb),
 };
 function getSimplifySquareRoot() {
@@ -20,8 +19,8 @@ function getSimplifySquareRoot() {
         maxSquare: 11,
     });
     const question = {
-        startStatement: (0, latexParser_1.latexParser)(squareRoot.toTree()),
-        answer: (0, latexParser_1.latexParser)(squareRoot.simplify().toTree()),
+        startStatement: squareRoot.toTree().toTex(),
+        answer: squareRoot.simplify().toTree().toTex(),
     };
     return question;
 }

package/lib/exercises/utils/getDistinctQuestions.js

@@ -7,8 +7,7 @@ const getDistinctQuestions = (generator, nb) => {
         let question;
         do {
             question = generator();
-        } while (res.some((q) => q.instruction ? q.instruction === question.instruction :
-            q.startStatement === question.startStatement));
+        } while (res.some((q) => q.instruction === question.instruction && q.startStatement === question.startStatement));
         res.push(question);
     }
     return res;

package/lib/geometry/point.js

@@ -4,7 +4,7 @@ exports.Point = exports.PointConstructor = void 0;
 const numberNode_1 = require("../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../tree/nodes/operators/addNode");
 const fractionNode_1 = require("../tree/nodes/operators/fractionNode");
-const latexParser_1 = require("../tree/parsers/latexParser");
+const simplify_1 = require("../tree/parsers/simplify");
 class PointConstructor {
 }
 exports.PointConstructor = PointConstructor;
@@ -18,10 +18,10 @@ class Point {
         return `${this.name}`;
     }
     toTexWithCoords() {
-        return `${this.name}\\left(${(0, latexParser_1.latexParser)(this.x)}; ${(0, latexParser_1.latexParser)(this.y)}\\right)`;
+        return `${this.name}\\left(${this.x.toTex()}; ${this.y.toTex()}\\right)`;
     }
-    midpoint(B, name = "I") {
-        return new Point(name, new fractionNode_1.FractionNode(new addNode_1.AddNode(this.x, B.x), new numberNode_1.NumberNode(2)), new fractionNode_1.FractionNode(new addNode_1.AddNode(this.y, B.y), new numberNode_1.NumberNode(2)));
+    midpoint(B, name = 'I') {
+        return new Point(name, (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new addNode_1.AddNode(this.x, B.x), new numberNode_1.NumberNode(2))), (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new addNode_1.AddNode(this.y, B.y), new numberNode_1.NumberNode(2))));
     }
 }
 exports.Point = Point;

package/lib/geometry/vector.js

@@ -4,7 +4,7 @@ exports.Vector = exports.VectorConstructor = void 0;
 const addNode_1 = require("../tree/nodes/operators/addNode");
 const multiplyNode_1 = require("../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../tree/nodes/operators/substractNode");
-const latexParser_1 = require("../tree/parsers/latexParser");
+const simplify_1 = require("../tree/parsers/simplify");
 class VectorConstructor {
     static fromPoints(origin, end) {
         return new Vector(`${origin.name}${end.name}`, new substractNode_1.SubstractNode(end.x, origin.x), new substractNode_1.SubstractNode(end.y, origin.y));
@@ -22,10 +22,10 @@ class Vector {
         return `\\overrightarrow{${this.name}}`;
     }
     toTexWithCoords() {
-        return `\\overrightarrow{${this.name}}\\begin{pmatrix}${(0, latexParser_1.latexParser)(this.x)} \\${(0, latexParser_1.latexParser)(this.y)} \\end{pmatrix}`;
+        return `\\overrightarrow{${this.name}}\\begin{pmatrix}${this.x.toTex()} \\\\ ${this.y.toTex()} \\end{pmatrix}`;
     }
     scalarProduct(v) {
-        return new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.x, v.x), new multiplyNode_1.MultiplyNode(this.y, v.y));
+        return (0, simplify_1.simplifyNode)(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.x, v.x), new multiplyNode_1.MultiplyNode(this.y, v.y)));
     }
 }
 exports.Vector = Vector;

package/lib/index.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.exercises = void 0;
 const exercises_1 = require("./exercises/exercises");
 Object.defineProperty(exports, "exercises", { enumerable: true, get: function () { return exercises_1.exercises; } });
-const scalarProductViaCoords_1 = require("./exercises/geometry/vectors/scalarProductViaCoords");
-// exercises.forEach((exo) => {
-//   console.log(exo.instruction, exo.generator(10));
-// });
-console.log(scalarProductViaCoords_1.scalarProductViaCoords.generator(10));
+// import { simplify } from './tree/parsers/simplify';
+exercises_1.exercises.forEach((exo) => {
+    console.log(exo.instruction, exo.generator(10));
+});

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/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/numbers/numberNode.js

@@ -8,7 +8,7 @@ class NumberNode {
         this.value = value;
         this.tex = tex || value + '';
     }
-    toString() {
+    toMathString() {
         return `${this.tex}`;
     }
     toTex() {

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,36 @@
 "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");
+        super(operatorNode_1.OperatorIds.multiply, leftChild, rightChild, 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

@@ -25,11 +25,11 @@ class OperatorNode {
     /**shuffles in place */
     shuffle() {
         if (!this.isCommutative)
-            return this;
+            return;
         if ((0, coin_1.coin)())
-            return this;
+            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));
+//         }
+//       }
+//     }
+//   }
+// }