math-exercises 1.3.54 → 1.3.56

package/lib/math/polynomials/polynomial.d.ts

@@ -1,29 +1,29 @@
-import { Node } from '../../tree/nodes/node';
-export declare function createRandomPolynomialWithOrder(order: number, variable?: string): Polynomial;
-export declare class Polynomial {
-    degree: number;
-    variable: string;
-    /**
-     * coefficients[i] est le coeff de x^i
-     */
-    coefficients: number[];
-    /**
-     *
-     * @param coefficients coefficients[i] est le coeff de x^i
-     * @param variable
-     */
-    constructor(coefficients: number[], variable?: string);
-    equals(P: Polynomial): boolean;
-    getRoots(): number[];
-    add(P: Polynomial): Polynomial;
-    times(nb: number): Polynomial;
-    multiply(Q: Polynomial): Polynomial;
-    opposite(): Polynomial;
-    derivate(): Polynomial;
-    integrate(): Polynomial;
-    calculate(x: number): number;
-    toTree(): Node;
-    toTex(): string;
-    toString(): string;
-}
+import { Node } from '../../tree/nodes/node';
+export declare function createRandomPolynomialWithOrder(order: number, variable?: string): Polynomial;
+export declare class Polynomial {
+    degree: number;
+    variable: string;
+    /**
+     * coefficients[i] est le coeff de x^i
+     */
+    coefficients: number[];
+    /**
+     *
+     * @param coefficients coefficients[i] est le coeff de x^i
+     * @param variable
+     */
+    constructor(coefficients: number[], variable?: string);
+    equals(P: Polynomial): boolean;
+    getRoots(): number[];
+    add(P: Polynomial): Polynomial;
+    times(nb: number): Polynomial;
+    multiply(Q: Polynomial): Polynomial;
+    opposite(): Polynomial;
+    derivate(): Polynomial;
+    integrate(): Polynomial;
+    calculate(x: number): number;
+    toTree(): Node;
+    toTex(): string;
+    toString(): string;
+}
 //# sourceMappingURL=polynomial.d.ts.map

package/lib/math/polynomials/polynomial.js

@@ -1,184 +1,184 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Polynomial = exports.createRandomPolynomialWithOrder = 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");
-function createRandomPolynomialWithOrder(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);
-}
-exports.createRandomPolynomialWithOrder = createRandomPolynomialWithOrder;
-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[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 === 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.
-        }
-        return roots.sort((a, b) => a - b);
-    }
-    add(P) {
-        var _a, _b;
-        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 - 1
-            : Math.max(P.degree, this.degree);
-        const res = [];
-        for (let i = 0; i < newDegree + 1; i++) {
-            res[i] = ((_a = P.coefficients[i]) !== null && _a !== void 0 ? _a : 0) + ((_b = this.coefficients[i]) !== null && _b !== void 0 ? _b : 0);
-        }
-        return new Polynomial(res, this.variable);
-    }
-    times(nb) {
-        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;
-        }
-        return new Polynomial(res, this.variable);
-    }
-    opposite() {
-        return new Polynomial(this.coefficients.map((coeff) => -coeff), this.variable);
-    }
-    derivate() {
-        const res = [];
-        for (let i = 1; i < this.coefficients.length; i++)
-            res.push(i * this.coefficients[i]);
-        return new Polynomial(res, this.variable);
-    }
-    integrate() {
-        const newCoefficients = this.coefficients.map((coeff, exp) => coeff / (exp + 1));
-        newCoefficients.unshift(0);
-        return new Polynomial(newCoefficients, this.variable);
-    }
-    calculate(x) {
-        let res = 0;
-        for (let i = 0; i < this.coefficients.length; i++)
-            res += x ** i * this.coefficients[i];
-        return res;
-    }
-    toTree() {
-        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))
-                : 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);
-            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.createRandomPolynomialWithOrder = 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");
+function createRandomPolynomialWithOrder(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);
+}
+exports.createRandomPolynomialWithOrder = createRandomPolynomialWithOrder;
+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[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 === 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.
+        }
+        return roots.sort((a, b) => a - b);
+    }
+    add(P) {
+        var _a, _b;
+        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 - 1
+            : Math.max(P.degree, this.degree);
+        const res = [];
+        for (let i = 0; i < newDegree + 1; i++) {
+            res[i] = ((_a = P.coefficients[i]) !== null && _a !== void 0 ? _a : 0) + ((_b = this.coefficients[i]) !== null && _b !== void 0 ? _b : 0);
+        }
+        return new Polynomial(res, this.variable);
+    }
+    times(nb) {
+        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;
+        }
+        return new Polynomial(res, this.variable);
+    }
+    opposite() {
+        return new Polynomial(this.coefficients.map((coeff) => -coeff), this.variable);
+    }
+    derivate() {
+        const res = [];
+        for (let i = 1; i < this.coefficients.length; i++)
+            res.push(i * this.coefficients[i]);
+        return new Polynomial(res, this.variable);
+    }
+    integrate() {
+        const newCoefficients = this.coefficients.map((coeff, exp) => coeff / (exp + 1));
+        newCoefficients.unshift(0);
+        return new Polynomial(newCoefficients, this.variable);
+    }
+    calculate(x) {
+        let res = 0;
+        for (let i = 0; i < this.coefficients.length; i++)
+            res += x ** i * this.coefficients[i];
+        return res;
+    }
+    toTree() {
+        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))
+                : 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);
+            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;

