math-exercises 1.3.32 → 1.3.34

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

@@ -1,26 +1,26 @@
-import { Node } from '../../tree/nodes/node';
-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(): void;
-    add(P: Polynomial): Polynomial;
-    times(nb: number): Polynomial;
-    multiply(Q: Polynomial): Polynomial;
-    opposite(): Polynomial;
-    derivate(): Polynomial;
-    toTree(): Node;
-    toTex(): string;
-    toString(): string;
-}
+import { Node } from '../../tree/nodes/node';
+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(): void;
+    add(P: Polynomial): Polynomial;
+    times(nb: number): Polynomial;
+    multiply(Q: Polynomial): Polynomial;
+    opposite(): Polynomial;
+    derivate(): Polynomial;
+    toTree(): Node;
+    toTex(): string;
+    toString(): string;
+}
 //# sourceMappingURL=polynomial.d.ts.map

package/lib/math/polynomials/polynomial.js

@@ -1,131 +1,131 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Polynomial = 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");
-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() { }
-    add(P) {
-        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] = P.coefficients[i] + this.coefficients[i];
-        }
-        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);
-    }
-    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 = 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");
+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() { }
+    add(P) {
+        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] = P.coefficients[i] + this.coefficients[i];
+        }
+        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);
+    }
+    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/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;

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

@@ -1,23 +1,23 @@
-import { Node } from '../../tree/nodes/node';
-import { Integer } from '../numbers/integer/integer';
-declare enum SequenceType {
-    arithmetic = 0,
-    geometric = 1,
-    other = 2
-}
-export declare class Sequence {
-    type: SequenceType;
-    firstRank: Integer;
-    firstTerm: Node;
-    recurrenceFormula?: string;
-    explicitFormula?: string;
-    constructor({ type, recurrenceFormula, explicitFormula, firstRank, firstTerm, }: {
-        type: SequenceType;
-        recurrenceFormula?: string;
-        explicitFormula?: string;
-        firstRank: Integer;
-        firstTerm: Node;
-    });
-}
-export {};
+import { Node } from '../../tree/nodes/node';
+import { Integer } from '../numbers/integer/integer';
+declare enum SequenceType {
+    arithmetic = 0,
+    geometric = 1,
+    other = 2
+}
+export declare class Sequence {
+    type: SequenceType;
+    firstRank: Integer;
+    firstTerm: Node;
+    recurrenceFormula?: string;
+    explicitFormula?: string;
+    constructor({ type, recurrenceFormula, explicitFormula, firstRank, firstTerm, }: {
+        type: SequenceType;
+        recurrenceFormula?: string;
+        explicitFormula?: string;
+        firstRank: Integer;
+        firstTerm: Node;
+    });
+}
+export {};
 //# sourceMappingURL=sequence.d.ts.map

package/lib/math/sequences/sequence.js

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sequence = void 0;
-const integer_1 = require("../numbers/integer/integer");
-var SequenceType;
-(function (SequenceType) {
-    SequenceType[SequenceType["arithmetic"] = 0] = "arithmetic";
-    SequenceType[SequenceType["geometric"] = 1] = "geometric";
-    SequenceType[SequenceType["other"] = 2] = "other";
-})(SequenceType || (SequenceType = {}));
-class Sequence {
-    constructor({ type, recurrenceFormula, explicitFormula, firstRank, firstTerm, }) {
-        this.firstRank = new integer_1.Integer(0);
-        this.type = type;
-        this.firstTerm = firstTerm;
-        this.recurrenceFormula = recurrenceFormula;
-        this.explicitFormula = explicitFormula;
-        this.firstRank = firstRank;
-    }
-}
-exports.Sequence = Sequence;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sequence = void 0;
+const integer_1 = require("../numbers/integer/integer");
+var SequenceType;
+(function (SequenceType) {
+    SequenceType[SequenceType["arithmetic"] = 0] = "arithmetic";
+    SequenceType[SequenceType["geometric"] = 1] = "geometric";
+    SequenceType[SequenceType["other"] = 2] = "other";
+})(SequenceType || (SequenceType = {}));
+class Sequence {
+    constructor({ type, recurrenceFormula, explicitFormula, firstRank, firstTerm, }) {
+        this.firstRank = new integer_1.Integer(0);
+        this.type = type;
+        this.firstTerm = firstTerm;
+        this.recurrenceFormula = recurrenceFormula;
+        this.explicitFormula = explicitFormula;
+        this.firstRank = firstRank;
+    }
+}
+exports.Sequence = Sequence;

package/lib/math/sets/discreteSet.d.ts

