math-exercises 2.0.2 → 2.0.4

package/lib/math/polynomials/polynomial.js

@@ -1,377 +1,379 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Polynomial = exports.PolynomialConstructor = void 0;
-const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const addNode_1 = require("../../tree/nodes/operators/addNode");
-const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
-const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
-const powerNode_1 = require("../../tree/nodes/operators/powerNode");
-const variableNode_1 = require("../../tree/nodes/variables/variableNode");
-const randint_1 = require("../../math/utils/random/randint");
-const coinFlip_1 = require("../../utils/coinFlip");
-const rational_1 = require("../numbers/rationals/rational");
-const infiniteNode_1 = require("../../tree/nodes/numbers/infiniteNode");
-class PolynomialConstructor {
-    static randomWithOrder(order, variable = "x") {
-        if (order < 0) {
-            throw Error("Order must be a non-negative integer");
-        }
-        const coefficients = [];
-        for (let i = 0; i <= order - 1; i++) {
-            coefficients.push((0, randint_1.randint)(-9, 10));
-        }
-        coefficients.push((0, randint_1.randint)(-9, 10, [0]));
-        return new Polynomial(coefficients, variable);
-    }
-    static random(maxOrder, variable = "x") {
-        if (maxOrder < 0) {
-            throw Error("Order must be a non-negative integer");
-        }
-        const order = (0, randint_1.randint)(1, maxOrder + 1);
-        const coefficients = [];
-        for (let i = 0; i <= order - 1; i++) {
-            coefficients.push((0, randint_1.randint)(-9, 10));
-        }
-        coefficients.push((0, randint_1.randint)(-9, 10, [0]));
-        return new Polynomial(coefficients, variable);
-    }
-    /**
-     *
-     * @param maxOrder included
-     * @param length
-     * @param variable
-     * @returns
-     */
-    static randomWithLength(maxOrder, length, variable = "x") {
-        if (maxOrder < 0) {
-            throw Error("Order must be a non-negative integer");
-        }
-        const order = (0, randint_1.randint)(1, maxOrder + 1);
-        const coefficients = [];
-        const otherTermDegrees = [];
-        for (let i = 0; i < length - 1; i++) {
-            otherTermDegrees.push((0, randint_1.randint)(0, order));
-        }
-        for (let i = 0; i <= order - 1; i++) {
-            if (otherTermDegrees.includes(i))
-                coefficients.push((0, randint_1.randint)(-9, 10, [0]));
-            else
-                coefficients.push(0);
-        }
-        coefficients.push((0, randint_1.randint)(-9, 10, [0]));
-        return new Polynomial(coefficients, variable);
-    }
-    static randomWithLengthAndSameSigns(maxOrder, length, variable = "x") {
-        if (maxOrder < 0) {
-            throw Error("Order must be a non-negative integer");
-        }
-        const order = (0, randint_1.randint)(1, maxOrder + 1);
-        const coefficients = [];
-        const otherTermDegrees = [];
-        const sign = (0, coinFlip_1.coinFlip)() ? 1 : -1;
-        for (let i = 0; i < length - 1; i++) {
-            otherTermDegrees.push((0, randint_1.randint)(0, order));
-        }
-        for (let i = 0; i <= order - 1; i++) {
-            if (otherTermDegrees.includes(i))
-                coefficients.push(sign * (0, randint_1.randint)(0, 10, [0]));
-            else
-                coefficients.push(0);
-        }
-        coefficients.push(sign * (0, randint_1.randint)(0, 10, [0]));
-        return new Polynomial(coefficients, variable);
-    }
-    static randomNoFI(maxOrder, to, length, variable = "x") {
-        if (maxOrder < 0) {
-            throw Error("Order must be a non-negative integer");
-        }
-        const order = (0, randint_1.randint)(1, maxOrder + 1);
-        const fixedLength = length ?? order;
-        if (to === "+\\infty") {
-            return PolynomialConstructor.randomWithLengthAndSameSigns(maxOrder, fixedLength, variable);
-        }
-        //en -infini les degrés de parité différentes doivent avoir un signe différent
-        const coefficients = [];
-        const otherTermDegrees = [];
-        const signEven = (0, coinFlip_1.coinFlip)() ? 1 : -1;
-        for (let i = 0; i < fixedLength - 1; i++) {
-            otherTermDegrees.push((0, randint_1.randint)(0, order));
-        }
-        for (let i = 0; i <= order - 1; i++) {
-            if (otherTermDegrees.includes(i))
-                coefficients.push((i % 2 === 0 ? signEven : -signEven) * (0, randint_1.randint)(0, 10, [0]));
-            else
-                coefficients.push(0);
-        }
-        coefficients.push((order % 2 === 0 ? signEven : -signEven) * (0, randint_1.randint)(0, 10, [0]));
-        return new Polynomial(coefficients, variable);
-    }
-}
-exports.PolynomialConstructor = PolynomialConstructor;
-class Polynomial {
-    /**
-     *
-     * @param coefficients coefficients[i] est le coeff de x^i
-     * @param variable
-     */
-    constructor(coefficients, variable = "x") {
-        if (coefficients.length === 0)
-            throw Error("coeffs must be not null");
-        if (coefficients.length > 1 &&
-            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;
-    }
-    equals(P) {
-        return (P.degree === this.degree &&
-            this.coefficients.every((coeff, i) => coeff === P.coefficients[i]));
-    }
-    getRoots() {
-        const roots = [];
-        if (this.degree === 0) {
-            return this.coefficients[0] === 0 ? [0] : [];
-        }
-        if (this.degree === 1) {
-            // Polynôme de degré 1 : ax + b = 0
-            const a = this.coefficients[1];
-            const b = this.coefficients[0];
-            if (a !== 0) {
-                roots.push(-b / a);
-            }
-        }
-        else if (this.degree === 2) {
-            // Polynôme de degré 2 : ax^2 + bx + c = 0
-            const a = this.coefficients[2];
-            const b = this.coefficients[1];
-            const c = this.coefficients[0];
-            const delta = b * b - 4 * a * c;
-            if (delta > 0) {
-                roots.push((-b + Math.sqrt(delta)) / (2 * a));
-                roots.push((-b - Math.sqrt(delta)) / (2 * a));
-            }
-            else if (delta === 0) {
-                roots.push(-b / (2 * a));
-            }
-        }
-        else {
-            //méthode de Newton-Raphson ou des bibliothèques de calcul symbolique pour obtenir les racines.
-            throw Error("general roots not implemented yet");
-        }
-        return roots.sort((a, b) => a - b);
-    }
-    add(P) {
-        if (typeof P === "number") {
-            return new Polynomial([this.coefficients[0] + P, ...this.coefficients.slice(1)], this.variable);
-        }
-        if (P.variable !== this.variable)
-            throw Error("Can't add two polynomials with different variables");
-        const maxDegree = Math.max(P.degree, this.degree);
-        const res = [];
-        for (let i = 0; i < maxDegree + 1; i++) {
-            res[i] = (P.coefficients[i] ?? 0) + (this.coefficients[i] ?? 0);
-        }
-        let firstNonZeroIndex = res.length;
-        for (let i = res.length - 1; i > -1; i--) {
-            if (res[i] !== 0)
-                break;
-            firstNonZeroIndex = i;
-        }
-        let coeffs = res.slice(0, firstNonZeroIndex);
-        if (!coeffs.length)
-            coeffs = [0];
-        return new Polynomial(coeffs, this.variable);
-    }
-    times(nb) {
-        if (nb === 0)
-            return new Polynomial([0], this.variable);
-        return new Polynomial(this.coefficients.map((coeff) => coeff * nb), this.variable);
-    }
-    multiply(Q) {
-        if (Q.variable !== this.variable)
-            throw Error("Can't multiply two polynomials with different variables");
-        const p = this.degree;
-        const q = Q.degree;
-        const res = Array.apply(0, new Array(this.degree)).map((i) => 0);
-        for (let k = 0; k <= p + q; k++) {
-            let sum = 0;
-            for (let m = 0; m <= k; m++) {
-                sum += (this.coefficients[m] || 0) * (Q.coefficients[k - m] || 0);
-            }
-            res[k] = sum;
-        }
-        let firstNonZeroIndex = res.length;
-        for (let i = res.length - 1; i > -1; i--) {
-            if (res[i] !== 0)
-                break;
-            firstNonZeroIndex = i;
-        }
-        return new Polynomial(res.slice(0, firstNonZeroIndex), this.variable);
-    }
-    scalarDivide(n) {
-        return new Polynomial(this.coefficients.map((coeff) => coeff / n), this.variable);
-    }
-    opposite() {
-        return new Polynomial(this.coefficients.map((coeff) => -coeff), this.variable);
-    }
-    derivate() {
-        if (this.coefficients.length === 1)
-            return new Polynomial([0], this.variable);
-        const res = [];
-        for (let i = 1; i < this.coefficients.length; i++)
-            res.push(i * this.coefficients[i]);
-        return new Polynomial(res, this.variable);
-    }
-    // integrate(): Polynomial {
-    //   const newCoefficients = this.coefficients.map(
-    //     (coeff, exp) => coeff / (exp + 1),
-    //   );
-    //   newCoefficients.unshift(0);
-    //   return new Polynomial(newCoefficients, this.variable);
-    // }
-    integrateToNode(opts) {
-        let integralPolynomial = new variableNode_1.VariableNode("C");
-        for (let i = 0; i < this.degree + 1; i++) {
-            const coeff = this.coefficients[i];
-            if (coeff === 0)
-                continue;
-            const nodeCoeff = new rational_1.Rational(coeff, i + 1).simplify().toTree();
-            const powerNode = i + 1 === 1
-                ? new variableNode_1.VariableNode("x")
-                : new powerNode_1.PowerNode(new variableNode_1.VariableNode("x"), new numberNode_1.NumberNode(i + 1), opts);
-            let terme;
-            if (nodeCoeff.toTex() === "1")
-                terme = powerNode;
-            else if (nodeCoeff.toTex() === "-1")
-                terme = new oppositeNode_1.OppositeNode(powerNode, opts);
-            else {
-                terme = new multiplyNode_1.MultiplyNode(nodeCoeff, i + 1 === 1
-                    ? new variableNode_1.VariableNode("x")
-                    : new powerNode_1.PowerNode(new variableNode_1.VariableNode("x"), new numberNode_1.NumberNode(i + 1), opts), opts);
-            }
-            integralPolynomial = new addNode_1.AddNode(terme, integralPolynomial, opts);
-        }
-        return integralPolynomial;
-    }
-    calculate(x) {
-        let res = 0;
-        for (let i = 0; i < this.coefficients.length; i++)
-            res += x ** i * this.coefficients[i];
-        return res;
-    }
-    getLimit(to) {
-        const leadingCoeff = this.coefficients[this.coefficients.length - 1];
-        if (this.degree === 0)
-            return leadingCoeff + "";
-        if (to === "+\\infty") {
-            if (leadingCoeff > 0)
-                return "+\\infty";
-            return "-\\infty";
-        }
-        else {
-            if (leadingCoeff > 0) {
-                if (this.degree % 2 === 0)
-                    return "+\\infty";
-                return "-\\infty";
-            }
-            else {
-                if (this.degree % 2 === 0)
-                    return "-\\infty";
-                return "+\\infty";
-            }
-        }
-    }
-    getLimitNode(to) {
-        const leadingCoeff = this.coefficients[this.coefficients.length - 1];
-        if (this.degree === 0)
-            return new numberNode_1.NumberNode(leadingCoeff);
-        if (to === "+\\infty") {
-            if (leadingCoeff > 0)
-                return infiniteNode_1.PlusInfinityNode;
-            return infiniteNode_1.MinusInfinityNode;
-        }
-        else {
-            if (leadingCoeff > 0) {
-                if (this.degree % 2 === 0)
-                    return infiniteNode_1.PlusInfinityNode;
-                return infiniteNode_1.MinusInfinityNode;
-            }
-            else {
-                if (this.degree % 2 === 0)
-                    return infiniteNode_1.MinusInfinityNode;
-                return infiniteNode_1.PlusInfinityNode;
-            }
-        }
-    }
-    toTree(opts) {
-        const recursive = (cursor) => {
-            const coeff = this.coefficients[cursor];
-            if (coeff === 0)
-                return recursive(cursor - 1);
-            if (cursor === 0) {
-                return new numberNode_1.NumberNode(coeff);
-            }
-            const monome = cursor > 1
-                ? new powerNode_1.PowerNode(new variableNode_1.VariableNode(this.variable), new numberNode_1.NumberNode(cursor), opts)
-                : new variableNode_1.VariableNode(this.variable);
-            let 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, opts);
-            let nextCoeff;
-            for (let 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);
-    }
-    toTex() {
-        let s = "";
-        for (let i = this.degree; i > -1; i--) {
-            const coeff = this.coefficients[i];
-            if (coeff === 0)
-                continue;
-            if (i === 0)
-                s += coeff > 0 ? `+${coeff}` : coeff;
-            else if (i === this.degree) {
-                s += coeff === 1 ? "" : coeff === -1 ? "-" : coeff;
-            }
-            else {
-                s +=
-                    coeff === 1
-                        ? "+"
-                        : coeff === -1
-                            ? "-"
-                            : coeff > 0
-                                ? `+${coeff}`
-                                : coeff;
-            }
-            //x^n
-            if (i === 0)
-                continue;
-            if (i === 1)
-                s += this.variable;
-            else
-                s += `${this.variable}^{${i}}`;
-        }
-        return s;
-    }
-    toString() {
-        return this.toTex();
-    }
-}
-exports.Polynomial = Polynomial;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Polynomial = exports.PolynomialConstructor = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const randint_1 = require("../../math/utils/random/randint");
+const coinFlip_1 = require("../../utils/coinFlip");
+const rational_1 = require("../numbers/rationals/rational");
+const infiniteNode_1 = require("../../tree/nodes/numbers/infiniteNode");
+class PolynomialConstructor {
+    static randomWithOrder(order, variable = "x") {
+        if (order < 0) {
+            throw Error("Order must be a non-negative integer");
+        }
+        const coefficients = [];
+        for (let i = 0; i <= order - 1; i++) {
+            coefficients.push((0, randint_1.randint)(-9, 10));
+        }
+        coefficients.push((0, randint_1.randint)(-9, 10, [0]));
+        return new Polynomial(coefficients, variable);
+    }
+    static random(maxOrder, variable = "x") {
+        if (maxOrder < 0) {
+            throw Error("Order must be a non-negative integer");
+        }
+        const order = (0, randint_1.randint)(1, maxOrder + 1);
+        const coefficients = [];
+        for (let i = 0; i <= order - 1; i++) {
+            coefficients.push((0, randint_1.randint)(-9, 10));
+        }
+        coefficients.push((0, randint_1.randint)(-9, 10, [0]));
+        return new Polynomial(coefficients, variable);
+    }
+    /**
+     *
+     * @param maxOrder included
+     * @param length
+     * @param variable
+     * @returns
+     */
+    static randomWithLength(maxOrder, length, variable = "x") {
+        if (maxOrder < 0) {
+            throw Error("Order must be a non-negative integer");
+        }
+        const order = (0, randint_1.randint)(1, maxOrder + 1);
+        const coefficients = [];
+        const otherTermDegrees = [];
+        for (let i = 0; i < length - 1; i++) {
+            otherTermDegrees.push((0, randint_1.randint)(0, order));
+        }
+        for (let i = 0; i <= order - 1; i++) {
+            if (otherTermDegrees.includes(i))
+                coefficients.push((0, randint_1.randint)(-9, 10, [0]));
+            else
+                coefficients.push(0);
+        }
+        coefficients.push((0, randint_1.randint)(-9, 10, [0]));
+        return new Polynomial(coefficients, variable);
+    }
+    static randomWithLengthAndSameSigns(maxOrder, length, variable = "x") {
+        if (maxOrder < 0) {
+            throw Error("Order must be a non-negative integer");
+        }
+        const order = (0, randint_1.randint)(1, maxOrder + 1);
+        const coefficients = [];
+        const otherTermDegrees = [];
+        const sign = (0, coinFlip_1.coinFlip)() ? 1 : -1;
+        for (let i = 0; i < length - 1; i++) {
+            otherTermDegrees.push((0, randint_1.randint)(0, order));
+        }
+        for (let i = 0; i <= order - 1; i++) {
+            if (otherTermDegrees.includes(i))
+                coefficients.push(sign * (0, randint_1.randint)(0, 10, [0]));
+            else
+                coefficients.push(0);
+        }
+        coefficients.push(sign * (0, randint_1.randint)(0, 10, [0]));
+        return new Polynomial(coefficients, variable);
+    }
+    static randomNoFI(maxOrder, to, length, variable = "x") {
+        if (maxOrder < 0) {
+            throw Error("Order must be a non-negative integer");
+        }
+        const order = (0, randint_1.randint)(1, maxOrder + 1);
+        const fixedLength = length ?? order;
+        if (to === "+\\infty") {
+            return PolynomialConstructor.randomWithLengthAndSameSigns(maxOrder, fixedLength, variable);
+        }
+        //en -infini les degrés de parité différentes doivent avoir un signe différent
+        const coefficients = [];
+        const otherTermDegrees = [];
+        const signEven = (0, coinFlip_1.coinFlip)() ? 1 : -1;
+        for (let i = 0; i < fixedLength - 1; i++) {
+            otherTermDegrees.push((0, randint_1.randint)(0, order));
+        }
+        for (let i = 0; i <= order - 1; i++) {
+            if (otherTermDegrees.includes(i))
+                coefficients.push((i % 2 === 0 ? signEven : -signEven) * (0, randint_1.randint)(0, 10, [0]));
+            else
+                coefficients.push(0);
+        }
+        coefficients.push((order % 2 === 0 ? signEven : -signEven) * (0, randint_1.randint)(0, 10, [0]));
+        return new Polynomial(coefficients, variable);
+    }
+}
+exports.PolynomialConstructor = PolynomialConstructor;
+class Polynomial {
+    /**
+     *
+     * @param coefficients coefficients[i] est le coeff de x^i
+     * @param variable
+     */
+    constructor(coefficients, variable = "x") {
+        if (coefficients.length === 0)
+            throw Error("coeffs must be not null");
+        if (coefficients.length > 1 &&
+            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;
+    }
+    equals(P) {
+        return (P.degree === this.degree &&
+            this.coefficients.every((coeff, i) => coeff === P.coefficients[i]));
+    }
+    getRoots() {
+        const roots = [];
+        if (this.degree === 0) {
+            return this.coefficients[0] === 0 ? [0] : [];
+        }
+        if (this.degree === 1) {
+            // Polynôme de degré 1 : ax + b = 0
+            const a = this.coefficients[1];
+            const b = this.coefficients[0];
+            if (a !== 0) {
+                roots.push(-b / a);
+            }
+        }
+        else if (this.degree === 2) {
+            // Polynôme de degré 2 : ax^2 + bx + c = 0
+            const a = this.coefficients[2];
+            const b = this.coefficients[1];
+            const c = this.coefficients[0];
+            const delta = b * b - 4 * a * c;
+            if (delta > 0) {
+                roots.push((-b + Math.sqrt(delta)) / (2 * a));
+                roots.push((-b - Math.sqrt(delta)) / (2 * a));
+            }
+            else if (delta === 0) {
+                roots.push(-b / (2 * a));
+            }
+        }
+        else {
+            //méthode de Newton-Raphson ou des bibliothèques de calcul symbolique pour obtenir les racines.
+            throw Error("general roots not implemented yet");
+        }
+        return roots.sort((a, b) => a - b);
+    }
+    add(P) {
+        if (typeof P === "number") {
+            return new Polynomial([this.coefficients[0] + P, ...this.coefficients.slice(1)], this.variable);
+        }
+        if (P.variable !== this.variable)
+            throw Error("Can't add two polynomials with different variables");
+        const maxDegree = Math.max(P.degree, this.degree);
+        const res = [];
+        for (let i = 0; i < maxDegree + 1; i++) {
+            res[i] = (P.coefficients[i] ?? 0) + (this.coefficients[i] ?? 0);
+        }
+        let firstNonZeroIndex = res.length;
+        for (let i = res.length - 1; i > -1; i--) {
+            if (res[i] !== 0)
+                break;
+            firstNonZeroIndex = i;
+        }
+        let coeffs = res.slice(0, firstNonZeroIndex);
+        if (!coeffs.length)
+            coeffs = [0];
+        return new Polynomial(coeffs, this.variable);
+    }
+    times(nb) {
+        if (nb === 0)
+            return new Polynomial([0], this.variable);
+        return new Polynomial(this.coefficients.map((coeff) => coeff * nb), this.variable);
+    }
+    multiply(Q) {
+        if (Q.variable !== this.variable)
+            throw Error("Can't multiply two polynomials with different variables");
+        const p = this.degree;
+        const q = Q.degree;
+        const res = Array.apply(0, new Array(this.degree)).map((i) => 0);
+        for (let k = 0; k <= p + q; k++) {
+            let sum = 0;
+            for (let m = 0; m <= k; m++) {
+                sum += (this.coefficients[m] || 0) * (Q.coefficients[k - m] || 0);
+            }
+            res[k] = sum;
+        }
+        let firstNonZeroIndex = res.length;
+        for (let i = res.length - 1; i > -1; i--) {
+            if (res[i] !== 0)
+                break;
+            firstNonZeroIndex = i;
+        }
+        return new Polynomial(res.slice(0, firstNonZeroIndex), this.variable);
+    }
+    scalarDivide(n) {
+        return new Polynomial(this.coefficients.map((coeff) => coeff / n), this.variable);
+    }
+    opposite() {
+        return new Polynomial(this.coefficients.map((coeff) => -coeff), this.variable);
+    }
+    derivate() {
+        if (this.coefficients.length === 1)
+            return new Polynomial([0], this.variable);
+        const res = [];
+        for (let i = 1; i < this.coefficients.length; i++)
+            res.push(i * this.coefficients[i]);
+        return new Polynomial(res, this.variable);
+    }
+    // integrate(): Polynomial {
+    //   const newCoefficients = this.coefficients.map(
+    //     (coeff, exp) => coeff / (exp + 1),
+    //   );
+    //   newCoefficients.unshift(0);
+    //   return new Polynomial(newCoefficients, this.variable);
+    // }
+    integrateToNode(opts) {
+        let integralPolynomial = new variableNode_1.VariableNode("C");
+        const varNode = new variableNode_1.VariableNode(this.variable);
+        for (let i = 0; i < this.degree + 1; i++) {
+            const coeff = this.coefficients[i];
+            if (coeff === 0)
+                continue;
+            const nodeCoeff = new rational_1.Rational(coeff, i + 1).simplify().toTree();
+            const powerNode = i + 1 === 1
+                ? varNode
+                : new powerNode_1.PowerNode(varNode, new numberNode_1.NumberNode(i + 1), opts);
+            let terme;
+            const coeffTex = nodeCoeff.toTex();
+            if (coeffTex === "1")
+                terme = powerNode;
+            else if (coeffTex === "-1")
+                terme = new oppositeNode_1.OppositeNode(powerNode, opts);
+            else {
+                terme = new multiplyNode_1.MultiplyNode(nodeCoeff, i + 1 === 1
+                    ? varNode
+                    : new powerNode_1.PowerNode(varNode, new numberNode_1.NumberNode(i + 1), opts), opts);
+            }
+            integralPolynomial = new addNode_1.AddNode(terme, integralPolynomial, opts);
+        }
+        return integralPolynomial;
+    }
+    calculate(x) {
+        let res = 0;
+        for (let i = 0; i < this.coefficients.length; i++)
+            res += x ** i * this.coefficients[i];
+        return res;
+    }
+    getLimit(to) {
+        const leadingCoeff = this.coefficients[this.coefficients.length - 1];
+        if (this.degree === 0)
+            return leadingCoeff + "";
+        if (to === "+\\infty") {
+            if (leadingCoeff > 0)
+                return "+\\infty";
+            return "-\\infty";
+        }
+        else {
+            if (leadingCoeff > 0) {
+                if (this.degree % 2 === 0)
+                    return "+\\infty";
+                return "-\\infty";
+            }
+            else {
+                if (this.degree % 2 === 0)
+                    return "-\\infty";
+                return "+\\infty";
+            }
+        }
+    }
+    getLimitNode(to) {
+        const leadingCoeff = this.coefficients[this.coefficients.length - 1];
+        if (this.degree === 0)
+            return new numberNode_1.NumberNode(leadingCoeff);
+        if (to === "+\\infty") {
+            if (leadingCoeff > 0)
+                return infiniteNode_1.PlusInfinityNode;
+            return infiniteNode_1.MinusInfinityNode;
+        }
+        else {
+            if (leadingCoeff > 0) {
+                if (this.degree % 2 === 0)
+                    return infiniteNode_1.PlusInfinityNode;
+                return infiniteNode_1.MinusInfinityNode;
+            }
+            else {
+                if (this.degree % 2 === 0)
+                    return infiniteNode_1.MinusInfinityNode;
+                return infiniteNode_1.PlusInfinityNode;
+            }
+        }
+    }
+    toTree(opts) {
+        const recursive = (cursor) => {
+            const coeff = this.coefficients[cursor];
+            if (coeff === 0)
+                return recursive(cursor - 1);
+            if (cursor === 0) {
+                return new numberNode_1.NumberNode(coeff);
+            }
+            const monome = cursor > 1
+                ? new powerNode_1.PowerNode(new variableNode_1.VariableNode(this.variable), new numberNode_1.NumberNode(cursor), opts)
+                : new variableNode_1.VariableNode(this.variable);
+            let 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, opts);
+            let nextCoeff;
+            for (let 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);
+    }
+    toTex() {
+        let s = "";
+        for (let i = this.degree; i > -1; i--) {
+            const coeff = this.coefficients[i];
+            if (coeff === 0)
+                continue;
+            if (i === 0)
+                s += coeff > 0 ? `+${coeff}` : coeff;
+            else if (i === this.degree) {
+                s += coeff === 1 ? "" : coeff === -1 ? "-" : coeff;
+            }
+            else {
+                s +=
+                    coeff === 1
+                        ? "+"
+                        : coeff === -1
+                            ? "-"
+                            : coeff > 0
+                                ? `+${coeff}`
+                                : coeff;
+            }
+            //x^n
+            if (i === 0)
+                continue;
+            if (i === 1)
+                s += this.variable;
+            else
+                s += `${this.variable}^{${i}}`;
+        }
+        return s;
+    }
+    toString() {
+        return this.toTex();
+    }
+}
+exports.Polynomial = Polynomial;