math-exercises 1.3.40 → 1.3.42

package/lib/numbers/integer/integer.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Integer = exports.IntegerConstructor = void 0;
+const randint_1 = require("../../mathutils/random/randint");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const nombre_1 = require("../nombre");
+const rational_1 = require("../rationals/rational");
+class IntegerConstructor {
+    static random(nbOfDigits) {
+        return (0, randint_1.randint)(0, 10 ** nbOfDigits);
+    }
+}
+exports.IntegerConstructor = IntegerConstructor;
+class Integer {
+    constructor(value, tex) {
+        this.value = value;
+        this.tex = tex || value + "";
+        this.type = nombre_1.NumberType.Integer;
+    }
+    toTree() {
+        return new numberNode_1.NumberNode(this.value, this.tex);
+    }
+    round(precision) {
+        const intString = this.value + "";
+        if (precision >= intString.length || precision < 1)
+            throw Error("can't round to higher precision");
+        let newInt = "";
+        const shouldRoundUp = Number(intString[intString.length - precision]) > 4;
+        if (shouldRoundUp) {
+            for (let i = 0; i < precision; i++) {
+                newInt += "0";
+            }
+            let retenue = true;
+            let i = intString.length - precision - 1;
+            while (retenue) {
+                const nb = (Number(intString[i]) + 1) % 10;
+                newInt = "" + nb + newInt;
+                if (nb === 0) {
+                    i--;
+                }
+                else {
+                    retenue = false;
+                    for (let j = i - 1; j > -1; j--) {
+                        newInt = intString[j] + newInt;
+                    }
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < intString.length; i++) {
+                newInt += i < intString.length - precision ? intString[i] : "0";
+            }
+        }
+        return new Integer(Number(newInt));
+    }
+    divide(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer:
+                return new rational_1.Rational(this.value, nb.value).simplify();
+            case nombre_1.NumberType.Rational:
+                const rational = nb;
+                return new rational_1.Rational(this.value * rational.denum, rational.num).simplify();
+            default:
+                throw Error("not implemented");
+        }
+    }
+}
+exports.Integer = Integer;

package/lib/numbers/integer/power.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Power = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../tree/nodes/operators/powerNode");
+const nombre_1 = require("../nombre");
+const integer_1 = require("./integer");
+class Power {
+    constructor(a, b) {
+        this.operand = a;
+        this.power = b;
+        this.value = Math.pow(a, b);
+        this.tex = `${a}^{${b}}`;
+        this.type = b < 0 ? nombre_1.NumberType.Rational : nombre_1.NumberType.Integer;
+    }
+    simplify() {
+        if (this.power === 0)
+            return new numberNode_1.NumberNode(1);
+        if (this.power === 1)
+            return new numberNode_1.NumberNode(this.operand);
+        if (this.operand === 1)
+            return new numberNode_1.NumberNode(1);
+        if (this.operand === 0)
+            return new numberNode_1.NumberNode(0);
+        if (this.operand === -1)
+            return new numberNode_1.NumberNode(this.power % 2 === 0 ? 1 : -1);
+        return this.toTree();
+    }
+    toDecimalWriting() {
+        if (this.operand !== 10)
+            throw Error("only implemented for powers of ten so far");
+        let s = "";
+        if (this.power > -1) {
+            s += "1";
+            for (let i = 0; i < this.power; i++) {
+                s += 0;
+            }
+        }
+        else {
+            s += "1";
+            for (let i = 1; i < Math.abs(this.power); i++) {
+                s = "0" + s;
+            }
+            s = "0." + s;
+        }
+        return new integer_1.Integer(Number(s), s);
+    }
+    toTree() {
+        return new powerNode_1.PowerNode(new numberNode_1.NumberNode(this.operand), new numberNode_1.NumberNode(this.power));
+    }
+}
+exports.Power = Power;

package/lib/numbers/nombre.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberType = void 0;
+var NumberType;
+(function (NumberType) {
+    NumberType[NumberType["Integer"] = 0] = "Integer";
+    NumberType[NumberType["Decimal"] = 1] = "Decimal";
+    NumberType[NumberType["Rational"] = 2] = "Rational";
+    NumberType[NumberType["Real"] = 3] = "Real";
+})(NumberType = exports.NumberType || (exports.NumberType = {}));

