math-exercises 1.0.1 → 1.1.0

package/src/numbers/nombre.ts

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

package/src/numbers/rationals/rational.js

@@ -2,18 +2,40 @@
 exports.__esModule = true;
 exports.Rational = void 0;
 var gcd_1 = require("../../mathutils/arithmetic/gcd");
+var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var divideNode_1 = require("../../tree/nodes/operators/divideNode");
+var integer_1 = require("../integer/integer");
 var Rational = /** @class */ (function () {
     function Rational(numerator, denumerator) {
         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, "}");
     }
     Rational.prototype.toTex = function () {
         return "\\frac{".concat(this.num, "}{").concat(this.denum, "}");
     };
+    Rational.prototype.add = function (expression) {
+        return this;
+    };
+    Rational.prototype.multiply = function (expression) {
+        return this;
+    };
+    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));
+    };
     Rational.prototype.simplify = function () {
+        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));
-        return new Rational(this.num / div, this.denum / div);
+        if (Math.abs(this.denum) === div)
+            return new integer_1.Integer(this.num / this.denum);
+        return new Rational((sign * Math.abs(this.num)) / div, Math.abs(this.denum) / div);
     };
     return Rational;
 }());

package/src/numbers/rationals/rational.ts

@@ -1,22 +1,56 @@
+import { Expression } from "../../expression/expression";
 import { gcd } from "../../mathutils/arithmetic/gcd";
+import { Node } from "../../tree/nodes/node";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+import { DivideNode } from "../../tree/nodes/operators/divideNode";
+import { Integer } from "../integer/integer";
+import { Nombre } from "../nombre";
 
