math-exercises 1.3.31 → 1.3.32

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,53 +1,53 @@
-"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 exo = allExercises.find((exo) => exo.id == exoId);
-        if (!exo)
-            res.send('Exo not found');
-        const questions = exo === null || exo === void 0 ? void 0 : exo.generator(10);
-        res.json({
-            exercise: exo,
-            questions,
-        });
-    });
-    /*console.log(new Droite('D', new NumberNode(2), new NumberNode(-1)).toEquationExpression());
-    console.log(
-      PointConstructor.fromTwoPoints(
-        new Point('A', new NumberNode(0), new NumberNode(-1)),
-        new Point('B', new NumberNode(1), new NumberNode(1)),
-      ).toEquationExpression(),
-    );
-    console.log(
-      PointConstructor.fromPointAndSlope(
-        new Point('A', new NumberNode(0), new NumberNode(-1)),
-        new NumberNode(2),
-      ).toEquationExpression(),
-    );
-    console.log(
-      PointConstructor.fromPointAndAngle(
-        new Point('A', new NumberNode(0), new NumberNode(-1)),
-        new NumberNode(1.107),
-      ).toEquationExpression(),
-    );*/
-    //console.log(leadingCoefficient.generator(2));
-    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 exo = allExercises.find((exo) => exo.id == exoId);
+        if (!exo)
+            res.send('Exo not found');
+        const questions = exo === null || exo === void 0 ? void 0 : exo.generator(10);
+        res.json({
+            exercise: exo,
+            questions,
+        });
+    });
+    /*console.log(new Droite('D', new NumberNode(2), new NumberNode(-1)).toEquationExpression());
+    console.log(
+      PointConstructor.fromTwoPoints(
+        new Point('A', new NumberNode(0), new NumberNode(-1)),
+        new Point('B', new NumberNode(1), new NumberNode(1)),
+      ).toEquationExpression(),
+    );
+    console.log(
+      PointConstructor.fromPointAndSlope(
+        new Point('A', new NumberNode(0), new NumberNode(-1)),
+        new NumberNode(2),
+      ).toEquationExpression(),
+    );
+    console.log(
+      PointConstructor.fromPointAndAngle(
+        new Point('A', new NumberNode(0), new NumberNode(-1)),
+        new NumberNode(1.107),
+      ).toEquationExpression(),
+    );*/
+    //console.log(leadingCoefficient.generator(2));
+    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/functions/cosNode.d.ts

@@ -1,10 +1,10 @@
-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;
-    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;
+    simplify(): Node;
+}
 //# sourceMappingURL=cosNode.d.ts.map

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

@@ -1,21 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CosNode = void 0;
-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)`;
-    }
-    simplify() {
-        return this;
-    }
-}
-exports.CosNode = CosNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosNode = void 0;
+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)`;
+    }
+    simplify() {
+        return this;
+    }
+}
+exports.CosNode = CosNode;

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

@@ -1,15 +1,15 @@
-import { Node, NodeType } from '../node';
-export declare enum FunctionsIds {
-    opposite = 0,
-    sqrt = 1,
-    cos = 2,
-    sin = 3
-}
-export declare abstract class FunctionNode {
-    id: FunctionsIds;
-    child: Node;
-    type: NodeType;
-    tex: string;
-    constructor(id: FunctionsIds, child: Node, tex: string);
-}
+import { Node, NodeType } from '../node';
+export declare enum FunctionsIds {
+    opposite = 0,
+    sqrt = 1,
+    cos = 2,
+    sin = 3
+}
+export declare abstract class FunctionNode {
+    id: FunctionsIds;
+    child: Node;
+    type: NodeType;
+    tex: string;
+    constructor(id: FunctionsIds, child: Node, tex: string);
+}
 //# sourceMappingURL=functionNode.d.ts.map

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

@@ -1,20 +1,20 @@
-"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[FunctionsIds["cos"] = 2] = "cos";
-    FunctionsIds[FunctionsIds["sin"] = 3] = "sin";
-})(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[FunctionsIds["cos"] = 2] = "cos";
+    FunctionsIds[FunctionsIds["sin"] = 3] = "sin";
+})(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.d.ts

@@ -1,8 +1,8 @@
-import { Node } from '../node';
-import { FunctionNode } from './functionNode';
-export declare class OppositeNode extends FunctionNode implements Node {
-    constructor(child: Node);
-    toMathString(): string;
-    toTex(): string;
-}
+import { Node } from '../node';
+import { FunctionNode } from './functionNode';
+export declare class OppositeNode extends FunctionNode implements Node {
+    constructor(child: Node);
+    toMathString(): string;
+    toTex(): string;
+}
 //# sourceMappingURL=oppositeNode.d.ts.map

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

@@ -1,26 +1,26 @@
-"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 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;

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

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

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

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

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

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