package/lib/numbers/rationals/rational.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rational = exports.RationalConstructor = void 0;
+const coprimesOf_1 = require("../../mathutils/arithmetic/coprimesOf");
+const gcd_1 = require("../../mathutils/arithmetic/gcd");
+const lcd_1 = require("../../mathutils/arithmetic/lcd");
+const randint_1 = require("../../mathutils/random/randint");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const random_1 = require("../../utils/random");
+const shuffle_1 = require("../../utils/shuffle");
+const integer_1 = require("../integer/integer");
+const nombre_1 = require("../nombre");
+class RationalConstructor {
+    /**
+     * @param maxGcd max number by which the fraction is simplifiable
+     */
+    static randomSimplifiable(maxGcd = 10) {
+        const gcd = (0, randint_1.randint)(2, maxGcd);
+        const max = (0, randint_1.randint)(3, 11);
+        const min = (0, random_1.random)((0, coprimesOf_1.coprimesOf)(max));
+        let [num, denum] = (0, shuffle_1.shuffle)([gcd * min, gcd * max]);
+        if (denum === gcd) {
+            //si 10/2 on transforme en 2/10
+            return new Rational(denum, num);
+        }
+        return new Rational(num, denum);
+    }
+    static randomIrreductible(max = 11) {
+        const a = (0, randint_1.randint)(2, max);
+        const b = (0, random_1.random)([...(0, coprimesOf_1.coprimesOf)(a), 1]);
+        if (b === 1)
+            return new Rational(b, a);
+        const [num, denum] = (0, shuffle_1.shuffle)([a, b]);
+        return new Rational(num, denum);
+    }
+}
+exports.RationalConstructor = RationalConstructor;
+class Rational {
+    constructor(numerator, denumerator) {
+        if (denumerator === 0)
+            throw Error("division by zero");
+        this.num = numerator;
+        this.denum = denumerator;
+        this.value = numerator / denumerator;
+        this.isSimplified = Math.abs((0, gcd_1.gcd)(numerator, denumerator)) === 1;
+        this.tex = `\\frac{${this.num}}{${this.denum}}`;
+        this.type = nombre_1.NumberType.Rational;
+    }
+    toTex() {
+        return `\\frac{${this.num}}{${this.denum}}`;
+    }
+    add(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                const num = this.num + this.denum * nb.value;
+                return new Rational(num, this.denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                const rational = nb;
+                const ppcm = (0, lcd_1.lcd)(rational.denum, this.denum);
+                const num = this.num * (ppcm / this.denum) + rational.num * (ppcm / rational.denum);
+                return new Rational(num, ppcm).simplify();
+            }
+        }
+        throw Error("not implemented yet");
+    }
+    multiply(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                const num = this.num * nb.value;
+                const denum = this.denum;
+                return new Rational(num, denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                const rational = nb;
+                const num = this.num * rational.num;
+                const denum = this.denum * rational.denum;
+                return new Rational(num, denum).simplify();
+            }
+        }
+        throw Error("not implemented yet");
+    }
+    divide(nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                const denum = this.denum * nb.value;
+                return new Rational(this.num, denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                const rational = nb;
+                const num = this.num * rational.denum;
+                const denum = this.denum * rational.num;
+                return new Rational(num, denum).simplify();
+            }
+        }
+        throw Error("not implemented yet");
+    }
+    opposite() {
+        return new Rational(-this.num, this.denum);
+    }
+    toTree() {
+        return new fractionNode_1.FractionNode(new numberNode_1.NumberNode(this.num), new numberNode_1.NumberNode(this.denum));
+    }
+    simplify() {
+        const sign = (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0) ? 1 : -1;
+        const div = Math.abs((0, gcd_1.gcd)(this.num, this.denum));
+        if (Math.abs(this.denum) === div)
+            return new integer_1.Integer(this.num / this.denum);
+        return new Rational((sign * Math.abs(this.num)) / div, Math.abs(this.denum) / div);
+    }
+}
+exports.Rational = Rational;

package/lib/numbers/reals/real.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Real = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const nombre_1 = require("../nombre");
+class Real {
+    constructor(value, tex) {
+        this.value = value;
+        this.tex = tex;
+        this.type = nombre_1.NumberType.Real;
+    }
+    toTree() {
+        return new numberNode_1.NumberNode(this.value);
+    }
+}
+exports.Real = Real;

