math-exercises 3.0.170 → 3.0.172

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiAngle.js

@@ -1,6 +1,5 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
-import { GeogebraConstructor } from "../../../../../../geogebra/geogebraConstructor.js";
 import { TriangleConstructor, } from "../../../../../../math/geometry/triangles/triangle.js";
 import { randfloat } from "../../../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../../../math/utils/random/randint.js";
@@ -16,7 +15,12 @@ import { parseAlgebraic } from "../../../../../../tree/parsers/latexParser.js";
 import { probaFlip } from "../../../../../../utils/alea/probaFlip.js";
 import { arrayRotation } from "../../../../../../utils/arrays/rotation.js";
 import { handleVEAError } from "../../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../../utils/latex/alignTex.js";
 const precision = 2;
+const strForKeyIdDegree = "^\\circ";
+const texWithDegreesUnit = (strUnitless) => {
+    return `${strUnitless}${strForKeyIdDegree}`;
+};
 const getHydrated = (identifiers) => {
     const { triangleIds, indexAngle } = identifiers;
     const triangle = TriangleConstructor.fromIdentifiers(triangleIds);
@@ -35,33 +39,30 @@ const getInstruction = (identifiers) => {
   
 ${triangle.sides.map((segment) => `- $${segment.toInsideName()} = ${segment.getLength().frenchify()}$`).join(`
   
-`)} 
-  
-Combien l'angle $${triangle.angles[indexAngle].toTexMini()}$ mesure-t-il ? 
-Donner une valeur approchée en degrés avec $${precision}$ décimales.`;
+`)}
+
+Donner une mesure en degrés (arrondie à deux décimales) de l’angle $${triangle.angles[indexAngle].toTexMini()}$.`;
 };
 const getAnswerStuff = (identifiers) => {
     const { sides } = getHydrated(identifiers);
     const nodeCosAngle = frac(substract(add(power(sides[1].getLengthNode(), 2), power(sides[2].getLengthNode(), 2)), power(sides[0].getLengthNode(), 2)), multiply(2, multiply(sides[1].getLengthNode(), sides[2].getLengthNode())));
     const nodeAngleInRadians = arccos(nodeCosAngle);
     const nodeAngleInDegrees = multiply(nodeAngleInRadians, frac(180, PiNode));
+    const angleInDegreesRounded = round(nodeAngleInDegrees.evaluate(), precision);
     return {
         nodeCosAngle,
         nodeAngleInRadians,
         nodeAngleInDegrees,
+        angleInDegreesRounded,
     };
 };
 const getAnswerNode = (identifiers) => {
-    return getAnswerStuff(identifiers).nodeAngleInDegrees;
+    return getAnswerStuff(identifiers).angleInDegreesRounded.toTree();
 };
 const getAnswer = (identifiers) => {
-    return round(getAnswerNode(identifiers).evaluate(), precision).frenchify();
+    return texWithDegreesUnit(getAnswerNode(identifiers).toTex());
 };
 const getHint = (identifiers) => {
-    const { angleNames } = getHydrated(identifiers);
-    return `Applique le théorème d'Al Kashi dans le triangle $ABC$ pour l'angle $${angleNames[0]}$.`;
-};
-const getCorrection = (identifiers) => {
     const { indexAngle } = identifiers;
     const { sides, angleNames } = getHydrated(identifiers);
     const sideNames = arrayRotation(sides, indexAngle)
@@ -73,66 +74,65 @@ const getCorrection = (identifiers) => {
             BC: "a",
         }[name];
     });
-    const nodeCosAngle = frac(substract(add(power(sideNames[1], 2), power(sideNames[2], 2)), power(sideNames[0], 2)), multiply(2, multiply(sideNames[1], sideNames[2])));
-    const nodeAngle = arccos(nodeCosAngle);
-    return `On applique le théorème d'Al Kashi dans le triangle $ABC$.
+    return `Applique le théorème d'Al-Kashi dans le triangle $ABC$ pour l'angle $${angleNames[0]}$. 
+  
+Rappel: 
 
-On utilise les notations suivantes : 
+Si on utilise les notations suivantes : 
 
 $$
 a \\ = \\ BC \\ ; \\ b \\ = \\ AC \\ ; \\ c \\ = \\ AB \\ 
 $$
 
+le théorème d'Al-Kashi s'écrit :
+
 $$
 ${sideNames[0]}^2 = ${sideNames[1]}^2 + ${sideNames[2]}^2 - 2 ${sideNames[1]}  ${sideNames[2]}  \\cos(${angleNames[0]})
-$$
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { indexAngle } = identifiers;
+    const { sides, angleNames } = getHydrated(identifiers);
+    const sideNames = arrayRotation(sides, indexAngle)
+        .map((segment) => segment.toInsideName())
+        .map((name) => {
+        return {
+            AB: "c",
+            AC: "b",
+            BC: "a",
+        }[name];
+    });
+    const nodeCosAngleWithVars = frac(substract(add(power(sideNames[1], 2), power(sideNames[2], 2)), power(sideNames[0], 2)), multiply(2, multiply(sideNames[1], sideNames[2])));
+    const nodeCosAngleWithValues = getAnswerStuff(identifiers).nodeCosAngle;
+    return `On applique le théorème d'Al-Kashi dans le triangle $ABC$.
+
+On utilise les notations suivantes : 
 
 $$
