math-exercises 3.0.158 → 3.0.160

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

@@ -0,0 +1,181 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Line } from "../../../../math/geometry/line.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
+import { equal } from "../../../../tree/nodes/equations/equalNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const fakeA = PointConstructor.random("A");
+        const fakeB = PointConstructor.random("B");
+        const fakeC = PointConstructor.random("C");
+        tryToAddWrongProp(propositions, getAnswer({
+            AIds: fakeA.toIdentifiers(),
+            BIds: fakeB.toIdentifiers(),
+            CIds: fakeC.toIdentifiers(),
+        }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { AIds, BIds, CIds } = identifiers;
+    const A = PointConstructor.fromIdentifiers(AIds);
+    const B = PointConstructor.fromIdentifiers(BIds);
+    const C = PointConstructor.fromIdentifiers(CIds);
+    const vector = VectorConstructor.fromPoints(B, C);
+    const c = opposite(add(multiply(vector.x, A.x), multiply(vector.y, A.y))).simplify();
+    return equal(add(add(multiply(vector.x, "x"), multiply(vector.y, "y")), c).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    }), 0).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { AIds, BIds, CIds } = identifiers;
+    const A = PointConstructor.fromIdentifiers(AIds);
+    const B = PointConstructor.fromIdentifiers(BIds);
+    const C = PointConstructor.fromIdentifiers(CIds);
+    return `Dans un repère orthonormé, on considère un triangle $ABC$ avec $${A.toTexWithCoords()}$, $${B.toTexWithCoords()}$ et $${C.toTexWithCoords()}$.
+  
+Donner une équation cartésienne de la hauteur issue de $A$.`;
+};
+const getHint = () => {
+    return `Dans un triangle $ABC$, la hauteur issue de $A$ est perpendiculaire à la droite $(BC)$.
+  
+Alors, tout vecteur directeur de $(BC)$ est un vecteur normal à cette hauteur.
+
+Utilise alors ce vecteur normal et les coordonnées du point $A$ pour trouver une équation cartésienne de la hauteur issue de $A$.`;
+};
+const getCorrection = (identifiers) => {
+    const { AIds, BIds, CIds } = identifiers;
+    const A = PointConstructor.fromIdentifiers(AIds);
+    const B = PointConstructor.fromIdentifiers(BIds);
+    const C = PointConstructor.fromIdentifiers(CIds);
+    const normal = VectorConstructor.fromPoints(B, C);
+    const AM = new Vector("AM", substract("x", A.x), substract("y", A.y)).simplify();
+    return `La hauteur issue de $A$ est perpendiculaire à la droite $(BC)$. 
+  
+Un vecteur directeur de $(BC)$ est $${normal.toTexWithBinomCoords()}$.
+
+La hauteur issue de $A$ est donc une droite passant par $${A.toTexWithCoords()}$ et dont un vecteur normal est $${normal.toTexWithBinomCoords()}$.
+
+Pour déterminer une équation cartésienne de cette hauteur, on considère un point $M(x;y)$.
+  
+Les coordonnées du vecteur $\\overrightarrow{AM}$ sont alors $${AM.toBinomCoords().toTex()}$.
+
+Le point $M$ appartient à la hauteur si et seulement si :
+
+${alignTex([
+        ["", "\\overrightarrow{BC}\\cdot \\overrightarrow{AM}=0"],
+        ["\\iff", `${normal.scalarProduct(AM).toTex()} = 0`],
+        [
+            "\\iff",
+            `${normal
+                .scalarProduct(AM)
+                .simplify({ forbidFactorize: true, towardsDistribute: true })
+                .toTex()} = 0`,
+        ],
+    ])}
+
+Une équation cartésienne de $d$ est donc :
+
+$$
+${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getKeys = () => {
+    return ["x", "y", "equal"];
+};
+const isAnswerValid = (ans, { answer: _answer, AIds, BIds, CIds }) => {
+    try {
+        const splitted = ans.split("=");
+        if (splitted.length !== 2)
+            return false;
+        const left = parseAlgebraic(splitted[0]);
+        const right = parseAlgebraic(splitted[1]);
+        const studentEq = substract(left, right);
+        const point = PointConstructor.fromIdentifiers(AIds);
+        const B = PointConstructor.fromIdentifiers(BIds);
+        const C = PointConstructor.fromIdentifiers(CIds);
+        const normal = VectorConstructor.fromPoints(B, C).simplify();
+        //le point est-il sur la droite ?
+        if (Math.abs(studentEq
+            .toDetailedEvaluation({
+            x: point.x,
+            y: point.y,
+        })
+            .evaluate()) > 0.0001)
+            return false;
+        //le vecteur est-il normal ?
+        const studentC = studentEq.toDetailedEvaluation({
+            x: (0).toTree(),
+            y: (0).toTree(),
+        });
+        const studentAXPlusBY = substract(studentEq, studentC);
+        const studentA = studentAXPlusBY.toDetailedEvaluation({
+            x: (1).toTree(),
+            y: (0).toTree(),
+        });
+        const studentB = studentAXPlusBY.toDetailedEvaluation({
+            x: (0).toTree(),
+            y: (1).toTree(),
+        });
+        const studentVecNormal = new Vector("m", studentA, studentB);
+        return studentVecNormal.isColinear(normal);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCartesianEquationOfTriangleHeightQuestion = () => {
+    const A = PointConstructor.random("A");
+    const B = doWhile(() => PointConstructor.random("B"), (p) => p.equals(A));
+    const line = new Line(A, B);
+    const C = doWhile(() => PointConstructor.random("C"), (p) => p.equals(A) || p.equals(B) || line.includes(p));
+    const identifiers = {
+        AIds: A.toIdentifiers(),
+        BIds: B.toIdentifiers(),
+        CIds: C.toIdentifiers(),
+    };
+    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),
+    };
+};
+export const cartesianEquationOfTriangleHeight = {
+    id: "cartesianEquationOfTriangleHeight",
+    connector: "\\iff",
+    label: "Déterminer une équation cartésienne de la hauteur d'un triangle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCartesianEquationOfTriangleHeightQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -5,6 +5,9 @@ type Identifiers = {
     c: number;
     toReduced: boolean;
 };
-export declare const cartesianEquationToReduced: Exercise<Identifiers>;
+type Options = {
+    direction: string;
+};
+export declare const cartesianEquationToReduced: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=cartesianEquationToReduced.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cartesianEquationToReduced.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/cartesianEquationToReduced.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAmPF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}
+{"version":3,"file":"cartesianEquationToReduced.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/cartesianEquationToReduced.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AA4PF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgBF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBrE,CAAC"}

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

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
 import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
@@ -187,7 +187,7 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
         return handleVEAError(err);
     }
 };
-const getCartesianEquationToReducedQuestion = () => {
+const getCartesianEquationToReducedQuestion = (opts) => {
     let a;
     let b;
     let c;
@@ -200,7 +200,12 @@ const getCartesianEquationToReducedQuestion = () => {
         b = randint(-9, 10, [0]);
         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 identifiers = { a, b, c, toReduced: coinFlip() };
+    const toReduced = opts?.direction === "D'équation cartésienne à équation réduite"
+        ? true
+        : opts?.direction === "D'équation réduite à équation cartésienne"
+            ? false
+            : coinFlip();
+    const identifiers = { a, b, c, toReduced };
     return getQuestionFromIdentifiers(identifiers);
 };
 const getQuestionFromIdentifiers = (identifiers) => {
@@ -214,6 +219,20 @@ const getQuestionFromIdentifiers = (identifiers) => {
         correction: getCorrection(identifiers),
     };
 };
+const options = [
+    {
+        id: "direction",
+        label: "Sens demandé",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: [
+            "D'équation réduite à équation cartésienne",
+            "D'équation cartésienne à équation réduite",
+            "L'un ou l'autre aléatoirement",
+        ],
+        defaultValue: "L'un ou l'autre aléatoirement",
+    },
+];
 export const cartesianEquationToReduced = {
     id: "cartesianEquationToReduced",
     label: "Passer de l'équation réduite d'une droite à une équation cartésienne, et inversement",
@@ -230,4 +249,5 @@ export const cartesianEquationToReduced = {
     getAnswer,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    options,
 };

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

@@ -15,4 +15,5 @@ export * from "./findParallelLineFromCartesianEquation.js";
 export * from "./drawLineFromPointAndVector.js";
 export * from "./cartesianEquationsIntersection.js";
 export * from "./directorVectorFromAnother.js";
+export * from "./cartesianEquationOfTriangleHeight.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,iCAAiC,CAAC;AAChD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wCAAwC,CAAC;AACvD,cAAc,iCAAiC,CAAC;AAChD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wCAAwC,CAAC"}

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

@@ -15,3 +15,4 @@ export * from "./findParallelLineFromCartesianEquation.js";
 export * from "./drawLineFromPointAndVector.js";
 export * from "./cartesianEquationsIntersection.js";
 export * from "./directorVectorFromAnother.js";
+export * from "./cartesianEquationOfTriangleHeight.js";

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