math-exercises 3.0.158 → 3.0.160

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

@@ -0,0 +1,423 @@
+import { addValidProp, shuffleProps, GeneratorOptionType, GeneratorOptionTarget, tryToAddWrongProp, propWhile, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { orange } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Angle } from "../../../../../math/geometry/angle.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { relationPP } from "../../../../../math/geometry/polygons/relationPP.js";
+import { Segment } from "../../../../../math/geometry/segment.js";
+import { Triangle } from "../../../../../math/geometry/triangles/triangle.js";
+import { 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 { frac, isFractionNode, } from "../../../../../tree/nodes/operators/fractionNode.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 { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getHydratedPoints = (identifiers) => {
+    const { pointIds } = identifiers;
+    return pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+};
+const getInstruction = (identifiers) => {
+    const [B, A, C, _] = getHydratedPoints(identifiers);
+    return `Soient les points :
+
+${[A, B, C].map((point) => `- $${point.toTexWithCoords()}$`).join(`
+`)}
+  
+Dans $BAC$, $H$ est le pied de la hauteur issue de $A$.
+  
+Calculer la longueur $BH$.
+
+*Donner la valeur exacte.*`;
+};
+const getAnswerNode = (identifiers) => {
+    const [pointB, pointA, pointC, _] = getHydratedPoints(identifiers);
+    const vecBC = VectorConstructor.fromPoints(pointB, pointC);
+    const nodeLengthBC = vecBC.getNorm();
+    const vecBA = VectorConstructor.fromPoints(pointB, pointA);
+    return frac(abs(vecBA.scalarProduct(vecBC)), nodeLengthBC);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).simplify().toTex();
+};
+const getHint = () => {
+    return `Combien vaut le produit scalaire $\\overrightarrow{BA} \\cdot \\overrightarrow{BC}$ ?
+  
+Est-ce qu'il est égal à $\\overrightarrow{BH} \\cdot \\overrightarrow{BC}$ ? Et pourquoi ?`;
+};
+const getCorrection = (identifiers) => {
+    const [pointB, pointA, pointC, _] = getHydratedPoints(identifiers);
+    const vecBC = VectorConstructor.fromPoints(pointB, pointC);
+    const nodeLengthBC = vecBC.getNorm();
+    const vecBA = VectorConstructor.fromPoints(pointB, pointA);
+    const nodeScalarProduct = vecBA.scalarProduct(vecBC);
+    return `Dans $BAC$, $H$ est le pied de la hauteur issue de $A$.
+  
+Autrement dit, $H$ est le projeté orthogonal de $A$ sur $(BC)$.
+
+Par conséquent : 
+
+$$
+\\overrightarrow{BA} \\cdot \\overrightarrow{BC} = \\overrightarrow{BH} \\cdot \\overrightarrow{BC}
+$$
+
+Or, puisque $B$,$C$ et $H$ sont alignés : 
+
+$$
+\\lvert \\overrightarrow{BH} \\cdot \\overrightarrow{BC} \\rvert = BH \\times BC
+$$
+
+On a donc : 
+
+$$
+BH = \\frac{\\lvert \\overrightarrow{BA} \\cdot \\overrightarrow{BC} \\rvert}{BC}
+$$
+
+Application numérique : 
+
+$$
+\\overrightarrow{BA} = ${vecBA.toCoords()}
+$$
+
+$$
+\\overrightarrow{BC} = ${vecBC.toCoords()}
+$$
+
+$$
+\\overrightarrow{BA} \\cdot \\overrightarrow{BC} = ${nodeScalarProduct.toTex()}
+$$
+
+$$
+BC = ${nodeLengthBC.toTex()}
+$$
+
+$$
+BH = ${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const [B, A, C, H] = getHydratedPoints(identifiers);
+    const triangle = new Triangle([B, A, C]);
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //triangle
+            ...triangle.commands,
+            //AH
+            ...H.toGGBCommand({ isFixed: true, showLabel: true }),
+            ...new Segment(A, H).toGGBCommands(false, {
+                isFixed: true,
+                style: 2,
+                color: `${orange}`,
+            }),
+            //BH
+            ...new Segment(B, H).toGGBCommands(false, {
+                isFixed: true,
+                style: 2,
+            }),
+            //angle
+            ...new Angle([A, H, C]).toCommands(),
+        ],
+        hideAxes: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([B, A, C, H]),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const nodeAnswer = getAnswerNode(identifiers);
+    //student does scalarProduct(CA,BC) instead of scalarProduct(BA,BC)
+    function createNodeMistakeWrongScalarProduct(identifiers) {
+        const [pointB, pointA, pointC, _] = getHydratedPoints(identifiers);
+        const vecBC = VectorConstructor.fromPoints(pointB, pointC);
+        const nodeLengthBC = vecBC.getNorm();
+        const vecCA = VectorConstructor.fromPoints(pointC, pointA);
+        const nodeScalarProduct = vecCA.scalarProduct(vecBC);
+        return frac(abs(nodeScalarProduct), nodeLengthBC).simplify();
+    }
+    const nodeWrongSP = createNodeMistakeWrongScalarProduct(identifiers);
+    tryToAddWrongProp(propositions, nodeWrongSP.toTex());
+    //student does scalarProduct(CA,BC) instead of scalarProduct(BA,BC) + divides by CA
+    function createNodeMistakeWrongScalarProductAndWrongDen(identifiers) {
+        const [pointB, pointA, pointC, _] = getHydratedPoints(identifiers);
+        const vecBC = VectorConstructor.fromPoints(pointB, pointC);
+        const vecCA = VectorConstructor.fromPoints(pointC, pointA);
+        const nodeLengthCA = vecCA.getNorm();
+        const nodeScalarProduct = vecCA.scalarProduct(vecBC);
+        return frac(abs(nodeScalarProduct), nodeLengthCA).simplify();
+    }
+    const nodeWrongSPAndDen = createNodeMistakeWrongScalarProductAndWrongDen(identifiers);
+    tryToAddWrongProp(propositions, nodeWrongSPAndDen.toTex());
+    //terror: wrong sign
+    function createNodeTerrorSign(nodeSrc) {
+        if (isFractionNode(nodeSrc)) {
+            const nodeNum = nodeSrc.leftChild;
+            const nodeDen = nodeSrc.rightChild;
+            const nodeWrong = frac(multiply(-1, nodeNum).simplify(), nodeDen);
+            return nodeWrong;
+        }
+    }
+    const nodeTerrorSign = createNodeTerrorSign(coinFlip() ? nodeAnswer : random([nodeWrongSP, nodeWrongSPAndDen]));
+    if (nodeTerrorSign) {
+        tryToAddWrongProp(propositions, nodeTerrorSign.simplify().toTex());
+    }
+    //terror: frac num (related to: student has made a mistake when computing scalarProduct)
+    function createNodeTerrorFracNum(nodeSrc) {
+        if (isFractionNode(nodeSrc)) {
+            const nodeNum = nodeSrc.leftChild;
+            const nodeDen = nodeSrc.rightChild;
+            const nodeWrong = frac(add(nodeNum, randint(-3, 3, [0])).simplify(), nodeDen);
+            return nodeWrong;
+        }
+    }
+    const nodeTerrorFracNum = createNodeTerrorFracNum(coinFlip()
+        ? nodeAnswer
+        : random([
+            nodeWrongSP,
+            nodeWrongSPAndDen,
+            ...(nodeTerrorSign ? [nodeTerrorSign] : []),
+        ]));
+    if (nodeTerrorFracNum) {
+        tryToAddWrongProp(propositions, nodeTerrorFracNum.simplify().toTex());
+    }
+    //filler
+    propWhile(propositions, n, () => {
+        const [B, A, C, H] = getHydratedPoints(identifiers);
+        const BWrong = new Point("B", add(B.x, randint(-3, 3, [0])).simplify(), B.y);
+        const identifiersWrong = Object.assign({}, identifiers, {
+            pointIds: [BWrong, A, C, H].map((point) => point.toIdentifiers()),
+        });
+        const nodeWrong = getAnswerNode(identifiersWrong);
+        tryToAddWrongProp(propositions, nodeWrong.simplify().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScalarProductComputeBHQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const opts = {
+        sectorOfPointH: random(arrayedOptions.sectorOfPointH),
+        isPositiveCoordsOnly: arrayedOptions.isPositiveCoordsOnly,
+    };
+    const { sectorOfPointH, isPositiveCoordsOnly } = opts;
+    function createRandomIdentifiers() {
+        const offsetBtoC = 10;
+        const pointB = (() => {
+            if (isPositiveCoordsOnly) {
+                return new Point("B", randint(0, 10), randint(0, 10));
+            }
+            else {
+                return new Point("B", randint(-10, 0), randint(-10, 0));
+            }
+        })();
+        const pointC = new Point("C", pointB.x.evaluate() + offsetBtoC + randint(-2, 8), randint(0, 10, [pointB.y.evaluate()]));
+        const vecBC = VectorConstructor.fromPoints(pointB, pointC);
+        const nodeLengthBC = vecBC.getNorm();
+        const vecBCUnited = vecBC.times(frac(1, nodeLengthBC));
+        const vecOrthUnited = vecBCUnited.getOrthogonal().times((-1).toTree());
+        //rect PQRS will contain A, D is Proj(P,(BC)), E is Proj(S,(BC))
+        const nodeOffsetDtoE = (10).toTree();
+        const nodeOffsetBtoD = (() => {
+            switch (sectorOfPointH) {
+                case "Entre $B$ et $C$":
+                    return (0).toTree();
+                case "Après $C$":
+                    return nodeLengthBC;
+                case "Avant $B$":
+                    return multiply((-1).toTree(), nodeOffsetDtoE);
+                default:
+                    throw new Error("Unsupported opts.sectorOfPointH: " + opts.sectorOfPointH);
+            }
+        })();
+        const pointD = vecBCUnited.times(nodeOffsetBtoD).getEndPoint(pointB);
+        const pointE = vecBCUnited.times(nodeOffsetDtoE).getEndPoint(pointD);
+        const minOffsetBCtoA = 3;
+        const maxOffsetBCtoA = minOffsetBCtoA + 10;
+        const pointP = vecOrthUnited
+            .times(minOffsetBCtoA.toTree())
+            .getEndPoint(pointD);
+        const pointQ = vecOrthUnited
+            .times((maxOffsetBCtoA - minOffsetBCtoA).toTree())
+            .getEndPoint(pointP);
+        const pointS = vecOrthUnited
+            .times(minOffsetBCtoA.toTree())
+            .getEndPoint(pointE);
+        const pointR = vecOrthUnited
+            .times((maxOffsetBCtoA - minOffsetBCtoA).toTree())
+            .getEndPoint(pointS);
+        function getCoordsForPoints(points) {
+            const xMin = Math.min(...points.map((p) => p.x.evaluate()));
+            const xMax = Math.max(...points.map((p) => p.x.evaluate()));
+            const yMin = Math.min(...points.map((p) => p.y.evaluate()));
+            const yMax = Math.max(...points.map((p) => p.y.evaluate()));
+            return [xMin, xMax, yMin, yMax];
+        }
+        function getRandomIntegerPointInside(points) {
+            const [xMin, xMax, yMin, yMax] = getCoordsForPoints(points);
+            let point;
+            let counter = -1;
+            let isValid = false;
+            while (!isValid && counter < 1000) {
+                counter++;
+                const x = randint(Math.ceil(xMin), Math.floor(xMax));
+                const y = randint(Math.ceil(yMin), Math.floor(yMax));
+                const pointCandidate = new Point("RIP", x, y);
+                isValid = relationPP(pointCandidate, points) !== -1;
+                if (isValid) {
+                    point = pointCandidate;
+                }
+            }
+            if (!isValid) {
+                throw new Error("getRandomIntegerPointInside: too many iterations");
+            }
+            return point;
+        }
+        const pointRand = getRandomIntegerPointInside([
+            pointP,
+            pointQ,
+            pointR,
+            pointS,
+        ]);
+        const pointA = new Point("A", pointRand.x, pointRand.y);
+        const vecBA = VectorConstructor.fromPoints(pointB, pointA);
+        const vecBH = vecBCUnited.times(frac(vecBA.scalarProduct(vecBC), nodeLengthBC));
+        const pointH = vecBH.getEndPoint(pointB, "H");
+        return {
+            pointIds: [pointB, pointA, pointC, pointH].map((point) => point.toIdentifiers()),
+        };
+    }
+    function isIntegerPoint(point) {
+        const isIntegerX = () => point.x.evaluate() % 1 === 0;
+        const isIntegerY = () => point.y.evaluate() % 1 === 0;
+        return isIntegerX() && isIntegerY();
+    }
+    function isPositiveCoords(point) {
+        const isPositiveX = () => point.x.evaluate() >= 0;
+        const isPositiveY = () => point.y.evaluate() >= 0;
+        return isPositiveX() && isPositiveY();
+    }
+    function isValidIdentifiers(identifiersCandidate) {
+        const [B, A, C, H] = getHydratedPoints(identifiersCandidate);
+        const minDistance = 2;
+        const isHFarEnough = () => B.distanceTo(H) > minDistance && C.distanceTo(H) > minDistance;
+        const isValidPositivelyWise = () => isPositiveCoordsOnly
+            ? isPositiveCoords(B) && isPositiveCoords(A) && isPositiveCoords(C)
+            : true;
+        return !isIntegerPoint(H) && isHFarEnough() && isValidPositivelyWise();
+    }
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        try {
+            const identifiersCandidate = createRandomIdentifiers();
+            isValid = isValidIdentifiers(identifiersCandidate);
+            if (isValid) {
+                identifiers = identifiersCandidate;
+            }
+        }
+        catch (_) {
+            (() => { })();
+        }
+    }
+    if (!isValid) {
+        const pointB = new Point("B", 0, 0);
+        const pointC = new Point("C", 10, 1);
+        const pointA = new Point("A", 4, 7);
+        const vecBC = VectorConstructor.fromPoints(pointB, pointC);
+        const nodeLengthBC = vecBC.getNorm();
+        const vecBCUnited = vecBC.times(frac(1, nodeLengthBC));
+        const vecBA = VectorConstructor.fromPoints(pointB, pointA);
+        const vecBH = vecBCUnited.times(frac(vecBA.scalarProduct(vecBC), nodeLengthBC));
+        const pointH = vecBH.getEndPoint(pointB);
+        const identifiersDefault = {
+            pointIds: [pointB, pointA, pointC, pointH].map((point) => point.toIdentifiers()),
+        };
+        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),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    sectorOfPointH: ["Entre $B$ et $C$"],
+    isPositiveCoordsOnly: true,
+};
+const options = [
+    {
+        id: "sectorOfPointH",
+        label: "Position du point $H$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entre $B$ et $C$", "Après $C$", "Avant $B$"],
+        defaultValue: optsDefault.sectorOfPointH,
+    },
+    {
+        id: "isPositiveCoordsOnly",
+        label: "Coordonnées positives uniquement",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isPositiveCoordsOnly,
+    },
+];
+export const scalarProductComputeBH = {
+    id: "scalarProductComputeBH",
+    connector: "=",
+    label: "À partir de $A$, $B$ et $C$ ($H$ étant le projeté de $A$ sur $(BC)$), calculer $BH$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductComputeBHQuestion(opts), nb),
+    options,
+    validateOptions: (opts) => {
+        return {
+            valid: !!(opts?.sectorOfPointH.length > 0),
+            message: "Veuillez choisir au moins un secteur pour le point $H$.",
+        };
+    },
+    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/scalarProductOfVectsOnGrid1.d.ts

@@ -0,0 +1,17 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+import { VectorIdentifiers } from "../../../../../math/geometry/vector.js";
+type Identifiers = {
+    vecIds1: VectorIdentifiers;
+    vecIds2: VectorIdentifiers;
+    pointIds1A: PointIdentifiers;
+    pointIds2A: PointIdentifiers;
+    isVec1OnAxis: boolean;
+    isOnAxisX: boolean;
+};
+type Options = {
+    isSameStartPoint: boolean;
+};
+export declare const scalarProductOfVectsOnGrid1: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=scalarProductOfVectsOnGrid1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductOfVectsOnGrid1.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductOfVectsOnGrid1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAWvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAiYF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAgBF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyBtE,CAAC"}