-\\cos(${angleNames[0]}) = ${nodeCosAngle.toTex()} 
+a \\ = \\ BC \\ ; \\ b \\ = \\ AC \\ ; \\ c \\ = \\ AB \\ 
 $$
 
-En radians :
+Avec ces notations, d'après le théorème d'Al-Kashi : 
 
 $$
-${angleNames[0]} = ${nodeAngle.toTex()}
+${sideNames[0]}^2 = ${sideNames[1]}^2 + ${sideNames[2]}^2 - 2 ${sideNames[1]}  ${sideNames[2]}  \\cos(${angleNames[0]})
 $$
 
-Il ne faut pas oublier de passer en degrés :
+On a donc
 
-$$
-${angleNames[0]}_{deg} = ${angleNames[0]}_{rad} \\times \\frac{180}{${PiNode.toTex()}}
-$$
+${alignTex([
+        [`\\cos(${angleNames[0]})`, "=", `${nodeCosAngleWithVars.toTex()}`],
+        ["", "=", `${nodeCosAngleWithValues.toTex()}`],
+    ])}
 
-On arrondit à la toute fin :
+À l’aide de la calculatrice réglée en degrés, on calcule alors $\\cos^{-1}$ et, comme d'habitude, on arrondit à la toute fin :
 
 $$