package/lib/math/polynomials/trinom.d.ts

@@ -1,24 +1,24 @@
-import { Node } from '../../tree/nodes/node';
-import { NumberNode } from '../../tree/nodes/numbers/numberNode';
-import { MathSet } from '../sets/mathSet';
-import { Polynomial } from './polynomial';
-export declare abstract class TrinomConstructor {
-    static random(domainA?: MathSet, domainB?: MathSet, domainC?: MathSet): Trinom;
-    static randomCanonical(domainA?: MathSet, domainAlpha?: MathSet, domainBeta?: MathSet): Trinom;
-}
-export declare class Trinom extends Polynomial {
-    a: number;
-    b: number;
-    c: number;
-    variable: string;
-    constructor(a: number, b: number, c: number, variable?: string);
-    getDelta(): number;
-    getDeltaNode(): NumberNode;
-    getAlpha(): number;
-    getAlphaNode(): Node;
-    getBeta(): number;
-    getBetaNode(): Node;
-    getCanonicalForm(): Node;
-    getSommet(): string;
-}
+import { Node } from '../../tree/nodes/node';
+import { NumberNode } from '../../tree/nodes/numbers/numberNode';
+import { MathSet } from '../sets/mathSet';
+import { Polynomial } from './polynomial';
+export declare abstract class TrinomConstructor {
+    static random(domainA?: MathSet, domainB?: MathSet, domainC?: MathSet): Trinom;
+    static randomCanonical(domainA?: MathSet, domainAlpha?: MathSet, domainBeta?: MathSet): Trinom;
+}
+export declare class Trinom extends Polynomial {
+    a: number;
+    b: number;
+    c: number;
+    variable: string;
+    constructor(a: number, b: number, c: number, variable?: string);
+    getDelta(): number;
+    getDeltaNode(): NumberNode;
+    getAlpha(): number;
+    getAlphaNode(): Node;
+    getBeta(): number;
+    getBetaNode(): Node;
+    getCanonicalForm(): Node;
+    getSommet(): string;
+}
 //# sourceMappingURL=trinom.d.ts.map

package/lib/math/polynomials/trinom.js

