math-exercises 1.3.1 → 1.3.3

package/lib/polynomials/polynomial.js

@@ -1,125 +1,125 @@
-"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);
-    }
-    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);
+    }
+    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/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/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/sets/intervals/intervals.js

@@ -1,108 +1,108 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Interval = void 0;
-const epsilon_1 = require("../../numbers/epsilon");
-const nombre_1 = require("../../numbers/nombre");
-const round_1 = require("../../mathutils/round");
-const mathSet_1 = require("../mathSet");
-const integer_1 = require("../../numbers/integer/integer");
-const real_1 = require("../../numbers/reals/real");
-var BoundType;
-(function (BoundType) {
-    BoundType["OO"] = "]a;b[";
-    BoundType["OF"] = "]a;b]";
-    BoundType["FO"] = "[a;b[";
-    BoundType["FF"] = "[a;b]";
-})(BoundType || (BoundType = {}));
-class Interval {
-    /**
-     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
-     */
-    constructor(tex = "[-10; 10]") {
-        this.tex = tex;
-        const isInt = tex[1] === "[" || tex[1] === "]";
-        this.type = isInt ? nombre_1.NumberType.Integer : nombre_1.NumberType.Real;
-        const left = tex[0];
-        const right = tex[tex.length - 1];
-        const [a, b] = tex
-            .slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1)
-            .split(";");
-        switch (`${left}a;b${right}`) {
-            case "[a;b]":
-                this.boundType = BoundType.FF;
-                break;
-            case "]a;b[":
-                this.boundType = BoundType.OO;
-                break;
-            case "[a;b[":
-                this.boundType = BoundType.FO;
-                break;
-            case "]a;b]":
-                this.boundType = BoundType.OF;
-                break;
-            default:
-                throw console.error("wrong interval");
-        }
-        function getBound(bound) {
-            return bound === "-\\infty"
-                ? Number.NEGATIVE_INFINITY
-                : bound === "+\\infty"
-                    ? Number.POSITIVE_INFINITY
-                    : Number(bound);
-        }
-        this.min = getBound(a);
-        this.max = getBound(b);
-    }
-    // union(interval: Interval): MathSet {
-    //[a,b] [c,d]
-    //si a=c return a, max(b,d)
-    //si si b = d return min(a,c), b
-    //si a=d return c,b sauf si  OXXO
-    //si b=c return a,d sauf si XOOX
-    //si c > b ou d < a alors union disjointe avec plus petit en 1er
-    //sinon return min(a,c), max(b,d)
-    //res = a
-    // return new MathSet();
-    // }
-    exclude(nb) {
-        const rand = () => {
-            let x;
-            do {
-                x = this.getRandomElement();
-            } while (x.value === nb);
-            return x;
-        };
-        return new mathSet_1.MathSet(this.toTex() + `\\{${nb}\\}`, rand);
-    }
-    difference(set) {
-        const rand = () => {
-            let x;
-            do {
-                x = this.getRandomElement();
-            } while (set.includes(x));
-            return x;
-        };
-        return new mathSet_1.MathSet(this.toTex() + `\\ ${set.toTex()}`, rand);
-    }
-    toTex() {
-        return this.tex;
-    }
-    getRandomElement(precision = this.type === nombre_1.NumberType.Integer ? 0 : 2) {
-        if (this.min === -Infinity || this.max === Infinity)
-            throw Error("Can't chose amongst infinity");
-        let min = this.boundType === BoundType.OO || this.boundType === BoundType.OF
-            ? this.min + epsilon_1.EPSILON
-            : this.min;
-        let max = this.boundType === BoundType.OO || this.boundType === BoundType.FO
-            ? this.max - epsilon_1.EPSILON
-            : this.max;
-        const value = (0, round_1.round)(min + Math.random() * (max - this.min), precision);
-        switch (this.type) {
-            case nombre_1.NumberType.Integer:
-                return new integer_1.Integer(value);
-            default:
-                return new real_1.Real(value, value.toString());
-        }
-    }
-}
-exports.Interval = Interval;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interval = void 0;
+const epsilon_1 = require("../../numbers/epsilon");
+const nombre_1 = require("../../numbers/nombre");
+const round_1 = require("../../mathutils/round");
+const mathSet_1 = require("../mathSet");
+const integer_1 = require("../../numbers/integer/integer");
+const real_1 = require("../../numbers/reals/real");
+var BoundType;
+(function (BoundType) {
+    BoundType["OO"] = "]a;b[";
+    BoundType["OF"] = "]a;b]";
+    BoundType["FO"] = "[a;b[";
+    BoundType["FF"] = "[a;b]";
+})(BoundType || (BoundType = {}));
+class Interval {
+    /**
+     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
+     */
+    constructor(tex = "[-10; 10]") {
+        this.tex = tex;
+        const isInt = tex[1] === "[" || tex[1] === "]";
+        this.type = isInt ? nombre_1.NumberType.Integer : nombre_1.NumberType.Real;
+        const left = tex[0];
+        const right = tex[tex.length - 1];
+        const [a, b] = tex
+            .slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1)
+            .split(";");
+        switch (`${left}a;b${right}`) {
+            case "[a;b]":
+                this.boundType = BoundType.FF;
+                break;
+            case "]a;b[":
+                this.boundType = BoundType.OO;
+                break;
+            case "[a;b[":
+                this.boundType = BoundType.FO;
+                break;
+            case "]a;b]":
+                this.boundType = BoundType.OF;
+                break;
+            default:
+                throw console.error("wrong interval");
+        }
+        function getBound(bound) {
+            return bound === "-\\infty"
+                ? Number.NEGATIVE_INFINITY
+                : bound === "+\\infty"
+                    ? Number.POSITIVE_INFINITY
+                    : Number(bound);
+        }
+        this.min = getBound(a);
+        this.max = getBound(b);
+    }
+    // union(interval: Interval): MathSet {
+    //[a,b] [c,d]
+    //si a=c return a, max(b,d)
+    //si si b = d return min(a,c), b
+    //si a=d return c,b sauf si  OXXO
+    //si b=c return a,d sauf si XOOX
+    //si c > b ou d < a alors union disjointe avec plus petit en 1er
+    //sinon return min(a,c), max(b,d)
+    //res = a
+    // return new MathSet();
+    // }
+    exclude(nb) {
+        const rand = () => {
+            let x;
+            do {
+                x = this.getRandomElement();
+            } while (x.value === nb);
+            return x;
+        };
+        return new mathSet_1.MathSet(this.toTex() + `\\{${nb}\\}`, rand);
+    }
+    difference(set) {
+        const rand = () => {
+            let x;
+            do {
+                x = this.getRandomElement();
+            } while (set.includes(x));
+            return x;
+        };
+        return new mathSet_1.MathSet(this.toTex() + `\\ ${set.toTex()}`, rand);
+    }
+    toTex() {
+        return this.tex;
+    }
+    getRandomElement(precision = this.type === nombre_1.NumberType.Integer ? 0 : 2) {
+        if (this.min === -Infinity || this.max === Infinity)
+            throw Error("Can't chose amongst infinity");
+        let min = this.boundType === BoundType.OO || this.boundType === BoundType.OF
+            ? this.min + epsilon_1.EPSILON
+            : this.min;
+        let max = this.boundType === BoundType.OO || this.boundType === BoundType.FO
+            ? this.max - epsilon_1.EPSILON
+            : this.max;
+        const value = (0, round_1.round)(min + Math.random() * (max - this.min), precision);
+        switch (this.type) {
+            case nombre_1.NumberType.Integer:
+                return new integer_1.Integer(value);
+            default:
+                return new real_1.Real(value, value.toString());
+        }
+    }
+}
+exports.Interval = Interval;