-${angleNames[0]} \\approx ${getAnswer(identifiers)} {}^{\\circ}
+${angleNames[0]} \\approx ${getAnswer(identifiers)} 
 $$
 
 `;
 };
-//too helpful for student ?
-const getGGBOptions = (identifiers) => {
-    const { triangle } = getHydrated(identifiers);
-    // const { indexAngle } = identifiers;
-    // const angle = arrayRotation(triangle.angles, indexAngle)[0];
-    const ggb = new GeogebraConstructor({
-        commands: [
-            //triangle
-            ...triangle.commands,
-            // //angle
-            // `Ang = Angle(${angle.points
-            //   .reverse()
-            //   .map((point) => point.name)
-            //   .join(",")})`,
-            // `ShowLabel(Ang, false)`,
-        ],
-        hideAxes: true,
-    });
-    return ggb.getOptions({
-        coords: ggb.getCoordsForPoints(triangle.points),
-    });
-};
 const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -143,19 +143,19 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     {
         const valueCos = answerStuff.nodeCosAngle.evaluate();
         if (valueCos > 0) {
-            tryToAddWrongProp(propositions, round(valueCos, precision).frenchify());
+            tryToAddWrongProp(propositions, texWithDegreesUnit(round(valueCos, precision).frenchify()));
         }
     }
     //student: radians instead of degrees
     {
-        tryToAddWrongProp(propositions, round(answerStuff.nodeAngleInRadians.evaluate(), precision).frenchify());
+        tryToAddWrongProp(propositions, texWithDegreesUnit(round(answerStuff.nodeAngleInRadians.evaluate(), precision).frenchify()));
     }
     //student: sign error when getting cos
     {
         const nodeCosAngle = frac(substract(add(power(sides[1].getLengthNode(), 2), power(sides[2].getLengthNode(), 2)), power(sides[0].getLengthNode(), 2)), multiply(-2, multiply(sides[1].getLengthNode(), sides[2].getLengthNode())));
         const nodeAngleInRadians = arccos(nodeCosAngle);
         const nodeAngleInDegrees = multiply(nodeAngleInRadians, frac(180, PiNode));
-        tryToAddWrongProp(propositions, round(nodeAngleInDegrees.evaluate(), precision).frenchify());
+        tryToAddWrongProp(propositions, texWithDegreesUnit(round(nodeAngleInDegrees.evaluate(), precision).frenchify()));
     }
     //student: wrong angle
     {
@@ -180,26 +180,32 @@ const getPropositions = (n, { answer, ...identifiers }) => {
                 const identifiersWrong = Object.assign({}, identifiers, {
                     indexAngle: indexAngleWrong,
                 });
-                return getAnswerNode(identifiersWrong).evaluate();
+                return getAnswerStuff(identifiersWrong).nodeAngleInDegrees.evaluate();
             }
         })();
         [...Array(4).keys()].forEach(() => {
             const valueAnswerOffsetted = value + randfloat(-7, 7, 2, [0]);
-            tryToAddWrongProp(propositions, round(valueAnswerOffsetted, precision).frenchify());
+            tryToAddWrongProp(propositions, texWithDegreesUnit(round(valueAnswerOffsetted, precision).frenchify()));
         });
     }
     propWhile(propositions, n, () => {
-        tryToAddWrongProp(propositions, randfloat(0, 180, 2, [0, 180]).frenchify());
+        tryToAddWrongProp(propositions, texWithDegreesUnit(randfloat(0, 180, 2, [0, 180]).frenchify()));
     });
     return shuffleProps(propositions, n);
 };
 const getKeys = () => {
-    return [];
+    return ["degree"];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const strForKeyIdDegreeReceivedFromTests = "^\\circ";
+    const strForKeyIdDegreeReceivedFromFront = "^{\\circ}"; //different from strForKeyIdDegreeSent: "^\\circ"
+    const ansRefined = ans
+        .replace(strForKeyIdDegreeReceivedFromTests, "")
+        .replace(strForKeyIdDegreeReceivedFromFront, "");
     try {
-        const parsed = parseAlgebraic(ans);
-        return parsed.simplify().toTex() === answer;
+        const nodeAns = parseAlgebraic(ansRefined);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return substract(nodeAns, nodeAnswer).evaluate() === 0;
     }
     catch (err) {
         return handleVEAError(err);
@@ -223,13 +229,12 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
-        ggbOptions: getGGBOptions(identifiers),
     };
 };
 export const scalarProductAlKashiAngle = {
     id: "scalarProductAlKashiAngle",
     connector: "=",
-    label: "Connaissant les longueurs des trois côtés d'un triangle, calculer un angle",
+    label: "Connaissant les longueurs des trois côtés d'un triangle, calculer un angle grâce au théorème d’Al-Kashi",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getScalarProductAlKashiAngleQuestion(opts), nb),
     qcmTimer: 60,
@@ -243,5 +248,4 @@ export const scalarProductAlKashiAngle = {
     hasHintAndCorrection: true,
     getAnswer,
     getQuestionFromIdentifiers,
-    hasGeogebra: true,
 };

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.d.ts

@@ -2,6 +2,7 @@ import { Exercise } from "../../../../../../exercises/exercise.js";
 import { PointIdentifiers } from "../../../../../../math/geometry/point.js";
 import { TriangleIdentifiers } from "../../../../../../math/geometry/triangles/triangle.js";
 type Identifiers = {
+    sectorOfPointH: string;
     triangleIds: TriangleIdentifiers;
     pointIdsH: PointIdentifiers;
 };

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductAlKashiBH.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAsBnD,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,SAAS,EAAE,gBAAgB,CAAC;CAC7B,CAAC;AAggBF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAsBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA2BjE,CAAC"}
+{"version":3,"file":"scalarProductAlKashiBH.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAwBnD,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,mBAAmB,CAAC;IACjC,SAAS,EAAE,gBAAgB,CAAC;CAC7B,CAAC;AAopBF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAuBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA2BjE,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiBH.js

@@ -9,6 +9,7 @@ import { Segment } from "../../../../../../math/geometry/segment.js";
 import { Triangle, TriangleConstructor, } from "../../../../../../math/geometry/triangles/triangle.js";
 import { VectorConstructor } from "../../../../../../math/geometry/vector.js";
 import { randfloat } from "../../../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../../../math/utils/random/randint.js";
 import { round } from "../../../../../../math/utils/round.js";
 import { abs } from "../../../../../../tree/nodes/functions/absNode.js";
 import { arccos } from "../../../../../../tree/nodes/functions/arccosNode.js";
@@ -20,8 +21,9 @@ import { multiply } from "../../../../../../tree/nodes/operators/multiplyNode.js
 import { power } from "../../../../../../tree/nodes/operators/powerNode.js";
 import { substract } from "../../../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../../../tree/parsers/latexParser.js";
-import { probaFlip } from "../../../../../../utils/alea/probaFlip.js";
+import { probaLawFlip } from "../../../../../../utils/alea/probaLawFlip.js";
 import { random } from "../../../../../../utils/alea/random.js";
+import { shuffle } from "../../../../../../utils/alea/shuffle.js";
 import { zip } from "../../../../../../utils/arrays/arrayZip.js";
 import { arrayRotation } from "../../../../../../utils/arrays/rotation.js";
 import { handleVEAError } from "../../../../../../utils/errors/handleVEAError.js";
@@ -43,21 +45,48 @@ const getHydrated = (identifiers) => {
     };
 };
 const getInstruction = (identifiers) => {
+    const { sectorOfPointH } = identifiers;
     const { triangle, sides, sideLengths } = getHydrated(identifiers);
     return `Soit $${triangle.name}$ un triangle dont on connaît les longueurs des côtés :
   
 ${zip(sides, sideLengths).map(([segment, valueLength]) => `- $${segment.toInsideName()} = ${valueLength.frenchify()}$`).join(`
   
-`)} 
+`)}
 