package/lib/numbers/reals/squareRoot.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SquareRoot = exports.SquareRootConstructor = void 0;
+const isSquare_1 = require("../../mathutils/arithmetic/isSquare");
+const primeFactors_1 = require("../../mathutils/arithmetic/primeFactors");
+const randint_1 = require("../../mathutils/random/randint");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const real_1 = require("./real");
+const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
+class SquareRootConstructor {
+    /**
+     * @returns simplifiable square root type sqrt(c)=a*sqrt(b)
+     */
+    static randomSimplifiable({ allowPerfectSquare = false, maxSquare = 11 }) {
+        const a = (0, randint_1.randint)(2, maxSquare);
+        let b;
+        let bMin = allowPerfectSquare ? 1 : 2;
+        do {
+            b = (0, randint_1.randint)(bMin, maxSquare);
+        } while (b % (a * a) === 0 || (0, isSquare_1.isSquare)(b));
+        return new SquareRoot(a * a * b);
+    }
+}
+exports.SquareRootConstructor = SquareRootConstructor;
+class SquareRoot extends real_1.Real {
+    constructor(operand) {
+        super(Math.sqrt(operand), `\\sqrt{${operand}}`);
+        this.operand = operand;
+    }
+    simplify() {
+        const factors = (0, primeFactors_1.primeFactors)(this.operand);
+        // finds primes with even exponents
+        const multiples = [1];
+        for (let i = 0; i < factors.length - 1; i++) {
+            if (factors[i] === factors[i + 1]) {
+                multiples.push(factors[i]);
+                factors.splice(i, 2);
+                i--;
+            }
+        }
+        const outsideSqrt = multiples.reduce((x, y) => x * y);
+        const insideSqrt = factors.length === 0 ? 1 : factors.reduce((x, y) => x * y);
+        const simplified = insideSqrt !== 1
+            ? new real_1.Real(outsideSqrt * Math.sqrt(insideSqrt), `${outsideSqrt === 1 ? "" : `${outsideSqrt}`}\\sqrt{${insideSqrt}}`)
+            : new real_1.Real(outsideSqrt, outsideSqrt + "");
+        simplified.toTree = () => {
+            return insideSqrt !== 1
+                ? outsideSqrt === 1
+                    ? new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt))
+                    : new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(outsideSqrt), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(insideSqrt)))
+                : new numberNode_1.NumberNode(outsideSqrt);
+        };
+        return simplified;
+    }
+    toTex() {
+        return this.tex;
+    }
+    toTree() {
+        return new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(this.operand));
+    }
+}
+exports.SquareRoot = SquareRoot;

package/lib/polynomials/affine.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Affine = exports.AffineConstructor = void 0;
+const rational_1 = require("../numbers/rationals/rational");
+const intervals_1 = require("../sets/intervals/intervals");
+const polynomial_1 = require("./polynomial");
+const discreteSet_1 = require("../sets/discreteSet");
+const integer_1 = require("../numbers/integer/integer");
+class AffineConstructor {
+    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]]")) {
+        const a = domainA.getRandomElement();
+        const b = domainB.getRandomElement();
+        return new Affine(a.value, b.value);
+    }
+    static differentRandoms(nb, domainA = new intervals_1.Interval("[[-10; 10]]").difference(new discreteSet_1.DiscreteSet([new integer_1.Integer(0)])), domainB = new intervals_1.Interval("[[-10; 10]]")) {
+        const res = [];
+        for (let i = 0; i < nb; i++) {
+            let aff;
+            do {
+                aff = AffineConstructor.random(domainA, domainB);
+            } while (res.some((affine) => affine.equals(aff)));
+            res.push(aff);
+        }
+        return res;
+    }
+}
+exports.AffineConstructor = AffineConstructor;
+class Affine extends polynomial_1.Polynomial {
+    constructor(a, b, variable = "x") {
+        super([b, a], variable);
+        this.a = a;
+        this.b = b;
+        this.variable = variable;
+    }
+    getRoot() {
+        return new rational_1.Rational(-this.b, this.a).simplify();
+    }
+    toString() {
+        return super.toTex();
+    }
+}
+exports.Affine = Affine;

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,49 +1,49 @@
-"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,
-        });
-    });
-    app.get('/qcmExo', (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);
-        console.log(questions);
-        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,
-        });
-    });
-    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,
+        });
+    });
+    app.get('/qcmExo', (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);
+        console.log(questions);
+        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,
+        });
+    });
+    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;
+// }