math-exercises 1.1.1 → 1.2.1

package/src/numbers/nombre.ts

@@ -3,11 +3,13 @@ import { NumberNode } from "../tree/nodes/numbers/numberNode";
 
 export enum NumberType {
   Integer,
+  Decimal,
   Rational,
   Real,
 }
 export interface Nombre {
   value: number;
   tex: string;
+  type: NumberType;
   toTree: () => Node;
 }

package/src/numbers/rationals/rational.js

@@ -1,37 +1,123 @@
 "use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 exports.__esModule = true;
-exports.Rational = void 0;
+exports.Rational = exports.RationalConstructor = void 0;
+var coprimesOf_1 = require("../../mathutils/arithmetic/coprimesOf");
 var gcd_1 = require("../../mathutils/arithmetic/gcd");
+var lcd_1 = require("../../mathutils/arithmetic/lcd");
+var randint_1 = require("../../mathutils/random/randint");
 var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-var divideNode_1 = require("../../tree/nodes/operators/divideNode");
+var fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+var random_1 = require("../../utils/random");
+var shuffle_1 = require("../../utils/shuffle");
 var integer_1 = require("../integer/integer");
+var nombre_1 = require("../nombre");
+var RationalConstructor = /** @class */ (function () {
+    function RationalConstructor() {
+    }
+    /**
+     * @param maxGcd max number by which the fraction is simplifiable
+     */
+    RationalConstructor.randomSimplifiable = function (maxGcd) {
+        if (maxGcd === void 0) { maxGcd = 10; }
+        var gcd = (0, randint_1.randint)(2, maxGcd);
+        var max = (0, randint_1.randint)(3, 11);
+        var min = (0, random_1.random)((0, coprimesOf_1.coprimesOf)(max));
+        var _a = (0, shuffle_1.shuffle)([gcd * min, gcd * max]), num = _a[0], denum = _a[1];
+        if (denum === gcd) {
+            //si 10/2 on transforme en 2/10
+            return new Rational(denum, num);
+        }
+        return new Rational(num, denum);
+    };
+    RationalConstructor.randomIrreductible = function (max) {
+        if (max === void 0) { max = 11; }
+        var a = (0, randint_1.randint)(2, max);
+        var b = (0, random_1.random)(__spreadArray(__spreadArray([], (0, coprimesOf_1.coprimesOf)(a), true), [1], false));
+        if (b === 1)
+            return new Rational(b, a);
+        var _a = (0, shuffle_1.shuffle)([a, b]), num = _a[0], denum = _a[1];
+        return new Rational(num, denum);
+    };
+    return RationalConstructor;
+}());
+exports.RationalConstructor = RationalConstructor;
 var Rational = /** @class */ (function () {
     function Rational(numerator, denumerator) {
+        if (denumerator === 0)
+            throw Error("division by zero");
         this.num = numerator;
         this.denum = denumerator;
         this.value = numerator / denumerator;
         this.isSimplified = Math.abs((0, gcd_1.gcd)(numerator, denumerator)) === 1;
         this.tex = "\\frac{".concat(this.num, "}{").concat(this.denum, "}");
+        this.type = nombre_1.NumberType.Rational;
     }
     Rational.prototype.toTex = function () {
         return "\\frac{".concat(this.num, "}{").concat(this.denum, "}");
     };
-    Rational.prototype.add = function (expression) {
-        return this;
+    Rational.prototype.add = function (nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                var num = this.num + this.denum * nb.value;
+                return new Rational(num, this.denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                var rational = nb;
+                var ppcm = (0, lcd_1.lcd)(rational.denum, this.denum);
+                var num = this.num * (ppcm / this.denum) + rational.num * (ppcm / rational.denum);
+                return new Rational(num, ppcm).simplify();
+            }
+        }
+        throw Error("not implemented yet");
+    };
+    Rational.prototype.multiply = function (nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                var num = this.num * nb.value;
+                var denum = this.denum;
+                return new Rational(num, denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                var rational = nb;
+                var num = this.num * rational.num;
+                var denum = this.denum * rational.denum;
+                return new Rational(num, denum).simplify();
+            }
+        }
+        throw Error("not implemented yet");
     };
-    Rational.prototype.multiply = function (expression) {
-        return this;
+    Rational.prototype.divide = function (nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                var denum = this.denum * nb.value;
+                return new Rational(this.num, denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                var rational = nb;
+                var num = this.num * rational.denum;
+                var denum = this.denum * rational.num;
+                return new Rational(num, denum).simplify();
+            }
+        }
+        throw Error("not implemented yet");
     };
     Rational.prototype.opposite = function () {
         return new Rational(-this.num, this.denum);
     };
     Rational.prototype.toTree = function () {
-        return new divideNode_1.DivideNode(new numberNode_1.NumberNode(this.num), new numberNode_1.NumberNode(this.denum));
+        return new fractionNode_1.FractionNode(new numberNode_1.NumberNode(this.num), new numberNode_1.NumberNode(this.denum));
     };
     Rational.prototype.simplify = function () {
-        var sign = (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0)
-            ? 1
-            : -1;
+        var sign = (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0) ? 1 : -1;
         var div = Math.abs((0, gcd_1.gcd)(this.num, this.denum));
         if (Math.abs(this.denum) === div)
             return new integer_1.Integer(this.num / this.denum);

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);
                 }
             }
         }