math-exercises 3.0.171 → 3.0.172

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"}

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

@@ -1,7 +1,9 @@
 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 { Angle } from "../../../../../../math/geometry/angle.js";
+import { Point } from "../../../../../../math/geometry/point.js";
+import { Triangle, TriangleConstructor, } from "../../../../../../math/geometry/triangles/triangle.js";
+import { Vector } 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";
@@ -16,9 +18,25 @@ import { substract } from "../../../../../../tree/nodes/operators/substractNode.
 import { parseAlgebraic } from "../../../../../../tree/parsers/latexParser.js";
 import { probaFlip } from "../../../../../../utils/alea/probaFlip.js";
 import { random } from "../../../../../../utils/alea/random.js";
+import { shuffle } from "../../../../../../utils/alea/shuffle.js";
 import { arrayRotation } from "../../../../../../utils/arrays/rotation.js";
 import { handleVEAError } from "../../../../../../utils/errors/handleVEAError.js";
 const precision = 2;
+const createVector = (from, to, name, precision = 5) => {
+    return new Vector(name, round(substract(to.x, from.x).evaluate(), precision).toTree(), round(substract(to.y, from.y).evaluate(), precision).toTree());
+};
+const createPoint = (x, y, name, precision = 5) => {
+    return new Point(name, round(x, precision), round(y, precision));
+};
+const degreesToRadians = (angleInDegrees, precision) => {
+    const oneOver180 = 0.00555555555555555;
+    return round(multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(), precision);
+};
+const rotatePoint = (target, angle, center, name, precision = 2) => {
+    const vSrc = createVector(center, target, "vSrc", precision);
+    const vRotated = vSrc.rotate(angle, "vRotated");
+    return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
+};
 const getHydrated = (identifiers) => {
     const { indexSide } = identifiers;
     const indexAngle = indexSide;
@@ -42,12 +60,11 @@ ${triangle.sides
   
 `)}
 
-- $${triangle.angles[indexAngle].toTexMini()} \\approx ${triangle.angles[indexAngle]
+- $${triangle.angles[indexAngle].toTexMini()} = ${triangle.angles[indexAngle]
         .evaluate()
         .frenchify()} {}^{\\circ} $
   
-Combien le segment $${triangle.sides[indexSide].toTex()}$ mesure-t-il ? 
-Donner une valeur approchée en degrés avec $${precision}$ décimales.`;
+Calculer la longueur $${triangle.sides[indexSide].toTex()}$ (donner une valeur arrondie à $${precision}$ décimales).`;
 };
 const getAnswerStuff = (identifiers) => {
     const { indexSide } = identifiers;
@@ -55,24 +72,57 @@ const getAnswerStuff = (identifiers) => {
     const { triangle, sides } = getHydrated(identifiers);
     const nodeAngleInDegrees = triangle.angles[indexAngle].evaluate().toTree();
     const nodeAngleInRadians = multiply(nodeAngleInDegrees, frac(PiNode, 180));
+    //"nodeStr"
+    const nodeStrLengthSquared = substract(add(power(sides[1].getLengthNode(), 2), power(sides[2].getLengthNode(), 2)), multiply(2, multiply(multiply(sides[1].getLengthNode(), sides[2].getLengthNode()), cos(multiply(nodeAngleInDegrees, "{}^{\\circ}".toTree())))));
+    const nodeStrLength = sqrt(nodeStrLengthSquared.simplify());
+    //"true" nodes
     const nodeLengthSquared = substract(add(power(sides[1].getLengthNode(), 2), power(sides[2].getLengthNode(), 2)), multiply(2, multiply(multiply(sides[1].getLengthNode(), sides[2].getLengthNode()), cos(nodeAngleInRadians))));
     const nodeLength = sqrt(nodeLengthSquared);
+    const lengthRounded = round(nodeLength.evaluate(), precision);
     return {
-        nodeLengthSquared,
+        nodeStrLengthSquared,
+        nodeStrLength,
         nodeLength,
+        lengthRounded,
     };
 };
 const getAnswerNode = (identifiers) => {
-    return getAnswerStuff(identifiers).nodeLength;
+    return getAnswerStuff(identifiers).lengthRounded.toTree();
 };
 const getAnswer = (identifiers) => {
     return round(getAnswerNode(identifiers).evaluate(), precision).frenchify();
 };
 const getHint = (identifiers) => {
-    const { triangle } = getHydrated(identifiers);
+    const { sides, triangle } = getHydrated(identifiers);
     const { indexSide } = identifiers;
     const indexAngle = indexSide;
-    return `Applique le théorème d'Al Kashi dans le triangle $ABC$ pour l'angle $${triangle.angles[indexAngle].toTexMini()}$.`;
+    const sideNames = arrayRotation(sides, indexAngle)
+        .map((segment) => segment.toInsideName())
+        .map((name) => {
+        return {
+            AB: "c",
+            AC: "b",
+            BC: "a",
+            BA: "c",
+            CA: "b",
+            CB: "a",
+        }[name];
+    });
+    return `Applique le théorème d'Al Kashi dans le triangle $ABC$ pour l'angle $${triangle.angles[indexAngle].toTexMini()}$.
+
+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(${triangle.angles[indexAngle].toTexMini()})
+$$`;
 };
 const getCorrection = (identifiers) => {
     const { indexSide } = identifiers;
@@ -85,10 +135,13 @@ const getCorrection = (identifiers) => {
             AB: "c",
             AC: "b",
             BC: "a",
+            BA: "c",
+            CA: "b",
+            CB: "a",
         }[name];
     });
     const angleNames = arrayRotation(triangle.angles, indexAngle).map((angle) => angle.toTexMini());
-    const { nodeLengthSquared, nodeLength } = getAnswerStuff(identifiers);
+    const { nodeStrLengthSquared, nodeStrLength } = getAnswerStuff(identifiers);
     return `On applique le théorème d'Al Kashi dans le triangle $ABC$.
 
 On utilise les notations suivantes : 
@@ -97,25 +150,21 @@ $$
 a \\ = \\ BC \\ ; \\ b \\ = \\ AC \\ ; \\ c \\ = \\ AB \\ 
 $$
 
-$$
-${sideNames[0]}^2 = ${sideNames[1]}^2 + ${sideNames[2]}^2 - 2 ${sideNames[1]}  ${sideNames[2]}  \\cos(${angleNames[0]})
-$$
-
-Avant de prendre le cosinus, il faut convertir l'angle en radians :
+Avec ces notations, d'après le théorème d'Al-Kashi  :
 
 $$
-${angleNames[0]}_{rad} = ${angleNames[0]}_{deg} \\times \\frac{${PiNode.toTex()}}{180}
+${sideNames[0]}^2 = ${sideNames[1]}^2 + ${sideNames[2]}^2 - 2 ${sideNames[1]}  ${sideNames[2]}  \\cos(${angleNames[0]})
 $$
 
 $$
-${sideNames[0]}^2 = ${nodeLengthSquared.toTex()}
+${sideNames[0]}^2 = ${nodeStrLengthSquared.toTex()}
 $$
 
 $$
-${sideNames[0]} = ${nodeLength.toTex()}
+${sideNames[0]} = ${nodeStrLength.toTex()}
 $$
 
-On arrondit à la toute fin :
+À l’aide de la calculatrice réglée en degrés, on calcule et, comme d'habitude, on arrondit à la toute fin :
 
 $$
 ${sideNames[0]}  \\approx ${getAnswer(identifiers)}
@@ -123,28 +172,6 @@ $$
 
 `;
 };
-//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);
@@ -212,8 +239,49 @@ const isAnswerValid = (ans, { answer }) => {
     }
 };
 const getScalarProductAlKashiSideLengthQuestion = () => {
-    const triangle = TriangleConstructor.randomNiceSides({});
-    const indexSide = randint(0, 3);
+    function createNiceTriangle(pointNames, minAngle = 20, isIntSidesAroundAngleA = false, precision = 1) {
+        let A;
+        let B;
+        let C;
+        const anglesAreNice = () => {
+            const values = [
+                new Angle([C, B, A]).evaluate(),
+                new Angle([A, C, B]).evaluate(),
+                new Angle([B, A, C]).evaluate(),
+            ];
+            if (minAngle)
+                return values.every((v) => v > minAngle && v < 180 - minAngle);
+            return values.every((v) => v > 20 && v < 110);
+        };
+        let counter = 0;
+        do {
+            counter++;
+            if (counter > 1000)
+                throw new Error("createNiceTriangle: too many iterations");
+            //angle A
+            const angleAInDegrees = randint(minAngle, 180 - 2 * minAngle);
+            const angleAInRadians = degreesToRadians(angleAInDegrees, 8);
+            //AB and AC
+            const [AB, AC] = [0, 1].map(() => isIntSidesAroundAngleA ? randint(5, 15) : randfloat(5, 15, precision));
+            //A,B,C
+            A = new Point(pointNames[0], randfloat(-5, 6, 1), randfloat(-5, 6, 1));
+            B = (() => {
+                const pointBRaw = new Point(pointNames[1], add(A.x, AB), A.y);
+                return rotatePoint(pointBRaw, angleAInRadians, A, pointBRaw.name, 5);
+            })();
+            C = new Point(pointNames[2], add(A.x, AC), A.y);
+        } while (!anglesAreNice());
+        return new Triangle([A, B, C], {
+            sidesLengths: [
+                round(B.distanceTo(C), 5).toTree(),
+                round(A.distanceTo(C), isIntSidesAroundAngleA ? 0 : 1).toTree(),
+                round(A.distanceTo(B), isIntSidesAroundAngleA ? 0 : 1).toTree(),
+            ],
+        });
+    }
+    const pointNames = shuffle(["A", "B", "C"]);
+    const triangle = createNiceTriangle(pointNames);
+    const indexSide = 0;
     const identifiers = {
         triangleIds: triangle.toIdentifiers(),
         indexSide,
@@ -229,13 +297,12 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
-        ggbOptions: getGGBOptions(identifiers),
     };
 };
 export const scalarProductAlKashiSideLength = {
     id: "scalarProductAlKashiSideLength",
     connector: "=",
-    label: "Connaissant un angle entre deux longueurs, calculer le côté opposé",
+    label: "Connaissant un angle entre deux longueurs, calculer le côté opposé grâce au théorème d'Al-Kashi",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getScalarProductAlKashiSideLengthQuestion(opts), nb),
     qcmTimer: 60,
@@ -249,5 +316,4 @@ export const scalarProductAlKashiSideLength = {
     hasHintAndCorrection: true,
     getAnswer,
     getQuestionFromIdentifiers,
-    hasGeogebra: true,
 };

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductInOrthonormalBasisIJ.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductInOrthonormalBasisIJ.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductInOrthonormalBasisIJ.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AA+PF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAsBnE,CAAC"}
+{"version":3,"file":"scalarProductInOrthonormalBasisIJ.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductInOrthonormalBasisIJ.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAqQF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAsBnE,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductInOrthonormalBasisIJ.js

@@ -127,6 +127,12 @@ $$
 ${i} \\cdot ${j} = ${j} \\cdot ${i} = 0
 $$
 
+On a :
+
+$$
+${i} \\cdot ${i} = ${j} \\cdot ${j} = 1
+$$
+
 On peut donc calculer le produit scalaire en utilisant les coordonnées dans la base $(${i},${j})$ de la même manière que lorsque l'on travaille dans la base canonique du plan. 
 
 ${alignTex([