@@ -1,11 +1,11 @@
-import { Nombre } from '../numbers/nombre';
-import { MathSetInterface } from './mathSetInterface';
-export declare class DiscreteSet implements MathSetInterface {
-    elements: Nombre[];
-    tex: string;
-    constructor(elements: Nombre[]);
-    toTex(): string;
-    includes(el: Nombre): boolean;
-    getRandomElement(): Nombre;
-}
+import { Nombre } from '../numbers/nombre';
+import { MathSetInterface } from './mathSetInterface';
+export declare class DiscreteSet implements MathSetInterface {
+    elements: Nombre[];
+    tex: string;
+    constructor(elements: Nombre[]);
+    toTex(): string;
+    includes(el: Nombre): boolean;
+    getRandomElement(): Nombre;
+}
 //# sourceMappingURL=discreteSet.d.ts.map

package/lib/math/sets/discreteSet.js

@@ -1,28 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiscreteSet = void 0;
-const random_1 = require("../../utils/random");
-class DiscreteSet {
-    constructor(elements) {
-        this.elements = Array.from(new Set(elements));
-        let tex = '\\{';
-        this.elements.forEach((el, index) => {
-            tex += el.tex;
-            if (index < this.elements.length - 1)
-                tex += ';';
-            else
-                tex += '\\}';
-        });
-        this.tex = tex;
-    }
-    toTex() {
-        return this.tex;
-    }
-    includes(el) {
-        return this.elements.some((nb) => nb.value === el.value && nb.tex === el.tex);
-    }
-    getRandomElement() {
-        return (0, random_1.random)(this.elements);
-    }
-}
-exports.DiscreteSet = DiscreteSet;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscreteSet = void 0;
+const random_1 = require("../../utils/random");
+class DiscreteSet {
+    constructor(elements) {
+        this.elements = Array.from(new Set(elements));
+        let tex = '\\{';
+        this.elements.forEach((el, index) => {
+            tex += el.tex;
+            if (index < this.elements.length - 1)
+                tex += ';';
+            else
+                tex += '\\}';
+        });
+        this.tex = tex;
+    }
+    toTex() {
+        return this.tex;
+    }
+    includes(el) {
+        return this.elements.some((nb) => nb.value === el.value && nb.tex === el.tex);
+    }
+    getRandomElement() {
+        return (0, random_1.random)(this.elements);
+    }
+}
+exports.DiscreteSet = DiscreteSet;

package/lib/math/sets/emptySet.js

@@ -1,6 +1,6 @@
-"use strict";
-// import { MathSetInterface } from "./mathSetInterface";
-// export abstract class EmptySet implements MathSetInterface {
-//   tex: string = "\\emptyset";
-//   getRandomElement = () => null;
-// }
+"use strict";
+// import { MathSetInterface } from "./mathSetInterface";
+// export abstract class EmptySet implements MathSetInterface {
+//   tex: string = "\\emptyset";
+//   getRandomElement = () => null;
+// }

package/lib/math/sets/intervals/intervals.d.ts

@@ -1,27 +1,27 @@
-import { Nombre, NumberType } from '../../../math/numbers/nombre';
-import { DiscreteSet } from '../discreteSet';
-import { MathSet } from '../mathSet';
-import { MathSetInterface } from '../mathSetInterface';
-declare enum BoundType {
-    OO = "]a;b[",
-    OF = "]a;b]",
-    FO = "[a;b[",
-    FF = "[a;b]"
-}
-export declare class Interval implements MathSetInterface {
-    min: number;
-    max: number;
-    boundType: BoundType;
-    type: NumberType;
-    tex: string;
-    /**
-     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
-     */
-    constructor(tex?: string);
-    exclude(nb: number): MathSet;
-    difference(set: DiscreteSet): MathSet;
-    toTex(): string;
-    getRandomElement(precision?: number): Nombre;
-}
-export {};
+import { Nombre, NumberType } from '../../../math/numbers/nombre';
+import { DiscreteSet } from '../discreteSet';
+import { MathSet } from '../mathSet';
+import { MathSetInterface } from '../mathSetInterface';
+declare enum BoundType {
+    OO = "]a;b[",
+    OF = "]a;b]",
+    FO = "[a;b[",
+    FF = "[a;b]"
+}
+export declare class Interval implements MathSetInterface {
+    min: number;
+    max: number;
+    boundType: BoundType;
+    type: NumberType;
+    tex: string;
+    /**
+     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
+     */
+    constructor(tex?: string);
+    exclude(nb: number): MathSet;
+    difference(set: DiscreteSet): MathSet;
+    toTex(): string;
+    getRandomElement(precision?: number): Nombre;
+}
+export {};
 //# sourceMappingURL=intervals.d.ts.map