package/lib/sets/intervals/union.js

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

package/lib/sets/mathSet.js

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MathSet = void 0;
-class MathSet {
-    constructor(tex, getRandomElement) {
-        this.tex = tex;
-        this.getRandomElement = getRandomElement;
-    }
-}
-exports.MathSet = MathSet;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathSet = void 0;
+class MathSet {
+    constructor(tex, getRandomElement) {
+        this.tex = tex;
+        this.getRandomElement = getRandomElement;
+    }
+}
+exports.MathSet = MathSet;

package/lib/sets/mathSetInterface.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/tree/nodes/functions/functionNode.js

@@ -1,18 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionNode = exports.FunctionsIds = void 0;
-const node_1 = require("../node");
-var FunctionsIds;
-(function (FunctionsIds) {
-    FunctionsIds[FunctionsIds["opposite"] = 0] = "opposite";
-    FunctionsIds[FunctionsIds["sqrt"] = 1] = "sqrt";
-})(FunctionsIds = exports.FunctionsIds || (exports.FunctionsIds = {}));
-class FunctionNode {
-    constructor(id, child, tex) {
-        this.type = node_1.NodeType.function;
-        this.id = id;
-        this.child = child;
-        this.tex = tex;
-    }
-}
-exports.FunctionNode = FunctionNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionNode = exports.FunctionsIds = void 0;
+const node_1 = require("../node");
+var FunctionsIds;
+(function (FunctionsIds) {
+    FunctionsIds[FunctionsIds["opposite"] = 0] = "opposite";
+    FunctionsIds[FunctionsIds["sqrt"] = 1] = "sqrt";
+})(FunctionsIds = exports.FunctionsIds || (exports.FunctionsIds = {}));
+class FunctionNode {
+    constructor(id, child, tex) {
+        this.type = node_1.NodeType.function;
+        this.id = id;
+        this.child = child;
+        this.tex = tex;
+    }
+}
+exports.FunctionNode = FunctionNode;

package/lib/tree/nodes/functions/oppositeNode.js

@@ -1,26 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OppositeNode = void 0;
-const node_1 = require("../node");
-const operatorNode_1 = require("../operators/operatorNode");
-const functionNode_1 = require("./functionNode");
-class OppositeNode extends functionNode_1.FunctionNode {
-    constructor(child) {
-        super(functionNode_1.FunctionsIds.opposite, child, '-');
-    }
-    toMathString() {
-        return `-(${this.child.toMathString()})`;
-    }
-    toTex() {
-        let childTex = this.child.toTex();
-        let needBrackets = childTex[0] === '-';
-        if (this.child.type === node_1.NodeType.operator) {
-            const operatorChild = this.child;
-            needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorChild.id));
-        }
-        if (needBrackets)
-            childTex = `(${childTex})`;
-        return `-${childTex}`;
-    }
-}
-exports.OppositeNode = OppositeNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OppositeNode = void 0;
+const functionNode_1 = require("./functionNode");
+class OppositeNode extends functionNode_1.FunctionNode {
+    constructor(child) {
+        super(functionNode_1.FunctionsIds.opposite, child, "-");
+    }
+    toString() {
+        return `-(${this.child})`;
+    }
+}
+exports.OppositeNode = OppositeNode;