math-exercises 3.0.157 → 3.0.159

package/lib/exercises/math/geometry/circles/isPointOnCircleFromCartesianEquation.js

@@ -0,0 +1,131 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { equal } from "../../../../tree/nodes/equations/equalNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.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 { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.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 getEquation = (identifiers) => {
+    const { centreIds, radiusIds } = identifiers;
+    const radius = reifyAlgebraic(radiusIds);
+    const centre = PointConstructor.fromIdentifiers(centreIds);
+    return equal(add(square(substract("x", centre.x).simplify()), square(substract("y", centre.y).simplify())), square(radius).simplify());
+};
+const getAnswer = (identifiers) => {
+    const { centreIds, pointIds, radiusIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const radius = reifyAlgebraic(radiusIds);
+    const centre = PointConstructor.fromIdentifiers(centreIds);
+    return Math.abs(point.distanceTo(centre) - radius.evaluate()) < 0.001
+        ? "Oui"
+        : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { pointIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    return `On considère le cercle $\\mathcal{C}$ d'équation : 
+  
+$$
+${getEquation(identifiers).toTex()}
+$$
+
+Le point $${point.toTexWithCoords()}$ appartient-il au cercle $\\mathcal{C}$ ?`;
+};
+const getHint = () => {
+    return `Il suffit de remplacer $x$ et $y$ par les coordonnées de $A$ dans l'équation du cercle.`;
+};
+const getCorrection = (identifiers) => {
+    const { centreIds, pointIds } = identifiers;
+    const centre = PointConstructor.fromIdentifiers(centreIds);
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const leftEq = add(square(substract("x", centre.x).simplify()), square(substract("y", centre.y).simplify()));
+    const leftEqDetailed = leftEq.toDetailedEvaluation({
+        x: point.x,
+        y: point.y,
+    });
+    const isOnCircle = getAnswer(identifiers) === "Oui";
+    return `On remplace $x$ et $y$ par les coordonnées de $A$ dans l'équation du cercle : 
+  
+${alignTex([
+        ["", leftEqDetailed.toTex()],
+        [
+            "=",
+            add(square(substract(point.x, centre.x).simplify()), square(substract(point.y, centre.y).simplify())).toTex(),
+        ],
+        ["=", leftEqDetailed.simplify().toTex()],
+    ])}
+
+${isOnCircle
+        ? `Puisque l'égalité est bien vérifie, le point $A$ appartient bien au cercle.`
+        : `Puisque l'égalité n'est pas vérifiée, le point $A$ n'appartient pas au cercle.`}
+`;
+};
+const getIsPointOnCircleFromCartesianEquationQuestion = () => {
+    const centre = PointConstructor.random("O");
+    const radius = randint(1, 10).toTree();
+    const isOnCircle = coinFlip();
+    let point;
+    if (isOnCircle) {
+        // point = PointConstructor.random("A");
+        const angle = frac(PiNode, 2);
+        const index = randint(0, 4);
+        point = centre
+            .translate(radius, 0)
+            .centralRotate(multiply(index, angle).simplify(), centre);
+    }
+    else {
+        do {
+            point = PointConstructor.random("A");
+        } while (Math.abs(point.distanceTo(centre) - radius.evaluate()) < 0.001);
+    }
+    const identifiers = {
+        centreIds: centre.toIdentifiers(),
+        radiusIds: radius.toIdentifiers(),
+        pointIds: point.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const isPointOnCircleFromCartesianEquation = {
+    id: "isPointOnCircleFromCartesianEquation",
+    connector: "=",
+    label: "Déterminer si un point appartient à un cercle d'équation donnée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsPointOnCircleFromCartesianEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/geometry/euclidian/pinPointFromAxialOrCentralSymmetry.js

@@ -284,8 +284,8 @@ const getPinPointFromAxialOrCentralSymmetryQuestion = (optsIn) => {
                     const vecVRaw = VectorConstructor.fromPoints(point1, rotatePoint(point2, frac(PiNode, 2).evaluate(), point1, "N"));
                     const vecVUnit = vecVRaw.times(frac(1, vecVRaw.getNorm().evaluate()).evaluate().toTree());
                     const vecSrc = VectorConstructor.fromPoints(point1, pointSrc);
-                    const dotAx = vecSrc.scalarProduct(vecUUnit);
-                    const dotPerp = vecSrc.scalarProduct(vecVUnit);
+                    const dotAx = vecSrc.scalarProduct(vecUUnit).simplify();
+                    const dotPerp = vecSrc.scalarProduct(vecVUnit).simplify();
                     const vecDst = vecUUnit
                         .times(dotAx)
                         .add(vecVUnit.times(multiply(-1, dotPerp)));

package/lib/exercises/math/geometry/euclidian/pinSegmentFromRotation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pinSegmentFromRotation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pinSegmentFromRotation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAuK7C,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,gBAAgB,CAAC;IACzB,cAAc,EAAE,eAAe,CAAC;CACjC,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,yBAAyB,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAsYF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"pinSegmentFromRotation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pinSegmentFromRotation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAuK7C,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,gBAAgB,CAAC;IACzB,cAAc,EAAE,eAAe,CAAC;CACjC,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iBAAiB,EAAE,yBAAyB,CAAC;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAoYF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/geometry/euclidian/pinSegmentFromRotation.js

@@ -246,7 +246,6 @@ const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
             }
             return acc;
         }, {});
-        console.log("pointsDict", pointsDict);
         return pointsDict;
     }
     function getStudentSegmentsDictFromStudentCommands(commands) {
@@ -261,7 +260,6 @@ const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
             }
             return acc;
         }, {});
-        console.log("segmentsDict", segmentsDict);
         return segmentsDict;
     }
     const isSegmentValid = () => {

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

@@ -15,4 +15,5 @@ export * from "./angles/index.js";
 export * from "./lines/index.js";
 export * from "./triangles/index.js";
 export * from "./optimisation/index.js";
+export * from "./circles/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC"}

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

@@ -15,3 +15,4 @@ export * from "./angles/index.js";
 export * from "./lines/index.js";
 export * from "./triangles/index.js";
 export * from "./optimisation/index.js";
+export * from "./circles/index.js";

package/lib/exercises/math/geometry/thales/thales.js

@@ -23,7 +23,7 @@ const getSubTriangle = ({ triangle, insidePointsNames, ratio, }) => {
 const getInstruction = (identifiers) => {
     const { triangleIdentifiers, insidePointsNames } = identifiers;
     const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
-    return `En utilisant le théoreme de Thalès, écrire l'égalité des quotients sachant que  $\\left(${insidePointsNames.join("")}\\right)//\\left(${triangle.sides[2].toInsideName()}\\right)$.`;
+    return `En utilisant le théorème de Thalès, écrire l'égalité des quotients sachant que  $\\left(${insidePointsNames.join("")}\\right)//\\left(${triangle.sides[2].toInsideName()}\\right)$.`;
 };
 const getAnswer = (identifiers) => {
     const { triangleIdentifiers, insidePointsNames, isPapillon, ratio } = identifiers;

package/lib/exercises/math/geometry/thales/thalesCalcul.js

@@ -244,7 +244,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 export const thalesCalcul = {
     id: "thalesCalcul",
     connector: "=",
-    label: "Utiliser le théoreme de Thalès pour calculer un côté",
+    label: "Utiliser le théorème de Thalès pour calculer un côté",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getThalesFindSideQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/geometry/vectors/colinearity/determinant.js

@@ -75,7 +75,7 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     const { u, v } = getVectors(identifiers);
-    tryToAddWrongProp(propositions, u.scalarProduct(v).toTex());
+    tryToAddWrongProp(propositions, u.scalarProduct(v).simplify().toTex());
     propWhile(propositions, n, () => {
         const wrongAnswer = randint(-20, 20) + "";
         tryToAddWrongProp(propositions, wrongAnswer);

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

@@ -0,0 +1,4 @@
+export * from "./scalarProductAlKashiAngle.js";
+export * from "./scalarProductAlKashiSideLength.js";
+export * from "./scalarProductAlKashiBH.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC;AACpD,cAAc,6BAA6B,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./scalarProductAlKashiAngle.js";
+export * from "./scalarProductAlKashiSideLength.js";
+export * from "./scalarProductAlKashiBH.js";

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../../../../math/geometry/triangles/triangle.js";
+type Identifiers = {
+    triangleIds: TriangleIdentifiers;
+    indexAngle: number;
+};
+export declare const scalarProductAlKashiAngle: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductAlKashiAngle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductAlKashiAngle.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiAngle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAkBnD,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAmSF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAoB3D,CAAC"}

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

@@ -0,0 +1,247 @@
+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";
+import { round } from "../../../../../../math/utils/round.js";
+import { arccos } from "../../../../../../tree/nodes/functions/arccosNode.js";
+import { PiNode } from "../../../../../../tree/nodes/numbers/piNode.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 { 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 { arrayRotation } from "../../../../../../utils/arrays/rotation.js";
+import { handleVEAError } from "../../../../../../utils/errors/handleVEAError.js";
+const precision = 2;
+const getHydrated = (identifiers) => {
+    const { triangleIds, indexAngle } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIds);
+    const sides = arrayRotation(triangle.sides, indexAngle);
+    const angleNames = arrayRotation(triangle.angles, indexAngle).map((angle) => angle.toTexMini());
+    return {
+        triangle,
+        sides,
+        angleNames,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { indexAngle } = identifiers;
+    const { triangle } = getHydrated(identifiers);
+    return `Soit $${triangle.name}$ un triangle dont on connaît les longueurs des côtés :
+  
+${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.`;
+};
+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));
+    return {
+        nodeCosAngle,
+        nodeAngleInRadians,
+        nodeAngleInDegrees,
+    };
+};
+const getAnswerNode = (identifiers) => {
+    return getAnswerStuff(identifiers).nodeAngleInDegrees;
+};
+const getAnswer = (identifiers) => {
+    return round(getAnswerNode(identifiers).evaluate(), precision).frenchify();
+};
+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)
+        .map((segment) => segment.toInsideName())
+        .map((name) => {
+        return {
+            AB: "c",
+            AC: "b",
+            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$.
+
+On utilise les notations suivantes : 
+
+$$
+a \\ = \\ BC \\ ; \\ b \\ = \\ AC \\ ; \\ c \\ = \\ AB \\ 
+$$
+
+$$
+${sideNames[0]}^2 = ${sideNames[1]}^2 + ${sideNames[2]}^2 - 2 ${sideNames[1]}  ${sideNames[2]}  \\cos(${angleNames[0]})
+$$
+
+$$
+\\cos(${angleNames[0]}) = ${nodeCosAngle.toTex()} 
+$$
+
+En radians :
+
+$$
+${angleNames[0]} = ${nodeAngle.toTex()}
+$$
+
+Il ne faut pas oublier de passer en degrés :
+
+$$
+${angleNames[0]}_{deg} = ${angleNames[0]}_{rad} \\times \\frac{180}{${PiNode.toTex()}}
+$$
+
+On arrondit à la toute fin :
+
+$$
+${angleNames[0]} \\approx ${getAnswer(identifiers)} {}^{\\circ}
+$$
+
+`;
+};
+//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);
+    const { indexAngle } = identifiers;
+    const { sides } = getHydrated(identifiers);
+    const answerStuff = getAnswerStuff(identifiers);
+    //student: cos value
+    {
+        const valueCos = answerStuff.nodeCosAngle.evaluate();
+        if (valueCos > 0) {
+            tryToAddWrongProp(propositions, round(valueCos, precision).frenchify());
+        }
+    }
+    //student: radians instead of degrees
+    {
+        tryToAddWrongProp(propositions, 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());
+    }
+    //student: wrong angle
+    {
+        [0, 1, 2]
+            .filter((i) => i !== indexAngle)
+            .forEach((indexAngleWrong) => {
+            const identifiersWrong = Object.assign({}, identifiers, {
+                indexAngle: indexAngleWrong,
+            });
+            const texAnswerWrong = getAnswer(identifiersWrong);
+            tryToAddWrongProp(propositions, texAnswerWrong);
+        });
+    }
+    //terror: around answer, _most of the time_
+    {
+        const value = (() => {
+            if (probaFlip(0.71)) {
+                return answerStuff.nodeAngleInDegrees.evaluate();
+            }
+            else {
+                const indexAngleWrong = randint(0, 3, [indexAngle]);
+                const identifiersWrong = Object.assign({}, identifiers, {
+                    indexAngle: indexAngleWrong,
+                });
+                return getAnswerNode(identifiersWrong).evaluate();
+            }
+        })();
+        [...Array(4).keys()].forEach(() => {
+            const valueAnswerOffsetted = value + randfloat(-7, 7, 2, [0]);
+            tryToAddWrongProp(propositions, round(valueAnswerOffsetted, precision).frenchify());
+        });
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(0, 180, 2, [0, 180]).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScalarProductAlKashiAngleQuestion = () => {
+    const triangle = TriangleConstructor.randomNiceSides({});
+    const indexAngle = randint(0, 3);
+    const identifiers = {
+        triangleIds: triangle.toIdentifiers(),
+        indexAngle,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        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",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductAlKashiAngleQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../../math/geometry/point.js";
+import { TriangleIdentifiers } from "../../../../../../math/geometry/triangles/triangle.js";
+type Identifiers = {
+    triangleIds: TriangleIdentifiers;
+    pointIdsH: PointIdentifiers;
+};
+type Options = {
+    sectorOfPointH: string;
+};
+export declare const scalarProductAlKashiBH: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=scalarProductAlKashiBH.d.ts.map

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

@@ -0,0 +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"}