math-exercises 3.0.47 → 3.0.49

package/lib/exercises/math/geometry/lines/isPointOnCartesianLine.js

@@ -0,0 +1,118 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { randomLetter } from "../../../../utils/strings/randomLetter.js";
+const getCartesianEquation = (identifiers) => {
+    const { a, b, c } = identifiers;
+    return add(add(multiply(a, "x"), multiply(b, "y")), c).simplify({
+        forbidFactorize: true,
+    });
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return identifiers.isOnLine ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { x, y } = identifiers;
+    const point = new Point(randomLetter(true), reifyAlgebraic(x), reifyAlgebraic(y));
+    return `On considère la droite $d$ d'équation cartésienne :
+  
+$$
+${getCartesianEquation(identifiers).toTex()}=0
+$$
+
+Le point $${point.toTexWithCoords()}$ appartient-il à $d$ ?`;
+};
+const getHint = (identifiers) => {
+    return `Remplace $x$ et $y$ dans l'équation de la droite par les coordonnées du point. Le point appartient à la droite si et seulement si le résultat est égal à $0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { x, y } = identifiers;
+    const xNode = reifyAlgebraic(x);
+    const yNode = reifyAlgebraic(y);
+    const equation = getCartesianEquation(identifiers);
+    const detailed = equation.toDetailedEvaluation({ x: xNode, y: yNode });
+    const simp = detailed.simplify();
+    return `On remplace $x$ et $y$ dans l'équation de la droite par les coordonnées du point :
+
+${alignTex([
+        ["", detailed.toTex()],
+        ["=", simp.toTex()],
+    ])}
+
+${identifiers.isOnLine
+        ? `On obtient bien $0$. Le point appartient donc bien à la droite.`
+        : `On n'obtient pas $0$. Le point n'appartient donc pas à la droite.`}
+  `;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getIsPointOnLineQuestion = () => {
+    let a;
+    let b;
+    let c;
+    do {
+        a = randint(-9, 10);
+        b = randint(-9, 10, a === 0 ? [0] : undefined);
+        c = randint(-9, 10, (a === 1 && b === 0) || (a === 0 && b === 1) ? [0] : undefined);
+    } while (gcd(a, b, c) !== 1 || (a <= 0 && b <= 0 && c <= 0));
+    const isOnLine = coinFlip();
+    const x = b === 0 && isOnLine ? frac(-c, a).simplify() : randint(-10, 10).toTree();
+    const yOnLine = b === 0 ? (0).toTree() : frac(substract(-c, multiply(a, x)), b).simplify();
+    const y = isOnLine ? yOnLine : add(yOnLine, randint(-10, 10, [0])).simplify();
+    const identifiers = {
+        x: x.toIdentifiers(),
+        y: y.toIdentifiers(),
+        isOnLine,
+        a,
+        b,
+        c,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const isPointOnCartesianLine = {
+    id: "isPointOnCartesianLine",
+    connector: "=",
+    label: "Vérifier si un point appartient à une droite d'équation cartésienne donnée",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getIsPointOnLineQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/lines/isPointOnLine.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    affineA: number;
+    affineB: number;
+    x: number;
+    y: number;
+    isOnLine: boolean;
+};
+export declare const isPointOnLine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isPointOnLine.d.ts.map

package/lib/exercises/math/geometry/lines/isPointOnLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPointOnLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/isPointOnLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAoFF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAgB/C,CAAC"}

package/lib/exercises/math/geometry/lines/isPointOnLine.js

@@ -0,0 +1,94 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { randomLetter } from "../../../../utils/strings/randomLetter.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return identifiers.isOnLine ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const point = new Point(randomLetter(true), identifiers.x.toTree(), identifiers.y.toTree());
+    const affine = new Affine(identifiers.affineA, identifiers.affineB);
+    return `Le point $${point.toTexWithCoords()}$ appartient-il à la droite d'équation $${affine.toReducedEquation()}$ ?`;
+};
+const getHint = (identifiers) => {
+    return `Remplace $x$ dans l'équation de la droite par l'abscisse du point. Le point appartient à la droite si et seulement si le résultat est égal à l'ordonnée du point.`;
+};
+const getCorrection = (identifiers) => {
+    const affine = new Affine(identifiers.affineA, identifiers.affineB);
+    const affineTree = affine.toTree();
+    const res = affine.calculate(identifiers.x).toTree().toTex();
+    return `On remplace $x$ dans l'équation de la droite par l'abscisse du point : 
+  
+${alignTex([
+        [
+            "y",
+            "=",
+            affineTree.toDetailedEvaluation({ x: identifiers.x.toTree() }).toTex(),
+        ],
+        ["", "=", res],
+    ])}
+
+${identifiers.isOnLine
+        ? `On obtient bien l'ordonnée du point. Ainsi, le point appartient bien à la droite.`
+        : `On n'obtient pas l'ordonnée du point. Ainsi, le point n'appartient pas à la droite.`}
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getIsPointOnLineQuestion = () => {
+    const affine = AffineConstructor.random();
+    const x = randint(-10, 10);
+    const isOnLine = coinFlip();
+    const yOnLine = affine.calculate(x);
+    const y = isOnLine ? yOnLine : yOnLine + randint(-10, 10, [0]);
+    const identifiers = {
+        x,
+        y,
+        isOnLine,
+        affineA: affine.a,
+        affineB: affine.b,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const isPointOnLine = {
+    id: "isPointOnLine",
+    connector: "=",
+    label: "Vérifier si un point appartient à une droite d'équation $y=ax+b$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getIsPointOnLineQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/triangles/triangleThirdAngleValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangleThirdAngleValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/triangleThirdAngleValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,mBAAmB,EAEpB,MAAM,2CAA2C,CAAC;AAQnD,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAkIF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}
+{"version":3,"file":"triangleThirdAngleValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/triangleThirdAngleValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,mBAAmB,EAEpB,MAAM,2CAA2C,CAAC;AASnD,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8IF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAoBzD,CAAC"}

package/lib/exercises/math/geometry/triangles/triangleThirdAngleValue.js

@@ -6,6 +6,7 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
 import { DegreeNode } from "../../../../tree/nodes/geometry/degree.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { degreeParser } from "../../../../tree/parsers/degreeParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getPropositions = (n, { answer }) => {
@@ -20,7 +21,13 @@ const getPropositions = (n, { answer }) => {
 const getAnswer = (identifiers) => {
     const { triangleIdentifiers, angleAsked } = identifiers;
     const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
-    return triangle.angles[angleAsked].getValueNode(true).toTex() + "^{\\circ}";
+    const angles = [
+        triangle.angles[(angleAsked + 1) % 3].getValueNode(true),
+        triangle.angles[(angleAsked + 2) % 3].getValueNode(true),
+    ];
+    const addAngles = add(angles[0], angles[1]);
+    const simp = addAngles.simplify();
+    return substract(180, simp).simplify().toTex() + "^{\\circ}";
 };
 const getInstruction = (identifiers) => {
     const { triangleIdentifiers, angleAsked } = identifiers;
@@ -66,7 +73,9 @@ $$`;
 const getGGBOptions = (identifiers) => {
     const { triangleIdentifiers, angleAsked } = identifiers;
     const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
-    triangle.drawAngles([angleAsked], { fitCaption: true, color: "red" });
+    // triangle.drawAngles([angleAsked], { fitCaption: true, color: "black" });
+    triangle.drawAngles([angleAsked]);
+    triangle.highlightAngle(angleAsked, { color: "red" });
     const ggb = new GeogebraConstructor({
         commands: [...triangle.commands],
         hideAxes: true,
@@ -101,7 +110,10 @@ const getTriangleThirdAngleValueQuestion = (opts) => {
         triangleIdentifiers: triangle.toIdentifiers(),
         angleAsked: randint(0, 3),
     };
-    const question = {
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
@@ -111,7 +123,6 @@ const getTriangleThirdAngleValueQuestion = (opts) => {
         correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
     };
-    return question;
 };
 export const triangleThirdAngleValue = {
     id: "triangleThirdAngleValue",
@@ -131,4 +142,5 @@ export const triangleThirdAngleValue = {
     getGGBOptions,
     hasGeogebra: true,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/probaStat/probabilityTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probabilityTree.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probabilityTree.ts"],"names":[],"mappings":"AAYA,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,OAAO,EACL,QAAQ,EAeT,MAAM,mBAAmB,CAAC;AAmC3B,KAAK,WAAW,GAAG;IAIjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4MF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB1D,CAAC"}
+{"version":3,"file":"probabilityTree.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probabilityTree.ts"],"names":[],"mappings":"AAWA,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,OAAO,EACL,QAAQ,EAeT,MAAM,mBAAmB,CAAC;AAmC3B,KAAK,WAAW,GAAG;IAIjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4MF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB1D,CAAC"}

package/lib/exercises/math/probaStat/stats1var/etendueList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"etendueList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmDF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAc7C,CAAC"}
+{"version":3,"file":"etendueList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAgFF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAkB7C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/etendueList.js

@@ -1,28 +1,50 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { sortedValues } = identifiers;
+    return `On considère la liste de valeurs suivante : 
+  
+$$
+${sortedValues.join("\\ ;\\ ")}
+$$
+    
+Calculer l'étendue de cette liste de valeurs.`;
+};
+const getAnswer = (identifiers) => {
+    const { sortedValues } = identifiers;
+    const answer = (sortedValues[sortedValues.length - 1] - sortedValues[0]).frenchify();
+    return answer;
+};
+const getHint = (identifiers) => {
+    return "L'étendue d'une liste de valeurs est la différence entre la valeur maximale et la valeur minimale.";
+};
+const getCorrection = (identifiers) => {
+    const { sortedValues } = identifiers;
+    return `L'étendue est la différence entre la valeur maximale et la valeur minimale : 
+
+$$
+${sortedValues[sortedValues.length - 1]} - ${sortedValues[0]} = ${getAnswer(identifiers)}
+$$
+    `;
+};
 const getEtendueListQuestion = () => {
     let randomValues = [];
     const length = randint(6, 10);
     for (let i = 0; i < length; i++)
         randomValues.push(randint(1, 20));
     const sortedValues = randomValues.sort((a, b) => a - b);
-    const answer = (sortedValues[sortedValues.length - 1] - sortedValues[0]).frenchify();
+    const identifiers = { sortedValues };
     const question = {
-        answer,
-        instruction: `On considère la liste suivante : $${randomValues.join(";\\ ")}.$
-    $\\\\$Calculer l'étendue de cette liste de valeurs.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { sortedValues },
-        hint: "L'étendue d'une liste de valeurs est la différence entre la valeur maximale et la valeur minimale.",
-        correction: `
-On calcule la différence entre la valeur maximale et la valeur minimale : 
-
-$$
-${sortedValues[sortedValues.length - 1]} - ${sortedValues[0]} = ${answer}
-$$
-    `,
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -36,7 +58,13 @@ const getPropositions = (n, { answer, sortedValues }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const etendueList = {
     id: "etendueList",
@@ -52,4 +80,8 @@ export const etendueList = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getHint,
+    getCorrection,
 };

package/lib/exercises/math/trigonometry/trigonometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AASnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAsHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAe9C,CAAC"}
+{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AASnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAyJF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAmB9C,CAAC"}

package/lib/exercises/math/trigonometry/trigonometry.js

@@ -7,17 +7,18 @@ import { LengthNode } from "../../../tree/nodes/geometry/lengthNode.js";
 import { FractionNode } from "../../../tree/nodes/operators/fractionNode.js";
 import { random } from "../../../utils/alea/random.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-const getTrigonometry = () => {
-    const triangle = RightTriangleConstructor.randomNiceSides({
-        randomName: true,
-    });
+const getInstruction = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
     const trigo = ["le cosinus", "le sinus", "la tangente"];
-    const randTrigo = randint(0, 3);
-    const randAngle = random([1, 2]);
-    triangle.highlightAngle(randAngle, { color: "red" });
-    const [sideA, sideB, sideC] = triangle.sides.map((s) => s.toInsideName());
     const angleSummit = triangle.points[randAngle].name;
+    return `À quel quotient est égal ${trigo[randTrigo]} de l'angle $${triangle.angles[randAngle].toTex()}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
     let quotient;
+    const [sideA, sideB, sideC] = triangle.sides.map((s) => s.toInsideName());
     switch (randAngle) {
         case 1: //angle B
             quotient = [
@@ -35,27 +36,49 @@ const getTrigonometry = () => {
             ];
             break;
     }
+    const answer = quotient[randTrigo];
+    return answer;
+};
+const getKeys = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return [...triangle.points.map((p) => p.name), "equal"];
+};
+const getGGBOptions = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    triangle.highlightAngle(randAngle, { color: "red" });
     const ggb = new GeogebraConstructor({
         commands: triangle.commands,
         hideAxes: true,
         hideGrid: true,
     });
-    const answer = quotient[randTrigo];
-    const question = {
-        instruction: `À quel quotient est égal ${trigo[randTrigo]} de l'angle $\\widehat{${angleSummit}}$ ?`,
-        answer,
-        keys: [...triangle.points.map((p) => p.name), "equal"],
-        ggbOptions: ggb.getOptions({
-            coords: triangle.generateCoords(),
-        }),
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getTrigonometry = () => {
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const randTrigo = randint(0, 3);
+    const randAngle = random([1, 2]);
+    const identifiers = {
+        triangleIdentifiers: triangle.toIdentifiers(),
+        randAngle,
+        randTrigo,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: {
-            triangleIdentifiers: triangle.toIdentifiers(),
-            randAngle,
-            randTrigo,
-        },
+        identifiers,
     };
-    return question;
 };
 const getPropositions = (n, { answer, triangleIdentifiers }) => {
     const propositions = [];
@@ -116,4 +139,8 @@ export const trigonometry = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getGGBOptions,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/trigonometry/trigonometryAngleCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAOnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAyDF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAOnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA+EF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}

package/lib/exercises/math/trigonometry/trigonometryAngleCalcul.js

@@ -5,39 +5,57 @@ import { RightTriangleConstructor } from "../../../math/geometry/triangles/right
 import { randint } from "../../../math/utils/random/randint.js";
 import { round } from "../../../math/utils/round.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-const getTrigonometryAngleCalcul = () => {
-    const triangle = RightTriangleConstructor.randomNiceSides({
-        randomName: true,
-    });
-    const randAngle = randint(1, 3);
-    const hiddenSide = randint(0, 3);
+const getInstruction = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
     const givenSides = triangle.sides.filter((s, i) => i !== hiddenSide);
+    return `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${givenSides[0].toLengthTex()}$ cm et $${givenSides[1].toLengthTex()}$ cm. 
+    
+Calculer $\\widehat{${triangle.points[randAngle].name}}$ à $1^\\circ$ près.`;
+};
+const getAnswer = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const answer = round(triangle.angles[randAngle].evaluate(), 0);
+    return answer + "^{\\circ}";
+};
+const getGGBOptions = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
     triangle.showSidesLength([hiddenSide]);
     triangle.highlightAngle(randAngle, { color: "red" });
-    const answer = round(triangle.angles[randAngle].evaluate(), 0);
-    const answerTex = answer + "^{\\circ}";
     const ggb = new GeogebraConstructor({
         commands: triangle.commands,
         hideAxes: true,
         hideGrid: true,
     });
-    const question = {
-        instruction: `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${givenSides[0].toLengthTex()}$ cm et $${givenSides[1].toLengthTex()}$ cm. 
-    
-Calculer $\\widehat{${triangle.points[randAngle].name}}$ à $1^\\circ$ près.`,
-        answer: answerTex,
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getTrigonometryAngleCalcul = () => {
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const randAngle = randint(1, 3);
+    const hiddenSide = randint(0, 3);
+    const identifiers = {
+        randAngle,
+        hiddenSide,
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    const question = getQuestionFromIdentifiers(identifiers);
+    return question;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: ["degree"],
-        ggbOptions: ggb.getOptions({
-            coords: triangle.generateCoords(),
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: {
-            randAngle,
-            hiddenSide,
-            triangleIdentifiers: triangle.toIdentifiers(),
-        },
+        identifiers,
     };
-    return question;
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -64,4 +82,8 @@ export const trigonometryAngleCalcul = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getGGBOptions,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAMnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA8OF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAmBxD,CAAC"}
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAMnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAiPF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAoBxD,CAAC"}

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.js

@@ -12,7 +12,7 @@ const getInstruction = (identifiers) => {
     const { givenAngle, givenSide, sideAsked, triangleIdentifiers } = identifiers;
     const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
     const angleValue = triangle.angles[givenAngle].evaluate().frenchify();
-    return `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${triangle.sides[givenSide].toLengthTex()}$ cm et $\\widehat{${triangle.points[givenAngle].name}} = ${angleValue}^\\circ$. 
+    return `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${triangle.sides[givenSide].toLengthTex()}$ cm et $${triangle.angles[givenAngle].toTex()} = ${angleValue}^\\circ$. 
     
 Calculer $${triangle.sides[sideAsked].toInsideName()}$ à $0,1$ cm près.`;
 };
@@ -51,7 +51,10 @@ const getTrigonometrySideCalcul = () => {
         sideAsked,
         triangleIdentifiers: triangle.toIdentifiers(),
     };
-    const question = {
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
         instruction: getInstruction(identifiers),
         answer: getAnswer(identifiers),
         hint: getHint(identifiers),
@@ -61,7 +64,6 @@ const getTrigonometrySideCalcul = () => {
         answerFormat: "tex",
         identifiers,
     };
-    return question;
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -223,4 +225,5 @@ export const trigonometrySideCalcul = {
     getGGBOptions,
     getCorrection,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };