math-exercises 1.3.52 → 1.3.54

package/lib/polynomials/polynomial.js

@@ -0,0 +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;

package/lib/server.d.ts

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=server.d.ts.map

package/lib/server.js

@@ -1,54 +1,54 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const exercises_1 = require("./exercises/exercises");
-const express_1 = __importDefault(require("express"));
-const dotenv_1 = __importDefault(require("dotenv"));
-const cors_1 = __importDefault(require("cors"));
-const allExercises = [...exercises_1.exercises];
-const runServer = () => {
-    dotenv_1.default.config();
-    const app = (0, express_1.default)();
-    app.use((0, cors_1.default)());
-    app.get('/', (req, res) => {
-        res.json(allExercises);
-    });
-    app.get('/exo', (req, res) => {
-        const exoId = req.query.exoId;
-        const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
-        const exo = allExercises[exoIndex];
-        if (!exo)
-            res.send('Exo not found');
-        const questions = exo === null || exo === void 0 ? void 0 : exo.generator(10);
-        res.json({
-            exercise: exo,
-            questions,
-            nextId: allExercises[(exoIndex + 1) % allExercises.length].id,
-            prevId: allExercises[(exoIndex - 1 + allExercises.length) % allExercises.length].id,
-        });
-    });
-    app.get('/qcmExo', (req, res) => {
-        const exoId = req.query.exoId;
-        const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
-        const exo = allExercises[exoIndex];
-        if (!exo)
-            res.send('Exo not found');
-        const questions = exo === null || exo === void 0 ? void 0 : exo.generator(10);
-        const populatedQuestions = questions === null || questions === void 0 ? void 0 : questions.map((q) => {
-            var _a;
-            return Object.assign(Object.assign({}, q), { propositions: (_a = q.getPropositions) === null || _a === void 0 ? void 0 : _a.call(q, 4) });
-        });
-        res.json({
-            exercise: exo,
-            questions: populatedQuestions,
-            nextId: allExercises[(exoIndex + 1) % allExercises.length].id,
-            prevId: allExercises[(exoIndex - 1 + allExercises.length) % allExercises.length].id,
-        });
-    });
-    app.listen('5000', () => {
-        console.log(`[server]: Server is running at http://localhost:5000`);
-    });
-};
-runServer();
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const exercises_1 = require("./exercises/exercises");
+const express_1 = __importDefault(require("express"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const cors_1 = __importDefault(require("cors"));
+const allExercises = [...exercises_1.exercises];
+const runServer = () => {
+    dotenv_1.default.config();
+    const app = (0, express_1.default)();
+    app.use((0, cors_1.default)());
+    app.get('/', (req, res) => {
+        res.json(allExercises);
+    });
+    app.get('/exo', (req, res) => {
+        const exoId = req.query.exoId;
+        const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
+        const exo = allExercises[exoIndex];
+        if (!exo)
+            res.send('Exo not found');
+        const questions = exo === null || exo === void 0 ? void 0 : exo.generator(10);
+        res.json({
+            exercise: exo,
+            questions,
+            nextId: allExercises[(exoIndex + 1) % allExercises.length].id,
+            prevId: allExercises[(exoIndex - 1 + allExercises.length) % allExercises.length].id,
+        });
+    });
+    app.get('/qcmExo', (req, res) => {
+        const exoId = req.query.exoId;
+        const exoIndex = allExercises.findIndex((exo) => exo.id == exoId);
+        const exo = allExercises[exoIndex];
+        if (!exo)
+            res.send('Exo not found');
+        const questions = exo === null || exo === void 0 ? void 0 : exo.generator(10);
+        const populatedQuestions = questions === null || questions === void 0 ? void 0 : questions.map((q) => {
+            var _a;
+            return Object.assign(Object.assign({}, q), { propositions: (_a = q.getPropositions) === null || _a === void 0 ? void 0 : _a.call(q, 4) });
+        });
+        res.json({
+            exercise: exo,
+            questions: populatedQuestions,
+            nextId: allExercises[(exoIndex + 1) % allExercises.length].id,
+            prevId: allExercises[(exoIndex - 1 + allExercises.length) % allExercises.length].id,
+        });
+    });
+    app.listen('5000', () => {
+        console.log(`[server]: Server is running at http://localhost:5000`);
+    });
+};
+runServer();

package/lib/sets/discreteSet.js

@@ -0,0 +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;

package/lib/sets/emptySet.js

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

package/lib/sets/intervals/intervals.js

@@ -0,0 +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;

package/lib/sets/intervals/union.js

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

package/lib/sets/mathSet.js

@@ -0,0 +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;

package/lib/sets/mathSetInterface.js

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

package/lib/tree/nodes/complex/complexNode.d.ts

@@ -1,15 +1,15 @@
-import { Node, NodeType } from '../node';
-import { Complex } from '../../../math/complex/complex';
-export declare class ComplexNode implements Node {
-    tex: string;
-    mathString: string;
-    re: number;
-    im: number;
-    type: NodeType;
-    constructor(re: number, im: number, tex?: string, mathString?: string);
-    toMathString(): string;
-    toTex(): string;
-    toMathjs(): import("mathjs").Complex;
-    toComplex(): Complex;
-}
+import { Node, NodeType } from '../node';
+import { Complex } from '../../../math/complex/complex';
+export declare class ComplexNode implements Node {
+    tex: string;
+    mathString: string;
+    re: number;
+    im: number;
+    type: NodeType;
+    constructor(re: number, im: number, tex?: string, mathString?: string);
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): import("mathjs").Complex;
+    toComplex(): Complex;
+}
 //# sourceMappingURL=complexNode.d.ts.map

package/lib/tree/nodes/complex/complexNode.js

@@ -1,43 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComplexNode = void 0;
-const mathjs_1 = require("mathjs");
-const node_1 = require("../node");
-const complex_1 = require("../../../math/complex/complex");
-class ComplexNode {
-    constructor(re, im, tex, mathString) {
-        this.type = node_1.NodeType.number;
-        this.re = re;
-        this.im = im;
-        const reTex = re === 0 ? '' : re.toString();
-        const imTex = im === 0
-            ? ''
-            : im === 1
-                ? re === 0
-                    ? 'i'
-                    : '+i'
-                : im === -1
-                    ? '-i'
-                    : im > 0
-                        ? re === 0
-                            ? `${im}i`
-                            : `+${im}i`
-                        : `${im}i`;
-        const formatedTex = re === 0 && im === 0 ? '0' : `${reTex}${imTex}`;
-        this.tex = tex || formatedTex;
-        this.mathString = mathString || this.tex;
-    }
-    toMathString() {
-        return `${this.mathString ? this.mathString : this.tex}`;
-    }
-    toTex() {
-        return `${this.tex}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.complex)(this.re, this.im);
-    }
-    toComplex() {
-        return new complex_1.Complex(this.re, this.im);
-    }
-}
-exports.ComplexNode = ComplexNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComplexNode = void 0;
+const mathjs_1 = require("mathjs");
+const node_1 = require("../node");
+const complex_1 = require("../../../math/complex/complex");
+class ComplexNode {
+    constructor(re, im, tex, mathString) {
+        this.type = node_1.NodeType.number;
+        this.re = re;
+        this.im = im;
+        const reTex = re === 0 ? '' : re.toString();
+        const imTex = im === 0
+            ? ''
+            : im === 1
+                ? re === 0
+                    ? 'i'
+                    : '+i'
+                : im === -1
+                    ? '-i'
+                    : im > 0
+                        ? re === 0
+                            ? `${im}i`
+                            : `+${im}i`
+                        : `${im}i`;
+        const formatedTex = re === 0 && im === 0 ? '0' : `${reTex}${imTex}`;
+        this.tex = tex || formatedTex;
+        this.mathString = mathString || this.tex;
+    }
+    toMathString() {
+        return `${this.mathString ? this.mathString : this.tex}`;
+    }
+    toTex() {
+        return `${this.tex}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.complex)(this.re, this.im);
+    }
+    toComplex() {
+        return new complex_1.Complex(this.re, this.im);
+    }
+}
+exports.ComplexNode = ComplexNode;

package/lib/tree/nodes/expression/expressionNode.js

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

package/lib/tree/nodes/functions/cosNode.d.ts

@@ -1,11 +1,11 @@
-import { Node, NodeType } from '../node';
-import { FunctionNode } from './functionNode';
-export declare class CosNode extends FunctionNode implements Node {
-    type: NodeType;
-    constructor(child: Node);
-    toMathString(): string;
-    toTex(): string;
-    toMathjs(): number;
-    simplify(): Node;
-}
+import { Node, NodeType } from '../node';
+import { FunctionNode } from './functionNode';
+export declare class CosNode extends FunctionNode implements Node {
+    type: NodeType;
+    constructor(child: Node);
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): number;
+    simplify(): Node;
+}
 //# sourceMappingURL=cosNode.d.ts.map

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

@@ -1,25 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CosNode = void 0;
-const mathjs_1 = require("mathjs");
-const node_1 = require("../node");
-const functionNode_1 = require("./functionNode");
-class CosNode extends functionNode_1.FunctionNode {
-    constructor(child) {
-        super(functionNode_1.FunctionsIds.cos, child, '\\cos');
-        this.type = node_1.NodeType.function;
-    }
-    toMathString() {
-        return `cos(${this.child.toMathString()})`;
-    }
-    toTex() {
-        return `\\cos\\left(${this.child.toTex()}\\right)`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.cos)(this.child.toMathjs());
-    }
-    simplify() {
-        return this;
-    }
-}
-exports.CosNode = CosNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosNode = void 0;
+const mathjs_1 = require("mathjs");
+const node_1 = require("../node");
+const functionNode_1 = require("./functionNode");
+class CosNode extends functionNode_1.FunctionNode {
+    constructor(child) {
+        super(functionNode_1.FunctionsIds.cos, child, '\\cos');
+        this.type = node_1.NodeType.function;
+    }
+    toMathString() {
+        return `cos(${this.child.toMathString()})`;
+    }
+    toTex() {
+        return `\\cos\\left(${this.child.toTex()}\\right)`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.cos)(this.child.toMathjs());
+    }
+    simplify() {
+        return this;
+    }
+}
+exports.CosNode = CosNode;

package/lib/tree/nodes/functions/expNode.d.ts

@@ -1,11 +1,11 @@
-import { Node, NodeType } from '../node';
-import { FunctionNode } from './functionNode';
-export declare class ExpNode extends FunctionNode implements Node {
-    type: NodeType;
-    constructor(child: Node);
-    toMathString(): string;
-    toTex(): string;
-    toMathjs(): number;
-    simplify(): Node;
-}
+import { Node, NodeType } from '../node';
+import { FunctionNode } from './functionNode';
+export declare class ExpNode extends FunctionNode implements Node {
+    type: NodeType;
+    constructor(child: Node);
+    toMathString(): string;
+    toTex(): string;
+    toMathjs(): number;
+    simplify(): Node;
+}
 //# sourceMappingURL=expNode.d.ts.map