math-exercises 3.0.158 → 3.0.159

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductOfVectsOnGrid1.js

@@ -0,0 +1,347 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionType, GeneratorOptionTarget, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
+import { blueMain, greenMain, orange } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { Vector, VectorConstructor, } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { abs } from "../../../../../tree/nodes/functions/absNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../../utils/alea/random.js";
+import { getCartesiansProducts } from "../../../../../utils/arrays/cartesianProducts.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getHydratedVecs = (identifiers) => {
+    const { vecIds1, vecIds2 } = identifiers;
+    const [vec1, vec2] = [vecIds1, vecIds2].map((vecIds) => VectorConstructor.fromIdentifiers(vecIds));
+    return [vec1, vec2];
+};
+const getHydratedPoints = (identifiers) => {
+    const { pointIds1A, pointIds2A } = identifiers;
+    const [vec1, vec2] = getHydratedVecs(identifiers);
+    const [point1A, point2A] = [pointIds1A, pointIds2A].map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const point1B = vec1.getEndPoint(point1A);
+    const point2B = vec2.getEndPoint(point2A);
+    return [point1A, point1B, point2A, point2B];
+};
+const getInstruction = (identifiers) => {
+    const [vec1, vec2] = getHydratedVecs(identifiers);
+    return `Calculer : 
+  
+$$
+${vec1.toTex()} \\cdot ${vec2.toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { isVec1OnAxis, isOnAxisX } = identifiers;
+    const [vec1, vec2] = getHydratedVecs(identifiers);
+    const [vecOnAxis, vecOther] = isVec1OnAxis ? [vec1, vec2] : [vec2, vec1];
+    const vecOtherProj = isOnAxisX
+        ? new Vector("p", vecOther.x, (0).toTree())
+        : new Vector("p", (0).toTree(), vecOther.y);
+    const nodeCompVecOnAxis = isOnAxisX ? vecOnAxis.x : vecOnAxis.y;
+    const nodeCompVecOtherProj = isOnAxisX ? vecOtherProj.x : vecOtherProj.y;
+    const isSameSign = nodeCompVecOnAxis.evaluate() * nodeCompVecOtherProj.evaluate() > 0;
+    const nodeCompVecOnAxisPretty = abs(nodeCompVecOnAxis).evaluate().toTree();
+    const nodeCompVecOtherProjPretty = ((isSameSign ? +1 : -1) * abs(nodeCompVecOtherProj).evaluate()).toTree();
+    return isVec1OnAxis
+        ? multiply(nodeCompVecOnAxisPretty, nodeCompVecOtherProjPretty)
+        : multiply(nodeCompVecOtherProjPretty, nodeCompVecOnAxisPretty);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).simplify().toTex();
+};
+const getHint = () => {
+    return `Ici, on va se servir de la grille. Trouve un vecteur qui est parallèle à un axe de la grille, puis projète orthogonalement l'autre vecteur sur ce même axe.
+Ensuite, tu n'as plus qu'une multiplication à effectuer.`;
+};
+const getCorrection = (identifiers) => {
+    const { isVec1OnAxis, isOnAxisX } = identifiers;
+    const [vec1, vec2] = getHydratedVecs(identifiers);
+    const [vecOnAxis, vecOther] = isVec1OnAxis ? [vec1, vec2] : [vec2, vec1];
+    const vecOtherProj = isOnAxisX
+        ? new Vector("p", vecOther.x, (0).toTree())
+        : new Vector("p", (0).toTree(), vecOther.y);
+    const nodeAnswer = getAnswerNode(identifiers);
+    const isScalarProductZero = nodeAnswer.evaluate() === 0;
+    if (isScalarProductZero) {
+        return `Sur la grille, on remarque que les deux vecteurs sont orthogonaux.
+
+Leur produit scalaire est donc nul :
+
+$$
+${vec1.toTex()} \\cdot ${vec2.toTex()} = 0
+$$
+
+`;
+    }
+    else {
+        return `Sur la grille, on remarque que le vecteur $${vecOnAxis.toTex()}$ est parallèle à un axe de la grille.
+
+On projète $${vecOther.toTex()}$ sur ce même axe : on obtient le vecteur $${vecOtherProj.toTex()}$.
+
+Les vecteurs $${vecOnAxis.toTex()}$ et $${vecOtherProj.toTex()}$ sont colinéaires.
+
+Le calcul du produit scalaire est facilité :
+
+${alignTex([
+            [
+                `${vec1.toTex()} \\cdot ${vec2.toTex()}`,
+                "=",
+                `${isVec1OnAxis
+                    ? `${vecOnAxis.toTex()} \\cdot ${vecOtherProj.toTex()}`
+                    : `${vecOtherProj.toTex()} \\cdot ${vecOnAxis.toTex()}`}`,
+            ],
+            ["", "=", `${nodeAnswer.toTex({ forceNoSimplification: true })}`],
+            ["", "=", `${getAnswer(identifiers)}`],
+        ])}
+
+`;
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { isVec1OnAxis, isOnAxisX } = identifiers;
+    const [vec1, vec2] = getHydratedVecs(identifiers);
+    const [point1A, point1B, point2A, point2B] = getHydratedPoints(identifiers);
+    const [_, vecOther] = isVec1OnAxis ? [vec1, vec2] : [vec2, vec1];
+    const vecOtherProj = isOnAxisX
+        ? new Vector("p", vecOther.x, (0).toTree())
+        : new Vector("p", (0).toTree(), vecOther.y);
+    const pointPA = isVec1OnAxis ? point2A : point1A;
+    const pointPB = vecOtherProj.getEndPoint(pointPA);
+    const nodeAnswer = getAnswerNode(identifiers);
+    const isScalarProductZero = nodeAnswer.evaluate() === 0;
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `v1 = Vector(${point1A.toMathString()},${point1B.toMathString()})`,
+            `SetColor(v1, "${blueMain}")`,
+            `SetCaption(v1, "$${vec1.toTex()}$")`,
+            `ShowLabel(v1, true)`,
+            `v2 = Vector(${point2A.toMathString()},${point2B.toMathString()})`,
+            `SetColor(v2, "${orange}")`,
+            `SetCaption(v2, "$${vec2.toTex()}$")`,
+            `ShowLabel(v2, true)`,
+            ...(isScalarProductZero
+                ? []
+                : [
+                    `vP = Vector(${pointPA.toMathString()},${pointPB.toMathString()})`,
+                    `SetColor(vP, "${greenMain}")`,
+                    `SetCaption(vP, "$${vecOtherProj.toTex()}$")`,
+                    `ShowLabel(vP, true)`,
+                ]),
+        ],
+        hideAxes: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([point1A, point1B, point2A, point2B]),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const [vec1, vec2] = getHydratedVecs(identifiers);
+    const [point1A, point1B, point2A, point2B] = getHydratedPoints(identifiers);
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `v1 = Vector(${point1A.toMathString()},${point1B.toMathString()})`,
+            `SetColor(v1, "${blueMain}")`,
+            `SetCaption(v1, "$${vec1.toTex()}$")`,
+            `ShowLabel(v1, true)`,
+            `v2 = Vector(${point2A.toMathString()},${point2B.toMathString()})`,
+            `SetColor(v2, "${orange}")`,
+            `SetCaption(v2, "$${vec2.toTex()}$")`,
+            `ShowLabel(v2, true)`,
+        ],
+        hideAxes: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([point1A, point1B, point2A, point2B]),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const [vec1, vec2] = getHydratedVecs(identifiers);
+    const arrCoord1Coord2 = getCartesiansProducts([
+        [vec1.x, vec1.y],
+        [vec2.x, vec2.y],
+    ]);
+    //v1.[x or y] \\times v2.[x or y]
+    {
+        const arrNodeWrong = arrCoord1Coord2.map(([node1, node2]) => multiply(node1, node2).simplify());
+        arrNodeWrong.forEach((node) => {
+            tryToAddWrongProp(propositions, node.toTex());
+        });
+    }
+    //v1.[x or y] + v2.[x or y]
+    {
+        const arrNodeWrong = arrCoord1Coord2.map(([node1, node2]) => add(node1, node2).simplify());
+        arrNodeWrong.forEach((node) => {
+            tryToAddWrongProp(propositions, node.toTex());
+        });
+    }
+    //filler
+    {
+        if (propositions.length < n) {
+            const coordPool = [...Array(7).keys()].map((i) => i - 3);
+            const arrCoord1Coord2 = getCartesiansProducts([coordPool, coordPool]);
+            const arrNodeWrong = arrCoord1Coord2.map(([node1, node2]) => multiply(node1, node2).simplify());
+            arrNodeWrong.forEach((node) => {
+                tryToAddWrongProp(propositions, node.toTex());
+            });
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScalarProductOfVectsOnGrid1Question = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isSameStartPoint } = opts;
+    function createRandomIdentifiers() {
+        const isOnAxisX = coinFlip();
+        const vAxis = new Vector("vAxis", (!isOnAxisX ? 0 : randint(-3, 4, [0])).toTree(), (isOnAxisX ? 0 : randint(-3, 4, [0])).toTree());
+        const vOther = new Vector("vOther", randint(-3, 4, [vAxis.x.evaluate()]).toTree(), randint(-3, 4, [vAxis.y.evaluate()]).toTree());
+        const nameVPool = coinFlip() ? ["v_1", "v_2"] : ["u", "v", "w"];
+        const [strNameV1, strNameV2] = randomMany(nameVPool, 2);
+        const isVec1OnAxis = coinFlip();
+        const [vec1, vec2] = isVec1OnAxis
+            ? [
+                new Vector(strNameV1, vAxis.x, vAxis.y),
+                new Vector(strNameV2, vOther.x, vOther.y),
+            ]
+            : [
+                new Vector(strNameV1, vOther.x, vOther.y),
+                new Vector(strNameV2, vAxis.x, vAxis.y),
+            ];
+        const point1A = new Point("P1", randint(0, 3), randint(0, 3));
+        const point2A = isSameStartPoint
+            ? point1A
+            : new Point("P2", randint(0, 3), randint(0, 3));
+        return {
+            vecIds1: vec1.toIdentifiers(),
+            vecIds2: vec2.toIdentifiers(),
+            pointIds1A: point1A.toIdentifiers(),
+            pointIds2A: point2A.toIdentifiers(),
+            isVec1OnAxis,
+            isOnAxisX,
+        };
+    }
+    function isValidIdentifiers(identifiersCandidate) {
+        // const [vec1, vec2] = getHydratedVecs(identifiers);
+        const [point1A, point1B, point2A, point2B] = getHydratedPoints(identifiersCandidate);
+        function getCoordsFrame(arrPoint) {
+            const arrX = arrPoint.map((point) => point.x.evaluate());
+            const xMax = Math.max(...arrX);
+            const xMin = Math.min(...arrX);
+            const arrY = arrPoint.map((point) => point.x.evaluate());
+            const yMax = Math.max(...arrY);
+            const yMin = Math.min(...arrY);
+            return [xMin, xMax, yMin, yMax];
+        }
+        function isInSmallCoordsFrame(points) {
+            const [xMin, xMax, yMin, yMax] = getCoordsFrame(points);
+            const dx = xMax - xMin;
+            const dy = yMax - yMin;
+            const isValidXWise = 4 <= dx && dx <= 7;
+            const isValidYWise = 3 <= dy && dy <= 7;
+            return isValidXWise && isValidYWise;
+        }
+        const isValidFrameWise = () => isInSmallCoordsFrame([point1A, point1B, point2A, point2B]);
+        const isValidPointWise = () => {
+            if (!isSameStartPoint) {
+                return !(point1A.x.evaluate() === point2A.x.evaluate() &&
+                    point1A.y.evaluate() === point2A.y.evaluate());
+            }
+            else {
+                return true;
+            }
+        };
+        return isValidPointWise() && isValidFrameWise();
+    }
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        isValid = isValidIdentifiers(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const pointIds1A = new Point("P1A", 0, 0).toIdentifiers();
+        const identifiersDefault = {
+            vecIds1: new Vector("v_1", (1).toTree(), (0).toTree()).toIdentifiers(),
+            vecIds2: new Vector("v_2", (2).toTree(), (3).toTree()).toIdentifiers(),
+            pointIds1A: pointIds1A,
+            pointIds2A: isSameStartPoint
+                ? pointIds1A
+                : new Point("P2A", 1, -2).toIdentifiers(),
+            isVec1OnAxis: true,
+            isOnAxisX: true,
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    isSameStartPoint: false,
+};
+const options = [
+    {
+        id: "isSameStartPoint",
+        label: "Rapports positifs uniquement",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        defaultValue: optsDefault.isSameStartPoint,
+    },
+];
+export const scalarProductOfVectsOnGrid1 = {
+    id: "scalarProductOfVectsOnGrid1",
+    connector: "=",
+    label: "Produit scalaire de deux vecteurs sur un quadrillage ($1$)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductOfVectsOnGrid1Question(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    ggbTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getGGBOptions,
+    getInstruction,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductParallelogramDiagonalPlus.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+type Identifiers = {
+    pointIds: PointIdentifiers[];
+};
+export declare const scalarProductParallelogramDiagonalPlus: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductParallelogramDiagonalPlus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductParallelogramDiagonalPlus.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductParallelogramDiagonalPlus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAkBtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AA2UF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAuBxE,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductParallelogramDiagonalPlus.js

@@ -0,0 +1,301 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, purpleMain, red } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../../math/utils/round.js";
+import { sqrt } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.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 { random } from "../../../../../utils/alea/random.js";
+import { zip } from "../../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const precision = 2;
+const getHydrated = (identifiers) => {
+    const { pointIds } = identifiers;
+    const [A, B, C, D] = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const AB = round(A.distanceTo(B), precision);
+    const AD = round(A.distanceTo(D), precision);
+    const BD = round(B.distanceTo(D), precision);
+    return {
+        points: [A, B, C, D],
+        AB,
+        AD,
+        BD,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { AB, AD, BD } = getHydrated(identifiers);
+    return `Soit $ABCD$ un parallélogramme dont on connaît les longueurs suivantes :
+  
+${zip(["AB", "AD", "BD"], [AB, AD, BD]).map(([name, valueLength]) => `- $${name} = ${valueLength.frenchify()}$`).join(`
+  
+`)}
+
+Combien le segment $AC$ mesure-t-il ? 
+Donner une valeur approchée en degrés avec $${precision}$ décimales.`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { AB, AD, BD } = getHydrated(identifiers);
+    const nodeACSquared = substract(multiply(2, add(power(AB, 2), power(AD, 2))), power(BD, 2));
+    const nodeAC = sqrt(nodeACSquared);
+    return {
+        nodeAC,
+    };
+};
+const getAnswerNode = (identifiers) => {
+    return getAnswerStuff(identifiers).nodeAC;
+};
+const getAnswer = (identifiers) => {
+    return round(getAnswerNode(identifiers).evaluate(), precision).frenchify();
+};
+const getHint = () => {
+    const [u, v] = ["AB", "AD"].map((name) => `\\overrightarrow{${name}}`);
+    return `Utilise les égalités suivantes :
+
+$$
+AC^2 = {\\lVert ${u} + ${v} \\rVert}^2
+$$
+
+$$
+DB^2 = {\\lVert ${u} - ${v} \\rVert}^2
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const [u, v, uPlusV, uMinusV] = ["AB", "AD", "AC", "DB"].map((name) => `\\overrightarrow{${name}}`);
+    return `$ABCD$ est un parallélogramme. Par conséquent : 
+
+- $${uPlusV} = ${u} + ${v}$
+
+- $${uMinusV} = ${u} - ${v}$
+
+Ainsi :
+
+${alignTex([
+        ["{AC}^2", "=", `{\\lVert ${u} + ${v} \\rVert}^2`],
+        [
+            "",
+            "=",
+            `{\\lVert ${u} \\rVert}^2 + {\\lVert ${v} \\rVert}^2 + 2 ${u} \\cdot ${v}`,
+        ],
+    ])}
+
+${alignTex([
+        ["{DB}^2", "=", `{\\lVert ${u} - ${v} \\rVert}^2`],
+        [
+            "",
+            "=",
+            `{\\lVert ${u} \\rVert}^2 + {\\lVert ${v} \\rVert}^2 - 2 ${u} \\cdot ${v}`,
+        ],
+    ])}
+
+On additionne : 
+
+$$
+{AC}^2 + {DB}^2 = 2 \\left( {AB}^2 + {AD}^2 \\right)
+$$
+
+Donc : 
+
+$$
+AC = \\sqrt{ 2 \\left( {AB}^2 + {AD}^2 \\right) - {DB}^2 }
+$$
+
+On arrondit à la toute fin :
+
+$$
+AC \\approx ${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { points } = getHydrated(identifiers);
+    const [u, v] = ["u", "v"].map((name) => `\\overrightarrow{${name}}`);
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //points
+            ...points.flatMap((point) => point.toGGBCommand()),
+            //u
+            `u = Vector(A,B)`,
+            `SetColor(u, "${blueMain}")`,
+            `SetCaption(u, "$\\small ${u}$")`,
+            `ShowLabel(u, true)`,
+            //v
+            `v = Vector(A,D)`,
+            `SetColor(v, "${red}")`,
+            `SetCaption(v, "$\\small ${v}$")`,
+            `ShowLabel(v, true)`,
+            //u - v
+            `uMinusV = Vector(D,B)`,
+            `SetColor(uMinusV, "${purpleMain}")`,
+            // `SetCaption(uMinusV, "$\\small ${u} - ${v}$")`,
+            // `ShowLabel(uMinusV, true)`,
+            //u + v
+            `uPlusV = Vector(A,C)`,
+            `SetColor(uPlusV, "${greenMain}")`,
+            `SetCaption(uPlusV, "$\\small ${u} + ${v}$")`,
+            `ShowLabel(uPlusV, true)`,
+        ],
+        hideAxes: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { points } = getHydrated(identifiers);
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //points
+            ...points.flatMap((point) => point.toGGBCommand()),
+            //parallelogram ABCD
+            `Pol = Polygon(${points.map((point) => point.name).join(",")})`,
+            //segment BD
+            `segBD = Segment(B,D)`,
+            `SetLineStyle(segBD, 2)`,
+        ],
+        hideAxes: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { AB, AD, BD } = getHydrated(identifiers);
+    const arrValueWrong = [];
+    //student: forgets to sqrt
+    if (probaFlip(0.1)) {
+        const nodeACSquared = substract(multiply(2, add(power(AB, 2), power(AD, 2))), power(BD, 2));
+        const vWrong = nodeACSquared.evaluate();
+        arrValueWrong.push(vWrong);
+        tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+    }
+    //student: wrong formula: wrong factor
+    {
+        const nodeACSquared = substract(multiply(1, add(power(AB, 2), power(AD, 2))), power(BD, 2));
+        if (nodeACSquared.evaluate() >= 0) {
+            const nodeWrong = sqrt(nodeACSquared);
+            const vWrong = nodeWrong.evaluate();
+            arrValueWrong.push(vWrong);
+            tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+        }
+    }
+    //student: wrong formula: add instead of sub
+    {
+        const nodeACSquared = add(multiply(2, add(power(AB, 2), power(AD, 2))), power(BD, 2));
+        const nodeWrong = sqrt(nodeACSquared);
+        const vWrong = nodeWrong.evaluate();
+        arrValueWrong.push(vWrong);
+        tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+    }
+    //student: pythagore in ABC
+    {
+        const nodeWrong = sqrt(add(power(AB, 2), power(AD, 2)));
+        const vWrong = nodeWrong.evaluate();
+        arrValueWrong.push(vWrong);
+        tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+    }
+    //student: scalar AB+AD instead of ||vecAB + vecAD||
+    {
+        const nodeWrong = add(AB, AD);
+        const vWrong = nodeWrong.evaluate();
+        arrValueWrong.push(vWrong);
+        tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+    }
+    //terror: around answer, _most of the time_
+    {
+        const value = (() => {
+            const vAnswer = getAnswerNode(identifiers).evaluate();
+            if (probaFlip(0.6)) {
+                return vAnswer;
+            }
+            else {
+                return random([...arrValueWrong, vAnswer]);
+            }
+        })();
+        [...Array(2).keys()].forEach(() => {
+            const valueAnswerOffsetted = value + randfloat(-1.6, 1.6, 2, [0]);
+            if (valueAnswerOffsetted > 0) {
+                tryToAddWrongProp(propositions, round(valueAnswerOffsetted, precision).frenchify());
+            }
+        });
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(7, 30, 2).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 getScalarProductParallelogramDiagonalPlusQuestion = () => {
+    //    B   C
+    //  A   D
+    const [xA, yA] = [randfloat(0, 10, 2), randfloat(0, 10, 2)];
+    const [xB, yB] = [randfloat(0, 10, 2, [xA]), randfloat(14, 24, 2)];
+    const [xC, yC] = [randfloat(14, 24, 2), randfloat(14, 24, 2)];
+    const [A, B, C] = zip(["A", "B", "C"], [
+        [xA, yA],
+        [xB, yB],
+        [xC, yC],
+    ]).map(([pointName, [x, y]]) => new Point(pointName, x, y));
+    const vecBC = VectorConstructor.fromPoints(B, C);
+    const D = vecBC.getEndPoint(A, "D");
+    const identifiers = {
+        pointIds: [A, B, C, D].map((point) => point.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+};
+export const scalarProductParallelogramDiagonalPlus = {
+    id: "scalarProductParallelogramDiagonalPlus",
+    connector: "=",
+    label: "$ABCD$ étant un parallélogramme avec $AB$, $AD$ et $BD$ donnés, calculer $AC$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductParallelogramDiagonalPlusQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasGeogebra: true,
+};

package/lib/exercises/math/probaStat/randomVariable/findValueForFairRandomVariable.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    valuesIds: NodeIdentifiers[];
+    probasIds: NodeIdentifiers[];
+};
+export declare const findValueForFairRandomVariable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findValueForFairRandomVariable.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/findValueForFairRandomVariable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findValueForFairRandomVariable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/findValueForFairRandomVariable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,SAAS,EAAE,eAAe,EAAE,CAAC;CAC9B,CAAC;AA0HF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAmBhE,CAAC"}