math-exercises 1.1.0 → 1.2.0

package/src/numbers/rationals/rational.ts

@@ -1,10 +1,39 @@
-import { Expression } from "../../expression/expression";
+import { coprimesOf } from "../../mathutils/arithmetic/coprimesOf";
 import { gcd } from "../../mathutils/arithmetic/gcd";
+import { lcd } from "../../mathutils/arithmetic/lcd";
+import { randint } from "../../mathutils/random/randint";
 import { Node } from "../../tree/nodes/node";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode";
 import { DivideNode } from "../../tree/nodes/operators/divideNode";
+import { FractionNode } from "../../tree/nodes/operators/fractionNode";
+import { random } from "../../utils/random";
+import { shuffle } from "../../utils/shuffle";
 import { Integer } from "../integer/integer";
-import { Nombre } from "../nombre";
+import { Nombre, NumberType } from "../nombre";
+
+export abstract class RationalConstructor {
+  /**
+   * @param maxGcd max number by which the fraction is simplifiable
+   */
+  static randomSimplifiable(maxGcd: number = 10) {
+    const gcd = randint(2, maxGcd);
+    const max = randint(3, 11);
+    const min = random(coprimesOf(max));
+    let [num, denum]: number[] = shuffle([gcd * min, gcd * max]);
+    if (denum === gcd) {
+      //si 10/2 on transforme en 2/10
+      return new Rational(denum, num);
+    }
+    return new Rational(num, denum);
+  }
+  static randomIrreductible(max: number = 11) {
+    const a = randint(2, max);
+    const b = random([...coprimesOf(a), 1]);
+    if (b === 1) return new Rational(b, a);
+    const [num, denum] = shuffle([a, b]);
+    return new Rational(num, denum);
+  }
+}
 
 export class Rational implements Nombre {
   num: number;
@@ -12,25 +41,68 @@ export class Rational implements Nombre {
   tex: string;
   value: number;
   isSimplified: boolean;
+  type: NumberType;
 
   constructor(numerator: number, denumerator: number) {
+    if (denumerator === 0) throw Error("division by zero");
     this.num = numerator;
     this.denum = denumerator;
     this.value = numerator / denumerator;
     this.isSimplified = Math.abs(gcd(numerator, denumerator)) === 1;
     this.tex = `\\frac{${this.num}}{${this.denum}}`;
+    this.type = NumberType.Rational;
   }
 
   toTex() {
     return `\\frac{${this.num}}{${this.denum}}`;
   }
 
-  add(expression: Expression): Expression {
-    return this;
+  add(nb: Nombre): Nombre {
+    switch (nb.type) {
+      case NumberType.Integer: {
+        const num = this.num + this.denum * nb.value;
+        return new Rational(num, this.denum).simplify();
+      }
+      case NumberType.Rational: {
+        const rational = nb as Rational;
+        const ppcm = lcd(rational.denum, this.denum);
+        const num = this.num * (ppcm / this.denum) + rational.num * (ppcm / rational.denum);
+        return new Rational(num, ppcm).simplify();
+      }
+    }
+    throw Error("not implemented yet");
   }
 
-  multiply(expression: Expression): Expression {
-    return this;
+  multiply(nb: Nombre): Nombre {
+    switch (nb.type) {
+      case NumberType.Integer: {
+        const num = this.num * nb.value;
+        const denum = this.denum;
+        return new Rational(num, denum).simplify();
+      }
+      case NumberType.Rational: {
+        const rational = nb as Rational;
+        const num = this.num * rational.num;
+        const denum = this.denum * rational.denum;
+        return new Rational(num, denum).simplify();
+      }
+    }
+    throw Error("not implemented yet");
+  }
+  divide(nb: Nombre): Nombre {
+    switch (nb.type) {
+      case NumberType.Integer: {
+        const denum = this.denum * nb.value;
+        return new Rational(this.num, denum).simplify();
+      }
+      case NumberType.Rational: {
+        const rational = nb as Rational;
+        const num = this.num * rational.denum;
+        const denum = this.denum * rational.num;
+        return new Rational(num, denum).simplify();
+      }
+    }
+    throw Error("not implemented yet");
   }
 
   opposite(): Rational {
@@ -38,19 +110,13 @@ export class Rational implements Nombre {
   }
 
   toTree(): Node {
-    return new DivideNode(new NumberNode(this.num), new NumberNode(this.denum));
+    return new FractionNode(new NumberNode(this.num), new NumberNode(this.denum));
   }
 
   simplify(): Nombre {
-    const sign =
-      (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0)
-        ? 1
-        : -1;
+    const sign = (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0) ? 1 : -1;
     const div = Math.abs(gcd(this.num, this.denum));
     if (Math.abs(this.denum) === div) return new Integer(this.num / this.denum);
-    return new Rational(
-      (sign * Math.abs(this.num)) / div,
-      Math.abs(this.denum) / div
-    );
+    return new Rational((sign * Math.abs(this.num)) / div, Math.abs(this.denum) / div);
   }
 }

package/src/numbers/reals/real.js

@@ -2,10 +2,12 @@
 exports.__esModule = true;
 exports.Real = void 0;
 var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var nombre_1 = require("../nombre");
 var Real = /** @class */ (function () {
     function Real(value, tex) {
         this.value = value;
         this.tex = tex;
+        this.type = nombre_1.NumberType.Real;
     }
     Real.prototype.toTree = function () {
         return new numberNode_1.NumberNode(this.value);

package/src/numbers/reals/real.ts

@@ -1,13 +1,15 @@
 import { Node } from "../../tree/nodes/node";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode";
-import { Nombre } from "../nombre";
+import { Nombre, NumberType } from "../nombre";
 
 export class Real implements Nombre {
   value: number;
   tex: string;
+  type: NumberType;
   constructor(value: number, tex: string) {
     this.value = value;
     this.tex = tex;
+    this.type = NumberType.Real;
   }
   toTree(): Node {
     return new NumberNode(this.value);

package/src/numbers/reals/squareRoot.ts

@@ -11,10 +11,7 @@ export abstract class SquareRootConstructor {
   /**
    * @returns simplifiable square root type sqrt(c)=a*sqrt(b)
    */
-  static randomSimplifiable({
-    allowPerfectSquare = false,
-    maxSquare = 11,
-  }): SquareRoot {
+  static randomSimplifiable({ allowPerfectSquare = false, maxSquare = 11 }): SquareRoot {
     const a = randint(2, maxSquare);
     let b;
     let bMin = allowPerfectSquare ? 1 : 2;
@@ -44,8 +41,7 @@ export class SquareRoot extends Real {
       }
     }
     const outsideSqrt = multiples.reduce((x, y) => x * y);
-    const insideSqrt =
-      factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
+    const insideSqrt = factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
 
     const simplified =
       insideSqrt !== 1
@@ -58,10 +54,7 @@ export class SquareRoot extends Real {
       return insideSqrt !== 1
         ? outsideSqrt === 1
           ? new SqrtNode(new NumberNode(insideSqrt))
-          : new MultiplyNode(
-              new NumberNode(outsideSqrt),
-              new SqrtNode(new NumberNode(insideSqrt))
-            )
+          : new MultiplyNode(new NumberNode(outsideSqrt), new SqrtNode(new NumberNode(insideSqrt)))
         : new NumberNode(outsideSqrt);
     };
     return simplified;

package/src/polynomials/affine.ts

@@ -13,9 +13,7 @@ import { Nombre } from "../numbers/nombre";
 
 export abstract class AffineConstructor {
   static random(
-    domainA: MathSet = new Interval("[[-10; 10]]").difference(
-      new DiscreteSet([new Integer(0)])
-    ),
+    domainA: MathSet = new Interval("[[-10; 10]]").difference(new DiscreteSet([new Integer(0)])),
     domainB: MathSet = new Interval("[[-10; 10]]")
   ): Affine {
     const a = domainA.getRandomElement();
@@ -25,9 +23,7 @@ export abstract class AffineConstructor {
 
   static differentRandoms(
     nb: number,
-    domainA: MathSet = new Interval("[[-10; 10]]").difference(
-      new DiscreteSet([new Integer(0)])
-    ),
+    domainA: MathSet = new Interval("[[-10; 10]]").difference(new DiscreteSet([new Integer(0)])),
     domainB: MathSet = new Interval("[[-10; 10]]")
   ): Affine[] {
     const res: Affine[] = [];

package/src/polynomials/polynomial.js

@@ -4,7 +4,7 @@ exports.Polynomial = void 0;
 var numberNode_1 = require("../tree/nodes/numbers/numberNode");
 var addNode_1 = require("../tree/nodes/operators/addNode");
 var multiplyNode_1 = require("../tree/nodes/operators/multiplyNode");
-var oppositeNode_1 = require("../tree/nodes/operators/oppositeNode");
+var oppositeNode_1 = require("../tree/nodes/functions/oppositeNode");
 var powerNode_1 = require("../tree/nodes/operators/powerNode");
 var variableNode_1 = require("../tree/nodes/variables/variableNode");
 var Polynomial = /** @class */ (function () {
@@ -25,15 +25,13 @@ var Polynomial = /** @class */ (function () {
         this.degree = coefficients.length - 1;
     }
     Polynomial.prototype.equals = function (P) {
-        return (P.degree === this.degree &&
-            this.coefficients.every(function (coeff, i) { return coeff === P.coefficients[i]; }));
+        return P.degree === this.degree && this.coefficients.every(function (coeff, i) { return coeff === P.coefficients[i]; });
     };
     Polynomial.prototype.getRoots = function () { };
     Polynomial.prototype.add = function (P) {
         if (P.variable !== this.variable)
             throw Error("Can't add two polynomials with different variables");
-        var newDegree = P.degree === this.degree &&
-            P.coefficients[P.degree] === -this.coefficients[this.degree]
+        var newDegree = P.degree === this.degree && P.coefficients[P.degree] === -this.coefficients[this.degree]
             ? P.degree - 1
             : Math.max(P.degree, this.degree);
         var res = [];
@@ -110,14 +108,7 @@ var Polynomial = /** @class */ (function () {
                 s += coeff === 1 ? "" : coeff === -1 ? "-" : coeff;
             }
             else {
-                s +=
-                    coeff === 1
-                        ? "+"
-                        : coeff === -1
-                            ? "-"
-                            : coeff > 0
-                                ? "+".concat(coeff)
-                                : coeff;
+                s += coeff === 1 ? "+" : coeff === -1 ? "-" : coeff > 0 ? "+".concat(coeff) : coeff;
             }
             //x^n
             if (i === 0)

package/src/polynomials/polynomial.ts

@@ -1,14 +1,13 @@
-import { Expression } from "../expression/expression";
 import { Node } from "../tree/nodes/node";
 import { NumberNode } from "../tree/nodes/numbers/numberNode";
 import { AddNode } from "../tree/nodes/operators/addNode";
 import { MultiplyNode } from "../tree/nodes/operators/multiplyNode";
-import { OppositeNode } from "../tree/nodes/operators/oppositeNode";
+import { OppositeNode } from "../tree/nodes/functions/oppositeNode";
 import { PowerNode } from "../tree/nodes/operators/powerNode";
 import { SubstractNode } from "../tree/nodes/operators/substractNode";
 import { VariableNode } from "../tree/nodes/variables/variableNode";
 
-export class Polynomial implements Expression {
+export class Polynomial {
   degree: number;
   variable: string;
   /**
@@ -31,19 +30,14 @@ export class Polynomial implements Expression {
     this.degree = coefficients.length - 1;
   }
   equals(P: Polynomial): boolean {
-    return (
-      P.degree === this.degree &&
-      this.coefficients.every((coeff, i) => coeff === P.coefficients[i])
-    );
+    return P.degree === this.degree && this.coefficients.every((coeff, i) => coeff === P.coefficients[i]);
   }
   getRoots() {}
   add(P: Polynomial): Polynomial {
-    if (P.variable !== this.variable)
-      throw Error("Can't add two polynomials with different variables");
+    if (P.variable !== this.variable) throw Error("Can't add two polynomials with different variables");
 
     const newDegree =
-      P.degree === this.degree &&
-      P.coefficients[P.degree] === -this.coefficients[this.degree]
+      P.degree === this.degree && P.coefficients[P.degree] === -this.coefficients[this.degree]
         ? P.degree - 1
         : Math.max(P.degree, this.degree);
 
@@ -60,8 +54,7 @@ export class Polynomial implements Expression {
     );
   }
   multiply(Q: Polynomial): Polynomial {
-    if (Q.variable !== this.variable)
-      throw Error("Can't multiply two polynomials with different variables");
+    if (Q.variable !== this.variable) throw Error("Can't multiply two polynomials with different variables");
 
     const p = this.degree;
     const q = Q.degree;
@@ -96,10 +89,7 @@ export class Polynomial implements Expression {
 
       const monome =
         cursor > 1
-          ? new PowerNode(
-              new VariableNode(this.variable),
-              new NumberNode(cursor)
-            )
+          ? new PowerNode(new VariableNode(this.variable), new NumberNode(cursor))
           : new VariableNode(this.variable);
 
       let res: Node;
@@ -132,14 +122,7 @@ export class Polynomial implements Expression {
       else if (i === this.degree) {
         s += coeff === 1 ? "" : coeff === -1 ? "-" : coeff;
       } else {
-        s +=
-          coeff === 1
-            ? "+"
-            : coeff === -1
-            ? "-"
-            : coeff > 0
-            ? `+${coeff}`
-            : coeff;
+        s += coeff === 1 ? "+" : coeff === -1 ? "-" : coeff > 0 ? `+${coeff}` : coeff;
       }
       //x^n
       if (i === 0) continue;

package/src/tree/latexParser/latexParse.js

@@ -1,7 +1,9 @@
 "use strict";
 exports.__esModule = true;
 exports.latexParse = void 0;
+var functionNode_1 = require("../nodes/functions/functionNode");
 var node_1 = require("../nodes/node");
+var operatorNode_1 = require("../nodes/operators/operatorNode");
 function latexParse(node) {
     if (!node) {
         console.log("parsing a null node ???");
@@ -13,59 +15,104 @@ function latexParse(node) {
         case node_1.NodeType.number:
             return node.tex;
         case node_1.NodeType.operator:
-            var rightTex = latexParse(node.rightChild);
-            var leftTex = latexParse(node.leftChild);
-            var leftChild = node.leftChild, rightChild = node.rightChild;
-            switch (node.id) {
-                case "add":
+            var operatorNode = node;
+            var rightTex = latexParse(operatorNode.rightChild);
+            var leftTex = latexParse(operatorNode.leftChild);
+            var leftChild = operatorNode.leftChild, rightChild = operatorNode.rightChild;
+            switch (operatorNode.id) {
+                case operatorNode_1.OperatorIds.add:
                     return "".concat(leftTex, " ").concat(rightTex[0] === "-" ? "" : "+ ").concat(rightTex);
-                case "opposite":
-                    var needBrackets = leftChild.id === "add" ||
-                        leftChild.id === "substract" ||
-                        leftTex[0] === "-";
-                    if (needBrackets)
-                        leftTex = "(".concat(leftTex, ")");
-                    return "-".concat(leftTex);
-                case "substract": {
-                    var needBrackets_1 = rightChild.id === "add" ||
-                        rightChild.id === "substract" ||
+                case operatorNode_1.OperatorIds.substract: {
+                    var needBrackets = (rightChild.type === node_1.NodeType.operator &&
+                        [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(rightChild.id)) ||
                         rightTex[0] === "-";
-                    if (needBrackets_1)
+                    if (needBrackets)
                         rightTex = "(".concat(rightTex, ")");
                     return "".concat(leftTex, " - ").concat(rightTex);
                 }
-                case "multiply": {
-                    if (leftChild.id === "add" || leftChild.id === "substract")
-                        leftTex = "(".concat(leftTex, ")");
-                    var needBrackets_2 = rightChild.id === "add" ||
-                        rightChild.id === "substract" ||
-                        rightTex[0] === "-";
-                    if (needBrackets_2)
+                case operatorNode_1.OperatorIds.multiply: {
+                    if (leftChild.type === node_1.NodeType.operator) {
+                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(leftChild.id))
+                            leftTex = "(".concat(leftTex, ")");
+                    }
+                    var needBrackets = rightTex[0] === "-";
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        var operatorRightChild = rightChild;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
+                    }
+                    if (needBrackets)
                         rightTex = "(".concat(rightTex, ")");
-                    var showTimesSign = !isNaN(+rightTex[0]); //permet de gérer le cas 3*2^x
+                    //  permet de gérer le cas 3*2^x
+                    var showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === node_1.NodeType.number;
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        var operatorRightChild = rightChild;
+                        showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
+                    }
                     return "".concat(leftTex).concat(showTimesSign ? "\\times " : "").concat(rightTex);
                 }
-                case "divide": {
+                case operatorNode_1.OperatorIds.divide: {
+                    if (leftChild.type === node_1.NodeType.operator) {
+                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].includes(leftChild.id))
+                            leftTex = "(".concat(leftTex, ")");
+                    }
+                    var needBrackets = rightTex[0] === "-";
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        var operatorRightChild = rightChild;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
+                    }
+                    if (needBrackets)
+                        rightTex = "(".concat(rightTex, ")");
+                    //  permet de gérer le cas 3*2^x
+                    var showTimesSign = !isNaN(+rightTex[0]);
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        var operatorRightChild = rightChild;
+                        showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
+                    }
+                    return "".concat(leftTex).concat(showTimesSign ? "\\div " : "").concat(rightTex);
+                }
+                case operatorNode_1.OperatorIds.fraction: {
                     return "\\frac{".concat(leftTex, "}{").concat(rightTex, "}");
                 }
-                case "power": {
-                    if (leftChild.id === "add" ||
-                        leftChild.id === "substract" ||
-                        leftChild.id === "multiply")
+                case operatorNode_1.OperatorIds.power: {
+                    var needBrackets = leftTex[0] === "-";
+                    if (leftChild.type === node_1.NodeType.operator) {
+                        var childOperator = 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 = "(".concat(leftTex, ")");
                     return "".concat(leftTex, "^{").concat(rightTex, "}");
                 }
-                case "equal": {
+                case operatorNode_1.OperatorIds.equal: {
                     return "".concat(leftTex, " = ").concat(rightTex);
                 }
                 default:
                     return node.tex;
             }
         case node_1.NodeType["function"]: {
-            var leftTex_1 = latexParse(node.leftChild);
-            switch (node.id) {
-                case "sqrt": {
-                    return "\\sqrt{".concat(leftTex_1, "}");
+            var functionNode = node;
+            var child = functionNode.child;
+            var childTex = latexParse(functionNode.child);
+            switch (functionNode.id) {
+                case functionNode_1.FunctionsIds.sqrt: {
+                    return "\\sqrt{".concat(childTex, "}");
+                }
+                case functionNode_1.FunctionsIds.opposite: {
+                    var needBrackets = childTex[0] === "-";
+                    if (child.type === node_1.NodeType.operator) {
+                        var operatorChild = child;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorChild.id));
+                    }
+                    if (needBrackets)
+                        childTex = "(".concat(childTex, ")");
+                    return "-".concat(childTex);
                 }
             }
         }

package/src/tree/latexParser/latexParse.ts

@@ -1,7 +1,8 @@
+import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
 import { Node, NodeType } from "../nodes/node";
-import { OperatorNode } from "../nodes/operators/operatorNode";
+import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
 
-export function latexParse(node: Node | null): string {
+export function latexParse(node: Node): string {
   if (!node) {
     console.log("parsing a null node ???");
     return "";
@@ -12,67 +13,112 @@ export function latexParse(node: Node | null): string {
     case NodeType.number:
       return node.tex;
     case NodeType.operator:
-      let rightTex = latexParse(node.rightChild);
-      let leftTex = latexParse(node.leftChild);
-      const { leftChild, rightChild } = node;
-      switch (node.id) {
-        case "add":
+      const operatorNode = node as OperatorNode;
+      let rightTex = latexParse(operatorNode.rightChild);
+      let leftTex = latexParse(operatorNode.leftChild);
+      const { leftChild, rightChild } = operatorNode;
+      switch (operatorNode.id) {
+        case OperatorIds.add:
           return `${leftTex} ${rightTex[0] === "-" ? "" : "+ "}${rightTex}`;
 
-        case "opposite":
+        case OperatorIds.substract: {
           const needBrackets =
-            leftChild!.id === "add" ||
-            leftChild!.id === "substract" ||
-            leftTex[0] === "-";
-          if (needBrackets) leftTex = `(${leftTex})`;
-          return `-${leftTex}`;
-
-        case "substract": {
-          const needBrackets =
-            rightChild!.id === "add" ||
-            rightChild!.id === "substract" ||
+            (rightChild.type === NodeType.operator &&
+              [OperatorIds.add, OperatorIds.substract].includes((rightChild as OperatorNode).id)) ||
             rightTex[0] === "-";
+
           if (needBrackets) rightTex = `(${rightTex})`;
+
           return `${leftTex} - ${rightTex}`;
         }
 
-        case "multiply": {
-          if (leftChild!.id === "add" || leftChild!.id === "substract")
-            leftTex = `(${leftTex})`;
-          const needBrackets =
-            rightChild!.id === "add" ||
-            rightChild!.id === "substract" ||
-            rightTex[0] === "-";
+        case OperatorIds.multiply: {
+          if (leftChild.type === NodeType.operator) {
+            if ([OperatorIds.add, OperatorIds.substract, OperatorIds.divide].includes((leftChild as OperatorNode).id))
+              leftTex = `(${leftTex})`;
+          }
+          let needBrackets = rightTex[0] === "-";
+          if (rightChild.type === NodeType.operator) {
+            const operatorRightChild = rightChild as OperatorNode;
+            needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
+          }
           if (needBrackets) rightTex = `(${rightTex})`;
-          const showTimesSign = !isNaN(+rightTex[0]); //permet de gérer le cas 3*2^x
+
+          //  permet de gérer le cas 3*2^x
+          let showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === NodeType.number;
+          if (rightChild.type === NodeType.operator) {
+            const operatorRightChild = rightChild as OperatorNode;
+            showTimesSign ||= [OperatorIds.fraction].includes(operatorRightChild.id);
+          }
           return `${leftTex}${showTimesSign ? "\\times " : ""}${rightTex}`;
         }
 
-        case "divide": {
+        case OperatorIds.divide: {
+          if (leftChild.type === NodeType.operator) {
+            if ([OperatorIds.add, OperatorIds.substract, OperatorIds.multiply].includes((leftChild as OperatorNode).id))
+              leftTex = `(${leftTex})`;
+          }
+          let needBrackets = rightTex[0] === "-";
+          if (rightChild.type === NodeType.operator) {
+            const operatorRightChild = rightChild as OperatorNode;
+            needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
+          }
+          if (needBrackets) rightTex = `(${rightTex})`;
+
+          //  permet de gérer le cas 3*2^x
+          let showTimesSign = !isNaN(+rightTex[0]);
+          if (rightChild.type === NodeType.operator) {
+            const operatorRightChild = rightChild as OperatorNode;
+            showTimesSign ||= [OperatorIds.fraction].includes(operatorRightChild.id);
+          }
+          return `${leftTex}${showTimesSign ? "\\div " : ""}${rightTex}`;
+        }
+
+        case OperatorIds.fraction: {
           return `\\frac{${leftTex}}{${rightTex}}`;
         }
 
-        case "power": {
-          if (
-            leftChild!.id === "add" ||
-            leftChild!.id === "substract" ||
-            leftChild!.id === "multiply"
-          )
-            leftTex = `(${leftTex})`;
+        case OperatorIds.power: {
+          let needBrackets = leftTex[0] === "-";
+          if (leftChild.type === NodeType.operator) {
+            const childOperator = leftChild as OperatorNode;
+            needBrackets ||= [
+              OperatorIds.add,
+              OperatorIds.substract,
+              OperatorIds.multiply,
+              OperatorIds.divide,
+              OperatorIds.fraction,
+              OperatorIds.power,
+            ].includes(childOperator.id);
+          }
+          if (needBrackets) leftTex = `(${leftTex})`;
           return `${leftTex}^{${rightTex}}`;
         }
 
-        case "equal": {
+        case OperatorIds.equal: {
           return `${leftTex} = ${rightTex}`;
         }
         default:
           return node.tex;
       }
+
     case NodeType.function: {
-      let leftTex = latexParse(node.leftChild);
-      switch (node.id) {
-        case "sqrt": {
-          return `\\sqrt{${leftTex}}`;
+      const functionNode = node as FunctionNode;
+      const child = functionNode.child;
+      let childTex = latexParse(functionNode.child);
+      switch (functionNode.id) {
+        case FunctionsIds.sqrt: {
+          return `\\sqrt{${childTex}}`;
+        }
+
+        case FunctionsIds.opposite: {
+          let needBrackets = childTex[0] === "-";
+          if (child.type === NodeType.operator) {
+            const operatorChild = child as OperatorNode;
+            needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorChild.id);
+          }
+          if (needBrackets) childTex = `(${childTex})`;
+          return `-${childTex}`;
         }
       }
     }