math-exercises 3.0.25 → 3.0.27

package/lib/exercises/math/calculLitteral/equation/equationType1Exercise.js

@@ -91,7 +91,7 @@ const isAnswerValid = (ans, { a, b }) => {
 export const equationType1Exercise = {
     id: "equa1",
     connector: "\\iff",
-    label: "Équations $x+a = b$",
+    label: "Résoudre une équation du type $x+a = b$",
     levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
     sections: ["Équations"],
     isSingleStep: true,

package/lib/exercises/math/dataRepresentations/functionGraphReading.d.ts

@@ -1,6 +1,8 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
-    yValue: number;
+    isAskingX: boolean;
+    xValue?: number;
+    yValue?: number;
     a: number;
     b: number;
 };

package/lib/exercises/math/dataRepresentations/functionGraphReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8FF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC;;AAEF,UAAU;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGE"}
+{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4HF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC;;AAEF,UAAU;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGE"}

package/lib/exercises/math/dataRepresentations/functionGraphReading.js

@@ -1,40 +1,60 @@
-import { addValidProp, shuffleProps, } from "../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randomColor } from "../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { approxEqual } from "../../../geogebra/parsers/approxEqual.js";
 import { Affine } from "../../../math/polynomials/affine.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { round } from "../../../math/utils/round.js";
-const getPropositions = (n, { answer }) => {
+import { valueParser } from "../../../tree/parsers/valueParser.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, a, b, yValue, isAskingX }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     while (propositions.length < n) {
-        throw Error("QCM not implemented");
+        if (isAskingX)
+            tryToAddWrongProp(propositions, randint(4, 60) + "");
+        else
+            tryToAddWrongProp(propositions, 100 * randint(20, 60) + "");
     }
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    const { a, b, yValue } = identifiers;
-    return round((yValue - b) / a, 0).frenchify();
+    const { a, b, yValue, xValue, isAskingX } = identifiers;
+    if (isAskingX) {
+        return round((yValue - b) / a, 0).frenchify();
+    }
+    else
+        return round(a * xValue + b, 0).frenchify();
 };
 const getInstruction = (identifiers) => {
-    const { yValue, a, b } = identifiers;
+    const { yValue, a, b, isAskingX, xValue } = identifiers;
     return `La droite $(d_1)$ modélise l'évolution du coût total d'un voyage scolaire en fonction du nombre de participants.
     
-Si le coût total du voyage est de $${yValue}€$, quel est le nombre de participants ?`;
+${isAskingX
+        ? `Si le coût total du voyage est de $${yValue}€$, quel est le nombre de participants ?`
+        : `Si le nombre de participants est $${xValue}$, quel est le coût total du voyage ?`}`;
 };
 // const getHint: GetHint<Identifiers> = (identifiers) => {};
 // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
 const getGGBOptions = (identifiers) => {
-    const { a, b, yValue } = identifiers;
+    const { a, b, yValue, isAskingX, xValue } = identifiers;
     const affine = new Affine(a, b);
-    const xValue = (yValue - b) / a;
+    const x = xValue ?? (yValue - b) / a;
+    const y = yValue ?? a * xValue + b;
+    const xText = 4;
+    const yText = a * xText + b;
+    const color = randomColor();
     const ggb = new GeogebraConstructor({
         commands: [
             `f = Function(${a}*x+${b}, 0, 1000)`,
-            `SetCaption(f, "$(d_1)$")`,
-            `ShowLabel(f,true)`,
+            `SetColor(f, "${color}")`,
+            `T = Text("$(d_1)$", (${xText},${yText}), true, true)`,
+            `SetColor(T, "${color}")`,
             `Text("Nombre \\ de \\ participants", (x(Corner(2)),50), true, true, -1)`,
             `Text("Coût \\ en \\ €", (1, y(Corner(4))), true, true)`,
+            // `(${xValue},${yValue})`,
         ],
         forbidShiftDragZoom: false,
         gridDistance: [2, 500],
@@ -52,26 +72,43 @@ const getGGBOptions = (identifiers) => {
         fontSize: 14,
     });
     const xMin = -2;
-    const xMax = xValue + 6;
+    const xMax = x + 6;
     const xDelta = xMax - xMin;
     const yMin = -100;
-    const yMax = Math.max(yValue + 500, xDelta);
+    const yMax = Math.max(y + 500, xDelta);
     return ggb.getOptions({
-        coords: [-1, xValue + 6, -100, yValue + 500],
+        coords: [-1, x + 6, -100, y + 500],
     });
 };
 const getKeys = (identifiers) => {
     return [];
 };
-const isAnswerValid = (ans, { answer }) => {
-    throw Error("VEA not implemented");
+const isAnswerValid = (ans, { answer, isAskingX }) => {
+    try {
+        const nbAnswer = answer.unfrenchify();
+        const parsed = valueParser(ans);
+        if (parsed === false)
+            return false;
+        return approxEqual(parsed, nbAnswer, isAskingX ? 1 : 200);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const getFunctionGraphReadingQuestion = (opts) => {
     const b = randint(0, 2000);
     const randPoint = [2 * randint(5, 20), 3000 + 500 * randint(1, 7)];
-    const yValue = randPoint[1];
-    const a = (yValue - b) / randPoint[0];
-    const identifiers = { a, b, yValue };
+    const isAskingX = coinFlip();
+    let yValue;
+    let xValue;
+    const a = (randPoint[1] - b) / randPoint[0];
+    if (isAskingX) {
+        yValue = randPoint[1];
+    }
+    else {
+        xValue = randPoint[0];
+    }
+    const identifiers = { a, b, yValue, isAskingX, xValue };
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -86,7 +123,7 @@ const getFunctionGraphReadingQuestion = (opts) => {
 };
 export const functionGraphReading = {
     id: "functionGraphReading",
-    label: "",
+    label: "Lire et interpréter la courbe d'une fonction",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getFunctionGraphReadingQuestion(opts), nb),
     qcmTimer: 60,

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

@@ -1,4 +1,4 @@
 export * from "./tableReading.js";
+export * from "./functionGraphReading.js";
 export * from "./pieChartReading.js";
-export * from "./testGen.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAGlC,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAElC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}

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

@@ -1,5 +1,5 @@
 export * from "./tableReading.js";
 // export * from "./barChartReading.js";
-// export * from "./functionGraphReading.js";
+export * from "./functionGraphReading.js";
 export * from "./pieChartReading.js";
-export * from "./testGen.js";
+// export * from "./testGen.js";

package/lib/exercises/math/dataRepresentations/testGen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testGen.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/testGen.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAsDF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAezC,CAAC"}
+{"version":3,"file":"testGen.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/testGen.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AA8DF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAkBzC,CAAC"}

package/lib/exercises/math/dataRepresentations/testGen.js

@@ -33,6 +33,12 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
+const getHint = (identifiers) => {
+    return "voici l'indice";
+};
+const getCorrection = (identifiers) => {
+    return "voici la correction";
+};
 const getTestGenQuestion = (ops) => {
     const identifiers = {
         rand: Math.random(),
@@ -43,6 +49,8 @@ const getTestGenQuestion = (ops) => {
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
         answerFormat: "tex",
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         identifiers,
     };
     return question;
@@ -61,4 +69,7 @@ export const testGen = {
     getAnswer,
     isQCM: true,
     answerType: "QCM",
+    hasHintAndCorrection: true,
+    getHint,
+    getCorrection,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"convexityQuadrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/convexityQuadrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAqHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"convexityQuadrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/convexityQuadrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAqIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

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

@@ -11,13 +11,24 @@ import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
 import { intervalParser } from "../../../../tree/parsers/intervalParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-const getConvexityQuadrinomialsQuestion = () => {
-    const quadrinomial = PolynomialConstructor.randomWithOrder(3);
-    const quadcoeffs = quadrinomial.coefficients;
+const getInstruction = (identifiers) => {
+    const { askConvex, quadcoeffs } = identifiers;
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const questionType = askConvex ? "convexe" : "concave";
+    return `Soit la fonction $f$ définie par : 
+  
+$$
+f(x) = ${quadrinomial.toTex()}
+$$
+
+Sur quelle intervalle $f$ est-elle ${questionType} ?`;
+};
+const getAnswer = (identifiers) => {
+    const { askConvex, quadcoeffs } = identifiers;
+    const quadrinomial = new Polynomial(quadcoeffs);
     const secondderivative = quadrinomial.derivate().derivate();
     const seconddcoeffs = secondderivative.coefficients;
     const inflexionPoint = new FractionNode(new MultiplyNode(seconddcoeffs[0].toTree(), new NumberNode(-1)), seconddcoeffs[1].toTree()).simplify();
-    const askConvex = coinFlip();
     let interval;
     if (askConvex) {
         interval =
@@ -31,13 +42,19 @@ const getConvexityQuadrinomialsQuestion = () => {
                 ? new IntervalNode(inflexionPoint, PlusInfinityNode, ClosureType.OO).toTex()
                 : new IntervalNode(MinusInfinityNode, inflexionPoint, ClosureType.OO).toTex();
     }
-    const questionType = askConvex ? "convexe" : "concave";
+    return interval;
+};
+const getConvexityQuadrinomialsQuestion = () => {
+    const quadrinomial = PolynomialConstructor.randomWithOrder(3);
+    const quadcoeffs = quadrinomial.coefficients;
+    const askConvex = coinFlip();
+    const identifiers = { askConvex, quadcoeffs };
     const question = {
-        answer: interval,
-        instruction: `Soit la fonction $f(x) = ${quadrinomial.toTex()}$. Sur quelle intervalle est-elle ${questionType} ?`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["rbracket", "lbracket", "semicolon", "infty", "reals"],
         answerFormat: "tex",
-        identifiers: { askConvex, quadcoeffs },
+        identifiers,
     };
     return question;
 };
@@ -72,9 +89,7 @@ const isAnswerValid = (ans, { answer, askConvex, quadcoeffs }) => {
 export const convexityQuadrinomials = {
     id: "convexityQuadrinomials",
     label: "Convexité des fonctions polynomiales de degré $3$",
-    levels: ["TermSpé"],
     isSingleStep: true,
-    sections: ["Dérivation"],
     generator: (nb) => getDistinctQuestions(getConvexityQuadrinomialsQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -82,4 +97,6 @@ export const convexityQuadrinomials = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"convexityTrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/convexityTrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAgCF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"convexityTrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/convexityTrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA0CF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}

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

@@ -1,15 +1,30 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+const getInstruction = (identifiers) => {
+    const trinom = TrinomConstructor.fromCoeffs(identifiers.coeffs);
+    return `Soit la fonction $f$ définie par : 
+  
+$$
+f(x) = ${trinom.toTex()}
+$$
+
+Sur $\\mathbb{R}$, $f$ est :`;
+};
+const getAnswer = (identifiers) => {
+    const trinom = TrinomConstructor.fromCoeffs(identifiers.coeffs);
+    const isConvex = trinom.a > 0 ? "Convexe" : "Concave";
+    return isConvex;
+};
 const getConvexityTrinomialsQuestion = () => {
     const trinom = TrinomConstructor.random();
-    const isConvex = trinom.a > 0 ? "Convexe" : "Concave";
+    const identifiers = { coeffs: trinom.coefficients };
     const question = {
-        answer: isConvex,
-        instruction: `Soit la fonction $f(x) = ${trinom.toTex()}$. Sur $\\mathbb{R}$, $f$ est :`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "raw",
-        identifiers: { coeffs: trinom.coefficients },
+        identifiers,
     };
     return question;
 };
@@ -22,20 +37,16 @@ const getPropositions = (n, { answer }) => {
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    throw Error("VEA not implemented");
-};
 export const convexityTrinomials = {
     id: "convexityTrinomials",
     label: "Déterminer la convexité d'un trinôme",
-    levels: ["TermSpé"],
     isSingleStep: true,
-    sections: ["Dérivation"],
     generator: (nb) => getDistinctQuestions(getConvexityTrinomialsQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     answerType: "QCU",
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"cosCompositionDerivation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/cosCompositionDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA+DF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}
+{"version":3,"file":"cosCompositionDerivation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/cosCompositionDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAmFF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}

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

@@ -5,16 +5,33 @@ import { CosNode } from "../../../../tree/nodes/functions/cosNode.js";
 import { OppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
 import { SinNode } from "../../../../tree/nodes/functions/sinNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
-const getCosCompositionDerivationQuestion = () => {
-    const affine = AffineConstructor.random(undefined, { excludes: [0] });
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { affineA, affineB } = identifiers;
+    const affine = new Affine(affineA, affineB);
     const fct = new CosNode(affine.toTree());
+    return `Déterminer la dérivée de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${fct.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { affineA, affineB } = identifiers;
+    const affine = new Affine(affineA, affineB);
     const deriv = new MultiplyNode((-affine.a).toTree(), new SinNode(affine.toTree()));
+    return deriv.toTex();
+};
+const getCosCompositionDerivationQuestion = () => {
+    const affine = AffineConstructor.random(undefined, { excludes: [0] });
+    const identifiers = { affineA: affine.a, affineB: affine.b };
     const question = {
-        answer: deriv.toTex(),
-        instruction: `Déterminer la dérivée de la fonction $f(x) = ${fct.toTex()}$`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["x", "sin", "cos", "tan"],
         answerFormat: "tex",
-        identifiers: { affineA: affine.a, affineB: affine.b },
+        identifiers,
     };
     return question;
 };
@@ -33,22 +50,32 @@ const getPropositions = (n, { answer, affineA, affineB }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer, affineA, affineB }) => {
-    const affine = new Affine(affineA, affineB);
-    const deriv = new MultiplyNode((-affineA).toTree(), new SinNode(affine.toTree()));
-    const texs = deriv.toAllValidTexs();
-    return texs.includes(ans);
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const cosCompositionDerivation = {
     id: "cosCompositionDerivation",
     connector: "=",
     label: "Dérivée de $\\cos(ax+b)$",
-    levels: ["1reSpé"],
     isSingleStep: true,
-    sections: ["Dérivation"],
     generator: (nb) => getDistinctQuestions(getCosCompositionDerivationQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"cosSecondDegreeDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/cosSecondDegreeDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAoHF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}
+{"version":3,"file":"cosSecondDegreeDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/cosSecondDegreeDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA+HF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

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

@@ -8,19 +8,36 @@ import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { affinecoeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(affinecoeffs);
+    const func = new CosNode(affine.toTree().simplify({ forbidFactorize: true })).toTex();
+    return `Calculez la dérivée seconde de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${func}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { affinecoeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(affinecoeffs);
+    const ans = new MultiplyNode(new MultiplyNode(new PowerNode(affinecoeffs[1].toTree(), new NumberNode(2)), new NumberNode(-1)), new CosNode(affine.toTree().simplify({ forbidFactorize: true })))
+        .simplify({ forbidFactorize: true })
+        .toTex();
+    return ans;
+};
 const getCosSecondDegreeDerivativeQuestion = () => {
     const affine = AffineConstructor.random();
     const affinecoeffs = affine.coefficients;
-    const ans = new MultiplyNode(new MultiplyNode(new PowerNode(affinecoeffs[1].toTree(), new NumberNode(2)), new NumberNode(-1)), new CosNode(affine.toTree().simplify({ forbidFactorize: true })))
-        .simplify()
-        .toTex();
-    const func = new CosNode(affine.toTree().simplify({ forbidFactorize: true })).toTex();
+    const identifiers = { affinecoeffs };
     const question = {
-        answer: ans,
-        instruction: `Calculez la dérivée seconde de la fonction $f(x) = ${func}$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["x", "sin", "cos", "tan"],
         answerFormat: "tex",
-        identifiers: { affinecoeffs },
+        identifiers,
     };
     return question;
 };
@@ -56,21 +73,31 @@ const getPropositions = (n, { answer, affinecoeffs }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer, affinecoeffs }) => {
-    const affine = new AddNode(new MultiplyNode(new NumberNode(affinecoeffs[1]), new VariableNode("x")), new NumberNode(affinecoeffs[0])).simplify({ forbidFactorize: true });
-    const validanswer = new MultiplyNode(new MultiplyNode(new PowerNode(new NumberNode(affinecoeffs[1]), new NumberNode(2)), new NumberNode(-1)), new CosNode(affine)).simplify();
-    const latexs = validanswer.toAllValidTexs();
-    return latexs.includes(ans);
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const cosSecondDegreeDerivative = {
     id: "cosSecondDegreeDerivative",
     label: "Dérivée seconde de $\\cos(u)$",
-    levels: ["TermSpé"],
     isSingleStep: true,
-    sections: ["Dérivation"],
     generator: (nb) => getDistinctQuestions(getCosSecondDegreeDerivativeQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"expDerivativeFour.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/expDerivativeFour.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA4EF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}
+{"version":3,"file":"expDerivativeFour.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/expDerivativeFour.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAgFF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}

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

@@ -11,7 +11,11 @@ const getInstruction = (identifiers) => {
     const affine2 = new Affine(affine2Coeffs[1], affine2Coeffs[0]);
     const exp = new ExpNode(affine2.toTree());
     const fct = new MultiplyNode(affine1.toTree(), exp);
-    return `Déterminer la dérivée de la fonction $f(x) = ${fct.toTex()}$`;
+    return `Déterminer la dérivée de la fonction $f$ définie par :
+  
+$$
+f(x) = ${fct.toTex()}
+$$`;
 };
 const getAnswer = (identifiers) => {
     const { affine1Coeffs, affine2Coeffs } = identifiers;

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

@@ -1 +1 @@
-{"version":3,"file":"expDerivativeOne.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/expDerivativeOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqDF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}
+{"version":3,"file":"expDerivativeOne.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/expDerivativeOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}

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

@@ -6,20 +6,37 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { ExpNode } from "../../../../tree/nodes/functions/expNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
-const getExpDerivative = () => {
-    const a = randint(-9, 10, [0]);
-    const b = randint(-9, 10);
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Polynomial([b, a]);
+    const myfunction = new ExpNode(affine.toTree());
+    return `Déterminer la dérivée de la fonction $f$ définie par :
+  
+$$
+f(x) = ${myfunction.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
     const affine = new Polynomial([b, a]);
     const myfunction = new ExpNode(affine.toTree());
     const derivative = new MultiplyNode(new NumberNode(a), myfunction);
     const answer = derivative.toTex();
+    return answer;
+};
+const getExpDerivative = () => {
+    const a = randint(-9, 10, [0]);
+    const b = randint(-9, 10);
+    const identifiers = { a, b };
     const question = {
-        instruction: `Déterminer la dérivée de la fonction $f(x) = ${myfunction.toTex()}$.`,
+        instruction: getInstruction(identifiers),
         startStatement: "f'(x)",
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["x", "epower", "exp"],
         answerFormat: "tex",
-        identifiers: { a, b },
+        identifiers,
     };
     return question;
 };
@@ -36,19 +53,32 @@ const getPropositions = (n, { answer, a, b }) => {
         tryToAddWrongProp(propositions, new MultiplyNode(new NumberNode(randint(-9, 10)), myfunction).toTex());
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { a, b }) => {
-    const affine = new Polynomial([b, a]);
-    const myfunction = new ExpNode(affine.toTree());
-    const derivative = new MultiplyNode(new NumberNode(a), myfunction);
-    const texs = derivative.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, a, b }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        console.log(parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex());
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const expDerivativeOne = {
     id: "expDerivativeOne",
     connector: "=",
     label: "Dérivée de $\\exp(ax + b)$",
-    levels: ["1reESM", "1reSpé", "1reTech", "MathComp", "TermSpé"],
-    sections: ["Dérivation", "Exponentielle"],
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getExpDerivative, nb),
     qcmTimer: 60,
@@ -56,4 +86,6 @@ export const expDerivativeOne = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };