math-exercises 2.0.44 → 2.1.1

package/lib/exercises/math/derivation/derivative/thirdDegreeFunctionVariation.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thirdDegreeFunctionVariation = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../../../geogebra/colors");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const polynomial_1 = require("../../../../math/polynomials/polynomial");
+const randint_1 = require("../../../../math/utils/random/randint");
+const infiniteNode_1 = require("../../../../tree/nodes/numbers/infiniteNode");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const closure_1 = require("../../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
+const unionIntervalNode_1 = require("../../../../tree/nodes/sets/unionIntervalNode");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getThirdDegreeFunctionVariation = () => {
+    const a = (0, randint_1.randint)(-3, 4, [0]);
+    const c = (0, randint_1.randint)(-2, 3);
+    const racine1 = (0, randint_1.randint)(-5, 4);
+    const racine2 = (0, randint_1.randint)(racine1 + 1, 6);
+    const coefs = [
+        c,
+        a * racine1 * racine2,
+        (-a * (racine1 + racine2)) / 2,
+        a / 3,
+    ];
+    const polynome = new polynomial_1.Polynomial(coefs);
+    const coin = (0, coinFlip_1.coinFlip)() ? -1 : 1;
+    const instruction = `Soit $f$ la fonction représentée ci-dessous. Sur quel intervalle la dérivée de $f$ est-elle ` +
+        (coin < 0 ? "négative ?" : "positive ?");
+    const racine1Tree = new numberNode_1.NumberNode(racine1);
+    const racine2Tree = new numberNode_1.NumberNode(racine2);
+    const answer = coin * a < 0
+        ? new intervalNode_1.IntervalNode(racine1Tree, racine2Tree, closure_1.ClosureType.FF).toTex()
+        : new unionIntervalNode_1.UnionIntervalNode([
+            new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, racine1Tree, closure_1.ClosureType.OF),
+            new intervalNode_1.IntervalNode(racine2Tree, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.FO),
+        ]).toTex();
+    const commands = [
+        `f(x) = ${polynome.toString()}`,
+        `SetColor(f, "${(0, colors_1.randomColor)()}")`,
+    ];
+    const y1 = polynome.calculate(racine1);
+    const y2 = polynome.calculate(racine2);
+    const yMax = Math.max(y1, y2);
+    const yMin = Math.min(y1, y2);
+    const xMax = Math.max(racine1, racine2);
+    const xMin = Math.min(racine1, racine2);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isAxesRatioFixed: false,
+        isGridSimple: true,
+        gridDistance: false,
+    });
+    const question = {
+        instruction,
+        startStatement: "S",
+        answer,
+        keys: ["lbracket", "rbracket", "semicolon", "infty", "cup"],
+        answerFormat: "tex",
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        identifiers: { racine1, racine2, coin, a },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, racine1, racine2 }) => {
+    const racine1Tree = new numberNode_1.NumberNode(racine1);
+    const racine2Tree = new numberNode_1.NumberNode(racine2);
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, new intervalNode_1.IntervalNode(racine2Tree, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.FO).toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, racine1Tree, closure_1.ClosureType.OF).toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, new unionIntervalNode_1.UnionIntervalNode([
+        new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, racine1Tree, closure_1.ClosureType.OF),
+        new intervalNode_1.IntervalNode(racine2Tree, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.FO),
+    ]).toTex());
+    while (propositions.length < n) {
+        const root1 = (0, randint_1.randint)(-5, 4);
+        const root2 = (0, randint_1.randint)(root1 + 1, 6);
+        const root1Tree = new numberNode_1.NumberNode(racine1);
+        const root2Tree = new numberNode_1.NumberNode(racine2);
+        const wrongAnswer = new intervalNode_1.IntervalNode(root1Tree, root2Tree, closure_1.ClosureType.FF).toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { racine1, racine2, coin, a }) => {
+    const r1 = new numberNode_1.NumberNode(racine1);
+    const r2 = new numberNode_1.NumberNode(racine2);
+    const answer = coin * a < 0
+        ? new intervalNode_1.IntervalNode(r1, r2, closure_1.ClosureType.FF)
+        : new unionIntervalNode_1.UnionIntervalNode([
+            new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, r1, closure_1.ClosureType.OF),
+            new intervalNode_1.IntervalNode(r2, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.FO),
+        ]);
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.thirdDegreeFunctionVariation = {
+    id: "thirdDegreeFunctionVariation",
+    connector: "=",
+    label: "Lecture du signe de la dérivée via les variations d'une fonction",
+    levels: [
+        "1reESM",
+        "1reSpé",
+        "1reTech",
+        "MathComp",
+        "1rePro",
+        "TermPro",
+        "TermTech",
+    ],
+    sections: ["Dérivation"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThirdDegreeFunctionVariation, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/derivation/derivative/usualderivative.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercise";
+type Identifiers = {
+    type: number;
+    a?: number;
+    b?: number;
+    coefficients?: number[];
+    tex?: string;
+};
+export declare const usualDerivative: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=usualderivative.d.ts.map

package/lib/exercises/math/derivation/derivative/usualderivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usualderivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/usualderivative.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAMT,MAAM,mBAAmB,CAAC;AAuB3B,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AA0FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAqBjD,CAAC"}

package/lib/exercises/math/derivation/derivative/usualderivative.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usualDerivative = void 0;
+const randint_1 = require("../../../../math/utils/random/randint");
+const getDistinctQuestions_1 = require("../../../utils/getDistinctQuestions");
+const constanteDerivative_1 = require("./constanteDerivative");
+const firstDegreeDerivative_1 = require("./firstDegreeDerivative");
+const secondDegreeDerivative_1 = require("./secondDegreeDerivative");
+const thirdDegreeDerivative_1 = require("./thirdDegreeDerivative");
+const getUsualDerivative = () => {
+    const type = (0, randint_1.randint)(1, 5);
+    let question;
+    let identifiers;
+    switch (type) {
+        case 1:
+            question = (0, firstDegreeDerivative_1.getFirstDegreeDerivative)();
+            identifiers = { ...question.identifiers, type: 1 };
+            break;
+        case 2:
+            question = (0, secondDegreeDerivative_1.getSecondDegreeDerivative)();
+            identifiers = { ...question.identifiers, type: 2 };
+            break;
+        case 3:
+            question = (0, thirdDegreeDerivative_1.getThirdDegreeDerivative)();
+            identifiers = { ...question.identifiers, type: 3 };
+            break;
+        case 4:
+            question = (0, constanteDerivative_1.getConstanteDerivative)();
+            identifiers = { ...question.identifiers, type: 4 };
+            break;
+        default:
+            throw Error("erreur");
+    }
+    return { ...question, identifiers };
+};
+const getPropositions = (n, { answer, type, a, b, coefficients, tex }) => {
+    let props;
+    switch (type) {
+        case 1:
+            props = (0, firstDegreeDerivative_1.getFirstDegreeDerivativePropositions)(n, { a: a, answer, b: b });
+            break;
+        case 2:
+            props = (0, secondDegreeDerivative_1.getSecondDegreeDerivativePropositions)(n, {
+                answer,
+                coefficients: coefficients,
+            });
+            break;
+        case 3:
+            props = (0, thirdDegreeDerivative_1.getThirdDegreeDerivativePropositions)(n, {
+                answer,
+                coefficients: coefficients,
+            });
+            break;
+        case 4:
+            props = (0, constanteDerivative_1.getConstanteDerivativePropositions)(n, { answer, tex: tex });
+            break;
+        default:
+            throw Error("erreur");
+    }
+    return props;
+};
+const isAnswerValid = (ans, { answer, type, coefficients, a, b, tex }) => {
+    let valid;
+    switch (type) {
+        case 1:
+            valid = (0, firstDegreeDerivative_1.isFirstDegreeDerivativeAnswerValid)(ans, { answer, a: a, b: b });
+            break;
+        case 2:
+            valid = (0, secondDegreeDerivative_1.isSecondDegreeDerivativeAnswerValid)(ans, {
+                coefficients: coefficients,
+                answer,
+            });
+            break;
+        case 3:
+            valid = (0, thirdDegreeDerivative_1.isThirdDegreeDerivativeAnswerValid)(ans, {
+                coefficients: coefficients,
+                answer,
+            });
+            break;
+        case 4:
+            valid = (0, constanteDerivative_1.isConstanteDerivativeAnswerValid)(ans, { answer, tex: tex });
+            break;
+        default:
+            throw Error("erreur");
+    }
+    return valid;
+};
+exports.usualDerivative = {
+    id: "usualDerivative",
+    connector: "=",
+    label: "Dérivées des fonctions de référence",
+    levels: [
+        "1reESM",
+        "1reSpé",
+        "1reTech",
+        "MathComp",
+        "1rePro",
+        "TermPro",
+        "TermTech",
+    ],
+    sections: ["Dérivation"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getUsualDerivative, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/derivation/derivativeNumberCalcul.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    coeffs: number[];
+    x: number;
+};
+export declare const derivativeNumberCalcul: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=derivativeNumberCalcul.d.ts.map

package/lib/exercises/math/derivation/derivativeNumberCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeNumberCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/derivation/derivativeNumberCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuCF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/derivation/derivativeNumberCalcul.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivativeNumberCalcul = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../../math/polynomials/polynomial");
+const randint_1 = require("../../../math/utils/random/randint");
+const getDerivativeNumberCalculQuestion = () => {
+    const x = (0, randint_1.randint)(-9, 10);
+    const trinom = polynomial_1.PolynomialConstructor.randomWithOrder(2);
+    const instruction = `Soit $f(x) = ${trinom
+        .toTree()
+        .toTex()}$. Calculer $f'(${x})$.`;
+    const answer = trinom.derivate().calculate(x) + "";
+    const question = {
+        answer,
+        instruction,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { x, coeffs: trinom.coefficients },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongAnswer = (0, randint_1.randint)(-20, 20) + "";
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.derivativeNumberCalcul = {
+    id: "derivativeNumberCalcul",
+    connector: "=",
+    label: "Calculer un nombre dérivé via la définition",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Dérivation", "Limites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDerivativeNumberCalculQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/derivation/derivativeNumberReading.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    A: number[];
+    B: number[];
+};
+export declare const derivativeNumberReading: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=derivativeNumberReading.d.ts.map

package/lib/exercises/math/derivation/derivativeNumberReading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeNumberReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/derivation/derivativeNumberReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAmBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AA4FF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}

package/lib/exercises/math/derivation/derivativeNumberReading.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivativeNumberReading = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../../geogebra/colors");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const integer_1 = require("../../../math/numbers/integer/integer");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const polynomial_1 = require("../../../math/polynomials/polynomial");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getDerivativeNumberReading = () => {
+    let xA, yA, xB, yB;
+    [xA, yA] = [1, 2].map((el) => (0, randint_1.randint)(-5, 6));
+    xB = xA > 0 ? (0, randint_1.randint)(xA - 4, 6, [xA]) : (0, randint_1.randint)(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
+    yB = yA > 0 ? (0, randint_1.randint)(yA - 4, 6) : (0, randint_1.randint)(-4, yA + 5);
+    const pente = new rational_1.Rational(yB - yA, xB - xA).simplify();
+    const origin = pente
+        .opposite()
+        .multiply(new integer_1.Integer(xA))
+        .add(new integer_1.Integer(yA));
+    const penteTree = pente.toTree();
+    const originTree = origin.toTree();
+    const penteString = penteTree.toMathString();
+    const originString = originTree.toMathString();
+    const penteValue = pente.value;
+    const originValue = origin.value;
+    const [a, b] = [
+        (3 * (0, randint_1.randint)(-100, 100, [0])) / 100,
+        (2 * (0, randint_1.randint)(-4, 5)) / 100,
+    ];
+    const c = penteValue - a * Math.pow(xA, 2) - b * xA;
+    const d = yA - (a / 3) * Math.pow(xA, 3) - (b / 2) * Math.pow(xA, 2) - xA * c;
+    const polynome = new polynomial_1.Polynomial([d, c, b / 2, a / 3]);
+    const instruction = `Ci-dessous sont tracées la courbe $\\mathcal C_f$ de la fonction $f$ et la tangente à cette courbe au point d'abscisse $${xA}$.$\\\\$ Déterminer $f'(${xA})$.`;
+    const commands = [
+        `f(x) = ${polynome.toString()}`,
+        `SetColor(f, "${colors_1.blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        `g(x) = (${penteString}) * x + (${originString})`,
+        `SetColor(g, "${colors_1.orange}")`,
+        `A = (${xA},${yA})`,
+        "SetFixed(A, true)  ",
+    ];
+    const xMin = Math.min(xA, xB);
+    const yMin = Math.min(yA, yB);
+    const xMax = Math.max(xA, xB);
+    const yMax = Math.max(yA, yB);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+    });
+    const answer = penteTree.toTex();
+    const question = {
+        instruction,
+        startStatement: "a",
+        answer,
+        commands: ggb.commands,
+        // coords: ggb.getAdaptedCoords({ xMax, xMin, yMax, yMin }),
+        coords: [xMin - 5, xMax + 5, yMin - 5, yMax + 5],
+        options: ggb.getOptions(),
+        answerFormat: "tex",
+        keys: [],
+        identifiers: { A: [xA, yA], B: [xB, yB] },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, A, B }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    if (B[1] - A[1] !== 0)
+        (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational(B[0] - A[0], B[1] - A[1]).simplify().toTree().toTex());
+    while (propositions.length < n) {
+        const wrongAnswer = new numberNode_1.NumberNode((0, randint_1.randint)(-4, 5, [0]));
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { A, B }) => {
+    const answer = new rational_1.Rational(B[1] - A[1], B[0] - A[0])
+        .simplify()
+        .toTree({ allowFractionToDecimal: true });
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.derivativeNumberReading = {
+    id: "derivativeNumberReading",
+    connector: "=",
+    label: "Lecture de nombre dérivé",
+    levels: ["1reESM", "1reSpé", "1reTech", "MathComp", "1rePro"],
+    sections: ["Dérivation"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDerivativeNumberReading, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/derivation/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./derivative";
+export * from "./derivativeNumberCalcul";
+export * from "./derivativeNumberReading";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/derivation/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC"}

package/lib/exercises/math/derivation/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./derivative"), exports);
+__exportStar(require("./derivativeNumberCalcul"), exports);
+__exportStar(require("./derivativeNumberReading"), exports);

package/lib/exercises/math/equaDiff/equaDiffCheckSolutionFirstOrder.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    type: string;
+    d: number;
+    e: number;
+    f: number | undefined;
+};
+export declare const equaDiffCheckSolutionFirstOrder: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=equaDiffCheckSolutionFirstOrder.d.ts.map

package/lib/exercises/math/equaDiff/equaDiffCheckSolutionFirstOrder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equaDiffCheckSolutionFirstOrder.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/equaDiff/equaDiffCheckSolutionFirstOrder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAgBlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AAkHF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAejE,CAAC"}

package/lib/exercises/math/equaDiff/equaDiffCheckSolutionFirstOrder.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equaDiffCheckSolutionFirstOrder = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const affine_1 = require("../../../math/polynomials/affine");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const equalNode_1 = require("../../../tree/nodes/equations/equalNode");
+const expNode_1 = require("../../../tree/nodes/functions/expNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const doWhile_1 = require("../../../utils/doWhile");
+const random_1 = require("../../../utils/random");
+const getEquaDiffCheckSolutionFirstOrderQuestion = () => {
+    //types : constante, affine, tirnom, exp
+    const type = (0, random_1.random)(["affine", "trinom", "exp"]);
+    const isSolution = (0, coinFlip_1.coinFlip)();
+    const answer = isSolution ? "Oui" : "Non";
+    let equaDiff;
+    let randomFunc;
+    let d;
+    let e;
+    let f;
+    switch (type) {
+        case "affine":
+            // y = y' + dx+e, alors y = ax+b
+            //ax+b = a + dx + e
+            //a = d et e = b-a
+            const affineSolution = affine_1.AffineConstructor.random();
+            d = affineSolution.a;
+            e = affineSolution.b - affineSolution.a;
+            const affine = new affine_1.Affine(d, e);
+            equaDiff = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new variableNode_1.VariableNode("y'"), affine.toTree()));
+            randomFunc = isSolution
+                ? affineSolution.toTree()
+                : (0, doWhile_1.doWhile)(() => affine_1.AffineConstructor.random(), (P) => P.equals(affineSolution)).toTree();
+            break;
+        case "trinom":
+            /**y = y' + dx^2+ex+f, alors y = ax^2+bx+c */
+            const trinomSolution = trinom_1.TrinomConstructor.random();
+            d = trinomSolution.a;
+            e = trinomSolution.b - 2 * trinomSolution.a;
+            f = trinomSolution.c - trinomSolution.b;
+            const trinom = new trinom_1.Trinom(d, e, f);
+            equaDiff = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new variableNode_1.VariableNode("y'"), trinom.toTree()));
+            randomFunc = isSolution
+                ? trinomSolution.toTree()
+                : (0, doWhile_1.doWhile)(() => trinom_1.TrinomConstructor.random(), (P) => P.equals(trinomSolution)).toTree();
+            break;
+        case "exp":
+            /**y = y' +d exp(e*x), alors y = a exp(e*x) */
+            //a exp(ex) = ae*exp(ex) + dexp(e*x)
+            //a = ae + d
+            //d/(1-e) == a
+            e = (0, randint_1.randint)(-4, 5, [0, 1]);
+            const a = (0, randint_1.randint)(-5, 5, [0]);
+            d = a - a * e;
+            const expSolution = new multiplyNode_1.MultiplyNode(a.toTree(), new expNode_1.ExpNode(new multiplyNode_1.MultiplyNode(e.toTree(), new variableNode_1.VariableNode("x"))));
+            const exp = new multiplyNode_1.MultiplyNode(d.toTree(), new expNode_1.ExpNode(new multiplyNode_1.MultiplyNode(e.toTree(), new variableNode_1.VariableNode("x"))));
+            equaDiff = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new addNode_1.AddNode(new variableNode_1.VariableNode("y'"), exp));
+            randomFunc = isSolution
+                ? expSolution
+                : (0, doWhile_1.doWhile)(() => new multiplyNode_1.MultiplyNode((0, randint_1.randint)(-5, 5, [0]).toTree(), new expNode_1.ExpNode(new multiplyNode_1.MultiplyNode(e.toTree(), new variableNode_1.VariableNode("x")))), (P) => P.equals(expSolution));
+            break;
+    }
+    const question = {
+        answer,
+        instruction: `Soit l'équation différentielle suivante : $${equaDiff.toTex()}$. La fonction $y = ${randomFunc.toTex()}$ est-elle solution de cette équation ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { type, d, e, f },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.equaDiffCheckSolutionFirstOrder = {
+    id: "equaDiffCheckSolutionFirstOrder",
+    label: "Vérifier si une fonction est solution d'une équation différentielle du premier ordre",
+    levels: ["TermTech", "MathComp", "TermSpé"],
+    isSingleStep: true,
+    sections: ["Équations différentielles"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEquaDiffCheckSolutionFirstOrderQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCM",
+    subject: "Mathématiques",
+};

package/lib/exercises/math/equaDiff/equaDiffGeneralForme.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    a: number;
+};
+export declare const exponentialDifferentialEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=equaDiffGeneralForme.d.ts.map

package/lib/exercises/math/equaDiff/equaDiffGeneralForme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equaDiffGeneralForme.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/equaDiff/equaDiffGeneralForme.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8DF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/math/equaDiff/equaDiffGeneralForme.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exponentialDifferentialEquation = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const expNode_1 = require("../../../tree/nodes/functions/expNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const equalNode_1 = require("../../../tree/nodes/equations/equalNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getExponentialEquation = () => {
+    const a = (0, randint_1.randint)(-19, 20, [0]);
+    const equation = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("y"));
+    const answer = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new multiplyNode_1.MultiplyNode(new variableNode_1.VariableNode("C"), new expNode_1.ExpNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("x"))))).toTex();
+    const question = {
+        instruction: `Résoudre l'équation différentielle suivante : $y' = ${equation.toTex()}$.`,
+        startStatement: `y(x)`,
+        answer,
+        keys: ["x", "y", "epower", "exp", "C", "equal"],
+        answerFormat: "tex",
+        identifiers: { a },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const yNode = new variableNode_1.VariableNode("y");
+    const cNode = new variableNode_1.VariableNode("C");
+    const xNode = new variableNode_1.VariableNode("x");
+    while (propositions.length < n) {
+        const a = (0, randint_1.randint)(1, 10);
+        const myWrongAnswer = new equalNode_1.EqualNode(yNode, new multiplyNode_1.MultiplyNode(cNode, new expNode_1.ExpNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), xNode))));
+        (0, exercise_1.tryToAddWrongProp)(propositions, myWrongAnswer.toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a }) => {
+    const answer = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new multiplyNode_1.MultiplyNode(new variableNode_1.VariableNode("C"), new expNode_1.ExpNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("x")))), { allowRawRightChildAsSolution: true });
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.exponentialDifferentialEquation = {
+    id: "exponentialDifferentialEquation",
+    connector: "=",
+    label: "Équation différentielle $y' = ay$",
+    levels: ["1reSpé", "MathComp", "TermSpé"],
+    sections: ["Équations différentielles"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getExponentialEquation, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};