-Combien le segment $BH$ mesure-t-il ? 
-Donner une valeur approchée en degrés avec $${precision}$ décimales.`;
+$H$ est le pied de la hauteur issue de $A$. 
+
+${(() => {
+        switch (sectorOfPointH) {
+            case "Entre $B$ et $C$":
+                return `On précise que $H$ appartient au segment $[BC]$.`;
+            case "Après $C$":
+                return `On précise que $H$ n'appartient pas au segment $[BC]$. $H$ est plus proche de $C$ que de $B$.`;
+            case "Avant $B$":
+                return `On précise que $H$ n'appartient pas au segment $[BC]$. $H$ est plus proche de $B$ que de $C$.`;
+            default:
+                throw new Error("Unsupported opts.sectorOfPointH: " + sectorOfPointH);
+        }
+    })()} 
+
+Calculer la longueur $BH$ (donner une valeur arrondie à $${precision}$ décimales).`;
 };
 const getAnswerStuff = (identifiers) => {
+    const { sectorOfPointH } = identifiers;
     const { sideLengths } = getHydrated(identifiers);
     const nodeCosAngle = frac(substract(add(power(sideLengths[1], 2), power(sideLengths[2], 2)), power(sideLengths[0], 2)), multiply(2, multiply(sideLengths[1], sideLengths[2])));
     const nodeLengthBA = sideLengths[1];
-    const nodeLengthBH = multiply(nodeLengthBA, abs(nodeCosAngle));
+    const sign = (() => {
+        switch (sectorOfPointH) {
+            case "Entre $B$ et $C$":
+            case "Après $C$":
+                return +1;
+            case "Avant $B$":
+                return -1;
+            default:
+                throw new Error("Unsupported opts.sectorOfPointH: " + sectorOfPointH);
+        }
+    })();
+    const nodeLengthBH = multiply(sign, multiply(nodeLengthBA, nodeCosAngle));
     return {
         nodeCosAngle,
         nodeLengthBH,
@@ -69,12 +98,41 @@ const getAnswerNode = (identifiers) => {
 const getAnswer = (identifiers) => {
     return round(getAnswerNode(identifiers).evaluate(), precision).frenchify();
 };
-const getHint = () => {
-    return `Applique le théorème d'Al Kashi dans le triangle $ABC$ pour l'angle $\\widehat{B}$.
+const getHint = (identifiers) => {
+    const { sides, angleNames } = getHydrated(identifiers);
+    const sideNames = sides
+        .map((segment) => segment.toInsideName())
+        .map((name) => {
+        return {
+            AB: "c",
+            AC: "b",
+            BC: "a",
+        }[name];
+    });
+    return `Premièrement, puisque $H$ est le projeté orthogonal de $A$ sur $(BC)$, tu peux écrire : 
+
+$$
+\\overrightarrow{BA} \\cdot \\overrightarrow{BC} = \\overrightarrow{BH} \\cdot \\overrightarrow{BC}
+$$
   
-Ensuite, calcule $\\overrightarrow{BA} \\cdot \\overrightarrow{BC}$ de deux manières différentes.`;
+Deuxièmement, applique le théorème d'Al-Kashi dans le triangle $ABC$.
+
+Rappel: 
+
+Si on utilise les notations suivantes : 
+
+$$
+a \\ = \\ BC \\ ; \\ b \\ = \\ AC \\ ; \\ c \\ = \\ AB \\ 
+$$
+
+le théorème d'Al-Kashi s'écrit :
+
+$$
+${sideNames[0]}^2 = ${sideNames[1]}^2 + ${sideNames[2]}^2 - 2 ${sideNames[1]}  ${sideNames[2]}  \\cos(${angleNames[0]})
+$$`;
 };
 const getCorrection = (identifiers) => {
+    const { sectorOfPointH } = identifiers;
     const { sides, angleNames } = getHydrated(identifiers);
     const sideNames = sides
         .map((segment) => segment.toInsideName())
@@ -87,40 +145,94 @@ const getCorrection = (identifiers) => {
     });
     const nodeCosAngle = frac(substract(add(power(sideNames[1], 2), power(sideNames[2], 2)), power(sideNames[0], 2)), multiply(2, multiply(sideNames[1], sideNames[2])));
     const { nodeLengthBH } = getAnswerStuff(identifiers);
-    return `On applique le théorème d'Al Kashi dans le triangle $ABC$.
+    return `D'une part, par définition du produit scalaire : 
 
-On utilise les notations suivantes : 
+$$
+\\overrightarrow{BA} \\cdot \\overrightarrow{BC} = BA \\times BC \\times \\cos(${angleNames[0]})
+$$
+  
+D'autre part, puisque $H$ est le projeté orthogonal de $A$ sur $(BC)$, on a :
 
 $$
-a \\ = \\ BC \\ ; \\ b \\ = \\ AC \\ ; \\ c \\ = \\ AB \\ 
+\\overrightarrow{BA} \\cdot \\overrightarrow{BC} = \\overrightarrow{BH} \\cdot \\overrightarrow{BC}
 $$
 
+${(() => {
+        switch (sectorOfPointH) {
+            case "Entre $B$ et $C$":
+                return `Les points $B$,$H$ et $C$ sont alignés dans cet ordre. Par conséquent : 
+      
 $$
-${sideNames[0]}^2 = ${sideNames[1]}^2 + ${sideNames[2]}^2 - 2 ${sideNames[1]}  ${sideNames[2]}  \\cos(${angleNames[0]})
+\\overrightarrow{BH} \\cdot \\overrightarrow{BC} = BH \\times BC
 $$
 
+`;
+            case "Après $C$":
+                return `Les points $B$,$C$ et $H$ sont alignés dans cet ordre. Par conséquent : 
+      
 $$
-\\cos(${angleNames[0]}) = ${nodeCosAngle.toTex()} 
+\\overrightarrow{BH} \\cdot \\overrightarrow{BC} = BH \\times BC
+$$
+
+`;
+            case "Avant $B$":
+                return `Les points $H$,$B$ et $C$ sont alignés dans cet ordre. Par conséquent : 
+      
+$$
+\\overrightarrow{BH} \\cdot \\overrightarrow{BC} = - BH \\times BC
 $$
 
-D'une part, par définition du produit scalaire : 
+`;
+            default:
+                throw new Error("Unsupported opts.sectorOfPointH: " + sectorOfPointH);
+        }
+    })()}
+
+
+On va calculer $\\cos(${angleNames[0]})$ en utilisant le théorème d'Al-Kashi dans le triangle $ABC$.
+
+En utilisant les notations suivantes : 
 
 $$
-\\overrightarrow{BA} \\cdot \\overrightarrow{BC} = BA \\times BC \\times \\cos(${angleNames[0]})
+a \\ = \\ BC \\ ; \\ b \\ = \\ AC \\ ; \\ c \\ = \\ AB \\ 
 $$
 
-D'autre part, puisque $B$,$C$ et $H$ sont alignés : 
+La formule d'Al-Kashi s'écrit :
+
+$$
+${sideNames[0]}^2 = ${sideNames[1]}^2 + ${sideNames[2]}^2 - 2 ${sideNames[1]}  ${sideNames[2]}  \\cos(${angleNames[0]})
+$$
 
 $$
-\\lvert \\overrightarrow{BH} \\cdot \\overrightarrow{BC} \\rvert = BH \\times BC
+\\cos(${angleNames[0]}) = ${nodeCosAngle.toTex()} 
 $$
 
 On a donc :
 
+${(() => {
+        switch (sectorOfPointH) {
+            case "Entre $B$ et $C$":
+            case "Après $C$":
+                return `
+      
 $$
-BH =  BA \\times \\lvert  \\cos(${angleNames[0]}) \\rvert 
+BH = BA \\times \\cos(${angleNames[0]}) 
 $$
 
+`;
+            case "Avant $B$":
+                return `
+      
+$$
+BH = - BA \\times \\cos(${angleNames[0]}) 
+$$
+
+`;
+            default:
+                throw new Error("Unsupported opts.sectorOfPointH: " + sectorOfPointH);
+        }
+    })()}
+
 $$
 BH = ${nodeLengthBH.toTex()}
 $$
@@ -192,10 +304,28 @@ const getGGBOptions = (identifiers) => {
     });
 };
 const getPropositions = (n, { answer, ...identifiers }) => {
-    const propositions = [];
-    addValidProp(propositions, answer);
+    const propositionsMandatory = [];
+    addValidProp(propositionsMandatory, answer);
     const { sideLengths } = getHydrated(identifiers);
     const [BC, BA, _] = sideLengths;
+    //around answer
+    {
+        const vAnswer = getAnswerStuff(identifiers).nodeLengthBH.evaluate();
+        const createOffset = probaLawFlip([
+            [() => randfloat(0, 0.5, 2, [0]), 0.4],
+            [() => randfloat(-0.5, 0, 2, [0]), 0.4],
+            [() => randfloat(-0.5, 0.5, 2, [0]), 0.2],
+        ]);
+        const nbAroundAnswer = randint(1, 3);
+        const arrOffset = [...Array(nbAroundAnswer).keys()].map(createOffset);
+        arrOffset.forEach((vOffset) => {
+            const valueAnswerOffsetted = vAnswer + vOffset;
+            if (valueAnswerOffsetted > 0) {
+                tryToAddWrongProp(propositionsMandatory, round(valueAnswerOffsetted, precision).frenchify());
+            }
+        });
+    }
+    const propositionsFiller = [];
     const arrValueWrong = [];
     //student: sign error
     {
@@ -204,7 +334,7 @@ const getPropositions = (n, { answer, ...identifiers }) => {
         const nodeLengthBH = multiply(nodeLengthBA, abs(nodeCosAngle));
         const vWrong = nodeLengthBH.evaluate();
         arrValueWrong.push(vWrong);
-        tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+        tryToAddWrongProp(propositionsFiller, round(vWrong, precision).frenchify());
     }
     //student: computes AH instead of BH
     {
@@ -213,7 +343,7 @@ const getPropositions = (n, { answer, ...identifiers }) => {
         const nodeLengthAH = multiply(nodeLengthBA, abs(sin(arccos(nodeCosAngle))));
         const vWrong = nodeLengthAH.evaluate();
         arrValueWrong.push(vWrong);
-        tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+        tryToAddWrongProp(propositionsFiller, round(vWrong, precision).frenchify());
     }
     //student: pythagore with BA and BC
     {
@@ -221,31 +351,28 @@ const getPropositions = (n, { answer, ...identifiers }) => {
             const nodeWrong = sqrt(substract(power(BA, 2), power(BC, 2)));
             const vWrong = nodeWrong.evaluate();
             arrValueWrong.push(vWrong);
-            tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+            tryToAddWrongProp(propositionsFiller, round(vWrong, precision).frenchify());
         }
     }
-    //terror: around answer, _most of the time_
+    //terror: around wrong
     {
-        const value = (() => {
-            const vAnswer = getAnswerStuff(identifiers).nodeLengthBH.evaluate();
-            if (probaFlip(0.6)) {
-                return vAnswer;
-            }
-            else {
-                return random([...arrValueWrong, vAnswer]);
-            }
-        })();
+        const value = random([...arrValueWrong]);
         [...Array(2).keys()].forEach(() => {
             const valueAnswerOffsetted = value + randfloat(-1.2, 1.2, 2, [0]);
             if (valueAnswerOffsetted > 0) {
-                tryToAddWrongProp(propositions, round(valueAnswerOffsetted, precision).frenchify());
+                tryToAddWrongProp(propositionsFiller, round(valueAnswerOffsetted, precision).frenchify());
             }
         });
     }
-    propWhile(propositions, n, () => {
-        tryToAddWrongProp(propositions, randfloat(2, 20, 2, [0, 20]).frenchify());
+    propWhile(propositionsFiller, n, () => {
+        tryToAddWrongProp(propositionsFiller, randfloat(2, 20, 2, [0, 20]).frenchify());
     });
-    return shuffleProps(propositions, n);
+    return shuffle([
+        ...propositionsMandatory,
+        ...shuffleProps(propositionsFiller.filter((propositionFiller) => !propositionsMandatory
+            .map((proposition) => proposition.statement)
+            .includes(propositionFiller.statement)), n - propositionsMandatory.length),
+    ]);
 };
 const getKeys = () => {
     return [];
@@ -260,11 +387,8 @@ const isAnswerValid = (ans, { answer }) => {
     }
 };
 const getScalarProductAlKashiBHQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? optsDefault;
-    const opts = {
-        sectorOfPointH: random(arrayedOptions.sectorOfPointH),
-    };
-    const { sectorOfPointH } = opts;
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const sectorOfPointH = random(arrayedOptions.sectorOfPointH);
     function createRandomPoints() {
         const offsetBtoC = 10;
         const pointB = new Point("B", randfloat(0, 10), randfloat(0, 10));
@@ -284,7 +408,7 @@ const getScalarProductAlKashiBHQuestion = (optsIn) => {
                 case "Avant $B$":
                     return multiply((-1).toTree(), nodeOffsetDtoE);
                 default:
-                    throw new Error("Unsupported opts.sectorOfPointH: " + opts.sectorOfPointH);
+                    throw new Error("Unsupported sectorOfPointH: " + sectorOfPointH);
             }
         })();
         const pointD = vecBCUnited.times(nodeOffsetBtoD).getEndPoint(pointB);
@@ -356,6 +480,7 @@ const getScalarProductAlKashiBHQuestion = (optsIn) => {
                 const [B, A, C, H] = pointsCandidate;
                 const triangle = new Triangle([A, B, C]);
                 identifiers = {
+                    sectorOfPointH,
                     triangleIds: triangle.toIdentifiers(),
                     pointIdsH: H.toIdentifiers(),
                 };
@@ -377,7 +502,7 @@ const getScalarProductAlKashiBHQuestion = (optsIn) => {
                 case "Avant $B$":
                     return new Point("A", 5, 7);
                 default:
-                    throw new Error("Unsupported opts.sectorOfPointH: " + opts.sectorOfPointH);
+                    throw new Error("Unsupported opts.sectorOfPointH: " + sectorOfPointH);
             }
         })();
         const vecBC = VectorConstructor.fromPoints(pointB, pointC);
@@ -390,6 +515,7 @@ const getScalarProductAlKashiBHQuestion = (optsIn) => {
         const [B, A, C, H] = [pointB, pointA, pointC, pointH];
         const triangle = new Triangle([A, B, C]);
         const identifiersDefault = {
+            sectorOfPointH,
             triangleIds: triangle.toIdentifiers(),
             pointIdsH: H.toIdentifiers(),
         };
@@ -411,7 +537,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         options: opts,
     };
 };
-const optsDefault = {
+const arrayedOptsDefault = {
     sectorOfPointH: ["Entre $B$ et $C$"],
 };
 const options = [
@@ -421,13 +547,13 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["Entre $B$ et $C$", "Après $C$", "Avant $B$"],
-        defaultValue: optsDefault.sectorOfPointH,
+        defaultValue: arrayedOptsDefault.sectorOfPointH,
     },
 ];
 export const scalarProductAlKashiBH = {
     id: "scalarProductAlKashiBH",
     connector: "=",
-    label: "Connaissant les longueurs de trois côtés d'un triangle $ABC$, calculer $BH$ ($H$ étant le pied de la hauteur issue de $A$)",
+    label: "Connaissant les longueurs de trois côtés d'un triangle $ABC$, calculer $BH$ ($H$ étant le pied de la hauteur issue de $A$) grâce au théorème d'Al-Kashi",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getScalarProductAlKashiBHQuestion(opts), nb),
     options,

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiSideLength.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductAlKashiSideLength.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiSideLength.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAoBnD,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4SF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAsBhE,CAAC"}
+{"version":3,"file":"scalarProductAlKashiSideLength.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiSideLength.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAqEnD,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAuXF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAsBhE,CAAC"}