@@ -1,67 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Trinom = exports.TrinomConstructor = void 0;
-const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-const addNode_1 = require("../../tree/nodes/operators/addNode");
-const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
-const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
-const powerNode_1 = require("../../tree/nodes/operators/powerNode");
-const substractNode_1 = require("../../tree/nodes/operators/substractNode");
-const variableNode_1 = require("../../tree/nodes/variables/variableNode");
-const simplify_1 = require("../../tree/parsers/simplify");
-const point_1 = require("../geometry/point");
-const integer_1 = require("../numbers/integer/integer");
-const discreteSet_1 = require("../sets/discreteSet");
-const intervals_1 = require("../sets/intervals/intervals");
-const polynomial_1 = require("./polynomial");
-class TrinomConstructor {
-    static random(domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval('[[-10; 10]]'), domainC = new intervals_1.Interval('[[-10; 10]]')) {
-        const a = domainA.getRandomElement();
-        const b = domainB.getRandomElement();
-        const c = domainC.getRandomElement();
-        return new Trinom(a.value, b.value, c.value);
-    }
-    static randomCanonical(domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainAlpha = new intervals_1.Interval('[[-10; 10]]'), domainBeta = new intervals_1.Interval('[[-10; 10]]')) {
-        const a = domainA.getRandomElement();
-        const alpha = domainAlpha.getRandomElement();
-        const beta = domainBeta.getRandomElement();
-        const b = -2 * a.value * alpha.value;
-        const c = a.value * alpha.value ** 2 + beta.value;
-        return new Trinom(a.value, b, c);
-    }
-}
-exports.TrinomConstructor = TrinomConstructor;
-class Trinom extends polynomial_1.Polynomial {
-    constructor(a, b, c, variable = 'x') {
-        super([c, b, a], variable);
-        this.a = a;
-        this.b = b;
-        this.c = c;
-        this.variable = variable;
-    }
-    getDelta() {
-        return this.b ** 2 - 4 * this.a * this.c;
-    }
-    getDeltaNode() {
-        return new numberNode_1.NumberNode(this.getDelta());
-    }
-    getAlpha() {
-        return -this.b / (2 * this.a);
-    }
-    getAlphaNode() {
-        return (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(-this.b), new numberNode_1.NumberNode(2 * this.a)));
-    }
-    getBeta() {
-        return -this.getDelta() / (4 * this.a);
-    }
-    getBetaNode() {
-        return (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(-this.getDelta()), new numberNode_1.NumberNode(4 * this.a)));
-    }
-    getCanonicalForm() {
-        return (0, simplify_1.simplifyNode)(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(this.a), new powerNode_1.PowerNode(new substractNode_1.SubstractNode(new variableNode_1.VariableNode(this.variable), this.getAlphaNode()), new numberNode_1.NumberNode(2))), new numberNode_1.NumberNode(this.getBeta())));
-    }
-    getSommet() {
-        return new point_1.Point('S', this.getAlphaNode(), this.getBetaNode()).toTexWithCoords();
-    }
-}
-exports.Trinom = Trinom;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trinom = exports.TrinomConstructor = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const simplify_1 = require("../../tree/parsers/simplify");
+const point_1 = require("../geometry/point");
+const integer_1 = require("../numbers/integer/integer");
+const discreteSet_1 = require("../sets/discreteSet");
+const intervals_1 = require("../sets/intervals/intervals");
+const polynomial_1 = require("./polynomial");
+class TrinomConstructor {
+    static random(domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval('[[-10; 10]]'), domainC = new intervals_1.Interval('[[-10; 10]]')) {
+        const a = domainA.getRandomElement();
+        const b = domainB.getRandomElement();
+        const c = domainC.getRandomElement();
+        return new Trinom(a.value, b.value, c.value);
+    }
+    static randomCanonical(domainA = new intervals_1.Interval('[[-10; 10]]').difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainAlpha = new intervals_1.Interval('[[-10; 10]]'), domainBeta = new intervals_1.Interval('[[-10; 10]]')) {
+        const a = domainA.getRandomElement();
+        const alpha = domainAlpha.getRandomElement();
+        const beta = domainBeta.getRandomElement();
+        const b = -2 * a.value * alpha.value;
+        const c = a.value * alpha.value ** 2 + beta.value;
+        return new Trinom(a.value, b, c);
+    }
+}
+exports.TrinomConstructor = TrinomConstructor;
+class Trinom extends polynomial_1.Polynomial {
+    constructor(a, b, c, variable = 'x') {
+        super([c, b, a], variable);
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.variable = variable;
+    }
+    getDelta() {
+        return this.b ** 2 - 4 * this.a * this.c;
+    }
+    getDeltaNode() {
+        return new numberNode_1.NumberNode(this.getDelta());
+    }
+    getAlpha() {
+        return -this.b / (2 * this.a);
+    }
+    getAlphaNode() {
+        return (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(-this.b), new numberNode_1.NumberNode(2 * this.a)));
+    }
+    getBeta() {
+        return -this.getDelta() / (4 * this.a);
+    }
+    getBetaNode() {
+        return (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(-this.getDelta()), new numberNode_1.NumberNode(4 * this.a)));
+    }
+    getCanonicalForm() {
+        return (0, simplify_1.simplifyNode)(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(this.a), new powerNode_1.PowerNode(new substractNode_1.SubstractNode(new variableNode_1.VariableNode(this.variable), this.getAlphaNode()), new numberNode_1.NumberNode(2))), new numberNode_1.NumberNode(this.getBeta())));
+    }
+    getSommet() {
+        return new point_1.Point('S', this.getAlphaNode(), this.getBetaNode()).toTexWithCoords();
+    }
+}
+exports.Trinom = Trinom;

package/lib/math/sequences/arithmeticSequence.js

@@ -1 +1 @@
-"use strict";
+"use strict";

package/lib/math/sequences/geometricSequence.d.ts

@@ -1,4 +1,4 @@
-export declare abstract class GeometricSequenceConstructor {
-    static random(): void;
-}
+export declare abstract class GeometricSequenceConstructor {
+    static random(): void;
+}
 //# sourceMappingURL=geometricSequence.d.ts.map

package/lib/math/sequences/geometricSequence.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeometricSequenceConstructor = void 0;
-class GeometricSequenceConstructor {
-    static random() {
-    }
-}
-exports.GeometricSequenceConstructor = GeometricSequenceConstructor;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometricSequenceConstructor = void 0;
+class GeometricSequenceConstructor {
+    static random() {
+    }
+}
+exports.GeometricSequenceConstructor = GeometricSequenceConstructor;