-export class Rational {
+export class Rational implements Nombre {
   num: number;
   denum: number;
+  tex: string;
+  value: number;
   isSimplified: boolean;
 
   constructor(numerator: number, denumerator: number) {
     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}}`;
   }
 
   toTex() {
     return `\\frac{${this.num}}{${this.denum}}`;
   }
 
-  simplify(): Rational {
+  add(expression: Expression): Expression {
+    return this;
+  }
+
+  multiply(expression: Expression): Expression {
+    return this;
+  }
+
+  opposite(): Rational {
+    return new Rational(-this.num, this.denum);
+  }
+
+  toTree(): Node {
+    return new DivideNode(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 div = Math.abs(gcd(this.num, this.denum));
-    return new Rational(this.num / div, this.denum / div);
+    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
+    );
   }
 }

package/src/numbers/reals/real.js

@@ -0,0 +1,15 @@
+"use strict";
+exports.__esModule = true;
+exports.Real = void 0;
+var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var Real = /** @class */ (function () {
+    function Real(value, tex) {
+        this.value = value;
+        this.tex = tex;
+    }
+    Real.prototype.toTree = function () {
+        return new numberNode_1.NumberNode(this.value);
+    };
+    return Real;
+}());
+exports.Real = Real;

package/src/numbers/reals/real.ts

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

package/src/numbers/reals/squareRoot.js

@@ -0,0 +1,85 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.SquareRoot = exports.SquareRootConstructor = void 0;
+var isSquare_1 = require("../../mathutils/arithmetic/isSquare");
+var primeFactors_1 = require("../../mathutils/arithmetic/primeFactors");
+var randint_1 = require("../../mathutils/random/randint");
+var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+var real_1 = require("./real");
+var sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
+var SquareRootConstructor = /** @class */ (function () {
+    function SquareRootConstructor() {
+    }
+    /**
+     * @returns simplifiable square root type sqrt(c)=a*sqrt(b)
+     */
+    SquareRootConstructor.randomSimplifiable = function (_a) {
+        var _b = _a.allowPerfectSquare, allowPerfectSquare = _b === void 0 ? false : _b, _c = _a.maxSquare, maxSquare = _c === void 0 ? 11 : _c;
+        var a = (0, randint_1.randint)(2, maxSquare);
+        var b;
+        var bMin = allowPerfectSquare ? 1 : 2;
+        do {
+            b = (0, randint_1.randint)(bMin, maxSquare);
+        } while (b % (a * a) === 0 || (0, isSquare_1.isSquare)(b));
+        return new SquareRoot(a * a * b);
+    };
+    return SquareRootConstructor;
+}());
+exports.SquareRootConstructor = SquareRootConstructor;
+var SquareRoot = /** @class */ (function (_super) {
+    __extends(SquareRoot, _super);
+    function SquareRoot(operand) {
+        var _this = _super.call(this, Math.sqrt(operand), "\\sqrt{".concat(operand, "}")) || this;
+        _this.operand = operand;
+        return _this;
+    }
+    SquareRoot.prototype.simplify = function () {
+        var factors = (0, primeFactors_1.primeFactors)(this.operand);
+        // finds primes with even exponents
+        var multiples = [1];
+        for (var i = 0; i < factors.length - 1; i++) {
+            if (factors[i] === factors[i + 1]) {
+                multiples.push(factors[i]);
+                factors.splice(i, 2);
+                i--;
+            }
+        }
+        var outsideSqrt = multiples.reduce(function (x, y) { return x * y; });
+        var insideSqrt = factors.length === 0 ? 1 : factors.reduce(function (x, y) { return x * y; });
+        var simplified = insideSqrt !== 1
+            ? new real_1.Real(outsideSqrt * Math.sqrt(insideSqrt), "".concat(outsideSqrt === 1 ? "" : "".concat(outsideSqrt), "\\sqrt{").concat(insideSqrt, "}"))
+            : new real_1.Real(outsideSqrt, outsideSqrt + "");
+        simplified.toTree = function () {
+            return insideSqrt !== 1
+                ? outsideSqrt === 1
+                    ? new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt))
+                    : new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(outsideSqrt), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt)))
+                : new numberNode_1.NumberNode(outsideSqrt);
+        };
+        return simplified;
+    };
+    SquareRoot.prototype.toTex = function () {
+        return this.tex;
+    };
+    SquareRoot.prototype.toTree = function () {
+        return new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(this.operand));
+    };
+    return SquareRoot;
+}(real_1.Real));
+exports.SquareRoot = SquareRoot;

package/src/numbers/reals/squareRoot.ts

@@ -1,13 +1,20 @@
 import { isSquare } from "../../mathutils/arithmetic/isSquare";
 import { primeFactors } from "../../mathutils/arithmetic/primeFactors";
 import { randint } from "../../mathutils/random/randint";
+import { Node } from "../../tree/nodes/node";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+import { MultiplyNode } from "../../tree/nodes/operators/multiplyNode";
 import { Real } from "./real";
+import { SqrtNode } from "../../tree/nodes/functions/sqrtNode";
 
 export abstract class SquareRootConstructor {
   /**
    * @returns simplifiable square root type sqrt(c)=a*sqrt(b)
    */
-  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;
@@ -18,37 +25,53 @@ export abstract class SquareRootConstructor {
   }
 }
 
-export class SquareRoot implements Real {
-  tex: string;
-
-  constructor(operand: string | number) {
-    this.tex = `\\sqrt{${operand}}`;
+export class SquareRoot extends Real {
+  operand: number;
+  constructor(operand: number) {
+    super(Math.sqrt(operand), `\\sqrt{${operand}}`);
+    this.operand = operand;
   }
 
-  simplify() {
-    const factors = primeFactors(b);
-
-    /**
-     * finds primes with even exponents
-     */
+  simplify(): Real {
+    const factors = primeFactors(this.operand);
+    // finds primes with even exponents
     const multiples = [1];
     for (let i = 0; i < factors.length - 1; i++) {
       if (factors[i] === factors[i + 1]) {
         multiples.push(factors[i]);
-        factors.splice(i, 2); 
+        factors.splice(i, 2);
+        i--;
       }
     }
+    const outsideSqrt = multiples.reduce((x, y) => x * y);
+    const insideSqrt =
+      factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
+
+    const simplified =
+      insideSqrt !== 1
+        ? new Real(
+            outsideSqrt * Math.sqrt(insideSqrt),
+            `${outsideSqrt === 1 ? "" : `${outsideSqrt}`}\\sqrt{${insideSqrt}}`
+          )
+        : new Real(outsideSqrt, outsideSqrt + "");
+    simplified.toTree = (): Node => {
+      return insideSqrt !== 1
+        ? outsideSqrt === 1
+          ? new SqrtNode(new NumberNode(insideSqrt))
+          : new MultiplyNode(
+              new NumberNode(outsideSqrt),
+              new SqrtNode(new NumberNode(insideSqrt))
+            )
+        : new NumberNode(outsideSqrt);
+    };
+    return simplified;
   }
 
   toTex(): string {
     return this.tex;
   }
-}
 
-const outsideSqrtB = multiples.reduce((x, y) => x * y); // A should be muliply be all those numbers
-const insideSqrtB = factors.length === 0 ? "" : factors.reduce((x, y) => x * y); // here is what remains in the squareroot
-
-if (b === 1) answer = `${a}`;
-else if (factors.length === 0) answer = `${a * outsideSqrtB}`;
-// if the is no leftover in the squareroot, it just vanish
-else answer = `${a * outsideSqrtB}\\sqrt{${insideSqrtB}}`;
+  toTree(): Node {
+    return new SqrtNode(new NumberNode(this.operand));
+  }
+}

package/src/polynomials/affine.js

@@ -20,18 +20,19 @@ var rational_1 = require("../numbers/rationals/rational");
 var intervals_1 = require("../sets/intervals/intervals");
 var polynomial_1 = require("./polynomial");
 var discreteSet_1 = require("../sets/discreteSet");
+var integer_1 = require("../numbers/integer/integer");
 var AffineConstructor = /** @class */ (function () {
     function AffineConstructor() {
     }
     AffineConstructor.random = function (domainA, domainB) {
-        if (domainA === void 0) { domainA = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([0])); }
+        if (domainA === void 0) { domainA = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])); }
         if (domainB === void 0) { domainB = new intervals_1.Interval("[[-10; 10]]"); }
         var a = domainA.getRandomElement();
         var b = domainB.getRandomElement();
-        return new Affine(a, b);
+        return new Affine(a.value, b.value);
     };
     AffineConstructor.differentRandoms = function (nb, domainA, domainB) {
-        if (domainA === void 0) { domainA = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([0])); }
+        if (domainA === void 0) { domainA = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])); }
         if (domainB === void 0) { domainB = new intervals_1.Interval("[[-10; 10]]"); }
         var res = [];
         var _loop_1 = function (i) {
@@ -60,7 +61,7 @@ var Affine = /** @class */ (function (_super) {
         return _this;
     }
     Affine.prototype.getRoot = function () {
-        return new rational_1.Rational(-this.b, this.a).simplify().toTex();
+        return new rational_1.Rational(-this.b, this.a).simplify();
     };
     Affine.prototype.toString = function () {
         return _super.prototype.toTex.call(this);

package/src/polynomials/affine.ts

@@ -1,32 +1,34 @@
-import { Expression } from "../expression/expression";
-import { add } from "../latex/add";
-import { NumberType } from "../numbers/number";
 import { Rational } from "../numbers/rationals/rational";
 import { Interval } from "../sets/intervals/intervals";
-import { randint } from "../mathutils/random/randint";
 import { Polynomial } from "./polynomial";
-import { Latex } from "../latex/latex";
 import { DiscreteSet } from "../sets/discreteSet";
 import { MathSet } from "../sets/mathSet";
+import { Integer } from "../numbers/integer/integer";
+import { Node, NodeType } from "../tree/nodes/node";
+import { MultiplyNode } from "../tree/nodes/operators/multiplyNode";
+import { NumberNode } from "../tree/nodes/numbers/numberNode";
+import { VariableNode } from "../tree/nodes/variables/variableNode";
+import { AddNode } from "../tree/nodes/operators/addNode";
+import { Nombre } from "../numbers/nombre";
 
 export abstract class AffineConstructor {
   static random(
-    domainA: MathSet<number> = new Interval("[[-10; 10]]").difference(
-      new DiscreteSet([0])
+    domainA: MathSet = new Interval("[[-10; 10]]").difference(
+      new DiscreteSet([new Integer(0)])
     ),
-    domainB: MathSet<number> = new Interval("[[-10; 10]]")
+    domainB: MathSet = new Interval("[[-10; 10]]")
   ): Affine {
     const a = domainA.getRandomElement();
     const b = domainB.getRandomElement();
-    return new Affine(a, b);
+    return new Affine(a.value, b.value);
   }
 
   static differentRandoms(
     nb: number,
-    domainA: MathSet<number> = new Interval("[[-10; 10]]").difference(
-      new DiscreteSet([0])
+    domainA: MathSet = new Interval("[[-10; 10]]").difference(
+      new DiscreteSet([new Integer(0)])
     ),
-    domainB: MathSet<number> = new Interval("[[-10; 10]]")
+    domainB: MathSet = new Interval("[[-10; 10]]")
   ): Affine[] {
     const res: Affine[] = [];
     for (let i = 0; i < nb; i++) {
@@ -38,13 +40,6 @@ export abstract class AffineConstructor {
     }
     return res;
   }
-
-  // static add(aff1: Affine, aff2: Affine | number): Affine {
-  //   if(typeof aff2)
-  // }
-  // static randomWithIntegerRoot(): Affine {
-  //   const root = randint(-10, 10);
-  // }
 }
 
 export class Affine extends Polynomial {
@@ -59,8 +54,8 @@ export class Affine extends Polynomial {
     this.variable = variable;
   }
 
-  getRoot(): string {
-    return new Rational(-this.b, this.a).simplify().toTex();
+  getRoot(): Nombre {
+    return new Rational(-this.b, this.a).simplify();
   }
 
   toString(): string {

package/src/polynomials/polynomial.js

@@ -1,6 +1,12 @@
 "use strict";
 exports.__esModule = true;
 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 powerNode_1 = require("../tree/nodes/operators/powerNode");
+var variableNode_1 = require("../tree/nodes/variables/variableNode");
 var Polynomial = /** @class */ (function () {
     /**
      *
@@ -11,8 +17,9 @@ var Polynomial = /** @class */ (function () {
         if (variable === void 0) { variable = "x"; }
         if (coefficients.length === 0)
             throw Error("coeffs must be not null");
-        if (coefficients[coefficients.length - 1] === 0)
+        if (coefficients[coefficients.length - 1] === 0) {
             throw Error("n-th coeff must be not null");
+        }
         this.coefficients = coefficients;
         this.variable = variable;
         this.degree = coefficients.length - 1;
@@ -21,6 +28,7 @@ var Polynomial = /** @class */ (function () {
         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");
@@ -34,6 +42,9 @@ var Polynomial = /** @class */ (function () {
         }
         return new Polynomial(res, this.variable);
     };
+    Polynomial.prototype.times = function (nb) {
+        return new Polynomial(this.coefficients.map(function (coeff) { return coeff * nb; }), this.variable);
+    };
     Polynomial.prototype.multiply = function (Q) {
         if (Q.variable !== this.variable)
             throw Error("Can't multiply two polynomials with different variables");
@@ -52,14 +63,42 @@ var Polynomial = /** @class */ (function () {
     Polynomial.prototype.opposite = function () {
         return new Polynomial(this.coefficients.map(function (coeff) { return -coeff; }), this.variable);
     };
+    Polynomial.prototype.toTree = function () {
+        var _this = this;
+        var recursive = function (cursor) {
+            var coeff = _this.coefficients[cursor];
+            if (coeff === 0)
+                return recursive(cursor - 1);
+            if (cursor === 0) {
+                return new numberNode_1.NumberNode(coeff);
+            }
+            var monome = cursor > 1
+                ? new powerNode_1.PowerNode(new variableNode_1.VariableNode(_this.variable), new numberNode_1.NumberNode(cursor))
+                : new variableNode_1.VariableNode(_this.variable);
+            var res;
+            if (coeff === 1)
+                res = monome;
+            else if (coeff === -1)
+                res = new oppositeNode_1.OppositeNode(monome);
+            else
+                res = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(coeff), monome);
+            var nextCoeff;
+            for (var i = cursor - 1; i > -1; i--) {
+                if (_this.coefficients[i]) {
+                    nextCoeff = _this.coefficients[i];
+                    break;
+                }
+            }
+            if (nextCoeff) {
+                return new addNode_1.AddNode(res, recursive(cursor - 1));
+            }
+            else {
+                return res;
+            }
+        };
+        return recursive(this.degree);
+    };
     Polynomial.prototype.toTex = function () {
-        // if (this.degree == 0) return "" + this.b;
-        // function getMonome(power: number): string {
-        //   if (power === 0) return "";
-        //   if (power === 1) return this.variable;
-        //   else return `${this.variable}^{${power}}`;
-        // }
-        // let s = this.coefficients[this.degree] + this.variable + this.degree > 1 ? `^{${this.degree}}` : "";
         var s = "";
         for (var i = this.degree; i > -1; i--) {
             var coeff = this.coefficients[i];
@@ -87,9 +126,6 @@ var Polynomial = /** @class */ (function () {
                 s += this.variable;
             else
                 s += "".concat(this.variable, "^{").concat(i, "}");
-            // latex.add(this.coefficients[i]);
-            // s += addLatex(this.coefficients[i]);
-            // s += this.coefficients[i] + this.variable + `^{${i}}`;
         }
         return s;
     };

package/src/polynomials/polynomial.ts

@@ -1,5 +1,12 @@
 import { Expression } from "../expression/expression";
-import { Latex } from "../latex/latex";
+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 { 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 {
   degree: number;
@@ -16,8 +23,9 @@ export class Polynomial implements Expression {
    */
   constructor(coefficients: number[], variable: string = "x") {
     if (coefficients.length === 0) throw Error("coeffs must be not null");
-    if (coefficients[coefficients.length - 1] === 0)
+    if (coefficients[coefficients.length - 1] === 0) {
       throw Error("n-th coeff must be not null");
+    }
     this.coefficients = coefficients;
     this.variable = variable;
     this.degree = coefficients.length - 1;
@@ -28,7 +36,7 @@ export class Polynomial implements Expression {
       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");
@@ -38,13 +46,19 @@ export class Polynomial implements Expression {
       P.coefficients[P.degree] === -this.coefficients[this.degree]
         ? P.degree - 1
         : Math.max(P.degree, this.degree);
+
     const res: number[] = [];
     for (let i = 0; i < newDegree + 1; i++) {
       res[i] = P.coefficients[i] + this.coefficients[i];
     }
     return new Polynomial(res, this.variable);
   }
-
+  times(nb: number): Polynomial {
+    return new Polynomial(
+      this.coefficients.map((coeff) => coeff * nb),
+      this.variable
+    );
+  }
   multiply(Q: Polynomial): Polynomial {
     if (Q.variable !== this.variable)
       throw Error("Can't multiply two polynomials with different variables");
@@ -64,22 +78,52 @@ export class Polynomial implements Expression {
     return new Polynomial(res, this.variable);
   }
 
-  opposite() {
+  opposite(): Polynomial {
     return new Polynomial(
       this.coefficients.map((coeff) => -coeff),
       this.variable
     );
   }
 
-  toTex(): string {
-    // if (this.degree == 0) return "" + this.b;
-    // function getMonome(power: number): string {
-    //   if (power === 0) return "";
-    //   if (power === 1) return this.variable;
-    //   else return `${this.variable}^{${power}}`;
-    // }
+  toTree(): Node {
+    const recursive = (cursor: number): Node => {
+      const coeff = this.coefficients[cursor];
+      if (coeff === 0) return recursive(cursor - 1);
+
+      if (cursor === 0) {
+        return new NumberNode(coeff);
+      }
+
+      const monome =
+        cursor > 1
+          ? new PowerNode(
+              new VariableNode(this.variable),
+              new NumberNode(cursor)
+            )
+          : new VariableNode(this.variable);
+
+      let res: Node;
+      if (coeff === 1) res = monome;
+      else if (coeff === -1) res = new OppositeNode(monome);
+      else res = new MultiplyNode(new NumberNode(coeff), monome);
+
+      let nextCoeff;
+      for (let i = cursor - 1; i > -1; i--) {
+        if (this.coefficients[i]) {
+          nextCoeff = this.coefficients[i];
+          break;
+        }
+      }
+      if (nextCoeff) {
+        return new AddNode(res, recursive(cursor - 1));
+      } else {
+        return res;
+      }
+    };
+    return recursive(this.degree);
+  }
 
-    // let s = this.coefficients[this.degree] + this.variable + this.degree > 1 ? `^{${this.degree}}` : "";
+  toTex(): string {
     let s = "";
     for (let i = this.degree; i > -1; i--) {
       const coeff = this.coefficients[i];
@@ -101,10 +145,6 @@ export class Polynomial implements Expression {
       if (i === 0) continue;
       if (i === 1) s += this.variable;
       else s += `${this.variable}^{${i}}`;
-
-      // latex.add(this.coefficients[i]);
-      // s += addLatex(this.coefficients[i]);
-      // s += this.coefficients[i] + this.variable + `^{${i}}`;
     }
     return s;
   }