math-exercises 3.0.158 → 3.0.160

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

@@ -0,0 +1,452 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain, 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, TriangleConstructor, } from "../../../../../../math/geometry/triangles/triangle.js";
+import { VectorConstructor } from "../../../../../../math/geometry/vector.js";
+import { randfloat } from "../../../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../../../math/utils/round.js";
+import { abs } from "../../../../../../tree/nodes/functions/absNode.js";
+import { arccos } from "../../../../../../tree/nodes/functions/arccosNode.js";
+import { sin } from "../../../../../../tree/nodes/functions/sinNode.js";
+import { sqrt } from "../../../../../../tree/nodes/functions/sqrtNode.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 { random } from "../../../../../../utils/alea/random.js";
+import { zip } from "../../../../../../utils/arrays/arrayZip.js";
+import { arrayRotation } from "../../../../../../utils/arrays/rotation.js";
+import { handleVEAError } from "../../../../../../utils/errors/handleVEAError.js";
+const precision = 2;
+const getHydrated = (identifiers) => {
+    const { triangleIds, pointIdsH } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIds);
+    const indexAngle = 1; //B
+    const sides = arrayRotation(triangle.sides, indexAngle);
+    const sideLengths = sides.map((segment) => round(segment.getLengthNode().evaluate(), precision));
+    const angleNames = arrayRotation(triangle.angles, indexAngle).map((angle) => angle.toTexMini());
+    const pointH = PointConstructor.fromIdentifiers(pointIdsH);
+    return {
+        triangle,
+        sides,
+        sideLengths,
+        angleNames,
+        pointH,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { triangle, sides, sideLengths } = getHydrated(identifiers);
+    return `Soit $${triangle.name}$ un triangle dont on connaît les longueurs des côtés :
+  
+${zip(sides, sideLengths).map(([segment, valueLength]) => `- $${segment.toInsideName()} = ${valueLength.frenchify()}$`).join(`
+  
+`)} 
+
+Combien le segment $BH$ mesure-t-il ? 
+Donner une valeur approchée en degrés avec $${precision}$ décimales.`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { sideLengths } = getHydrated(identifiers);
+    const nodeCosAngle = frac(substract(add(power(sideLengths[1], 2), power(sideLengths[2], 2)), power(sideLengths[0], 2)), multiply(2, multiply(sideLengths[1], sideLengths[2])));
+    const nodeLengthBA = sideLengths[1];
+    const nodeLengthBH = multiply(nodeLengthBA, abs(nodeCosAngle));
+    return {
+        nodeCosAngle,
+        nodeLengthBH,
+    };
+};
+const getAnswerNode = (identifiers) => {
+    return getAnswerStuff(identifiers).nodeLengthBH;
+};
+const getAnswer = (identifiers) => {
+    return round(getAnswerNode(identifiers).evaluate(), precision).frenchify();
+};
+const getHint = () => {
+    return `Applique le théorème d'Al Kashi dans le triangle $ABC$ pour l'angle $\\widehat{B}$.
+  
+Ensuite, calcule $\\overrightarrow{BA} \\cdot \\overrightarrow{BC}$ de deux manières différentes.`;
+};
+const getCorrection = (identifiers) => {
+    const { sides, angleNames } = getHydrated(identifiers);
+    const sideNames = sides
+        .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 { nodeLengthBH } = getAnswerStuff(identifiers);
+    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()} 
+$$
+
+D'une part, par définition du produit scalaire : 
+
+$$
+\\overrightarrow{BA} \\cdot \\overrightarrow{BC} = BA \\times BC \\times \\cos(${angleNames[0]})
+$$
+
+D'autre part, puisque $B$,$C$ et $H$ sont alignés : 
+
+$$
+\\lvert \\overrightarrow{BH} \\cdot \\overrightarrow{BC} \\rvert = BH \\times BC
+$$
+
+On a donc :
+
+$$
+BH =  BA \\times \\lvert  \\cos(${angleNames[0]}) \\rvert 
+$$
+
+$$
+BH = ${nodeLengthBH.toTex()}
+$$
+
+On arrondit à la toute fin :
+
+$$
+BH \\approx ${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { triangle, pointH: H } = getHydrated(identifiers);
+    const [A, B, C] = triangle.points;
+    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(),
+            //angle
+            ...new Angle([A, B, C]).toCommands({ color: greenMain }),
+        ],
+        hideAxes: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([B, A, C, H]),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { triangle, pointH: H } = getHydrated(identifiers);
+    const [A, B, C] = triangle.points;
+    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 { sideLengths } = getHydrated(identifiers);
+    const [BC, BA, _] = sideLengths;
+    const arrValueWrong = [];
+    //student: sign error
+    {
+        const nodeCosAngle = frac(substract(add(power(sideLengths[1], 2), power(sideLengths[2], 2)), power(sideLengths[0], 2)), multiply(-2, multiply(sideLengths[1], sideLengths[2])));
+        const nodeLengthBA = sideLengths[1];
+        const nodeLengthBH = multiply(nodeLengthBA, abs(nodeCosAngle));
+        const vWrong = nodeLengthBH.evaluate();
+        arrValueWrong.push(vWrong);
+        tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+    }
+    //student: computes AH instead of BH
+    {
+        const nodeCosAngle = frac(substract(add(power(sideLengths[1], 2), power(sideLengths[2], 2)), power(sideLengths[0], 2)), multiply(-2, multiply(sideLengths[1], sideLengths[2])));
+        const nodeLengthBA = sideLengths[1];
+        const nodeLengthAH = multiply(nodeLengthBA, abs(sin(arccos(nodeCosAngle))));
+        const vWrong = nodeLengthAH.evaluate();
+        arrValueWrong.push(vWrong);
+        tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+    }
+    //student: pythagore with BA and BC
+    {
+        if (BA >= BC) {
+            const nodeWrong = sqrt(substract(power(BA, 2), power(BC, 2)));
+            const vWrong = nodeWrong.evaluate();
+            arrValueWrong.push(vWrong);
+            tryToAddWrongProp(propositions, round(vWrong, precision).frenchify());
+        }
+    }
+    //terror: around answer, _most of the time_
+    {
+        const value = (() => {
+            const vAnswer = getAnswerStuff(identifiers).nodeLengthBH.evaluate();
+            if (probaFlip(0.6)) {
+                return vAnswer;
+            }
+            else {
+                return random([...arrValueWrong, vAnswer]);
+            }
+        })();
+        [...Array(2).keys()].forEach(() => {
+            const valueAnswerOffsetted = value + randfloat(-1.2, 1.2, 2, [0]);
+            if (valueAnswerOffsetted > 0) {
+                tryToAddWrongProp(propositions, round(valueAnswerOffsetted, precision).frenchify());
+            }
+        });
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(2, 20, 2, [0, 20]).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 getScalarProductAlKashiBHQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const opts = {
+        sectorOfPointH: random(arrayedOptions.sectorOfPointH),
+    };
+    const { sectorOfPointH } = opts;
+    function createRandomPoints() {
+        const offsetBtoC = 10;
+        const pointB = new Point("B", randfloat(0, 10), randfloat(0, 10));
+        const pointC = new Point("C", pointB.x.evaluate() + offsetBtoC + randfloat(-2, 8), randfloat(0, 10));
+        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 getRandomPointInside(points) {
+            const [xMin, xMax, yMin, yMax] = getCoordsForPoints(points);
+            let point;
+            let counter = -1;
+            let isValid = false;
+            while (!isValid && counter < 1000) {
+                counter++;
+                const x = randfloat(Math.ceil(xMin), Math.floor(xMax));
+                const y = randfloat(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("getRandomPointInside: too many iterations");
+            }
+            return point;
+        }
+        const pointRand = getRandomPointInside([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 pointHRaw = vecBH.getEndPoint(pointB, "H");
+        const pointH = new Point("H", pointHRaw.x.evaluate(), pointHRaw.y.evaluate());
+        return [pointB, pointA, pointC, pointH];
+    }
+    function isValidPoints(points) {
+        const [B, _, C, H] = points;
+        const minDistance = 2;
+        const isHFarEnough = () => B.distanceTo(H) > minDistance && C.distanceTo(H) > minDistance;
+        return isHFarEnough();
+    }
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        try {
+            const pointsCandidate = createRandomPoints();
+            isValid = isValidPoints(pointsCandidate);
+            if (isValid) {
+                const [B, A, C, H] = pointsCandidate;
+                const triangle = new Triangle([A, B, C]);
+                identifiers = {
+                    triangleIds: triangle.toIdentifiers(),
+                    pointIdsH: H.toIdentifiers(),
+                };
+            }
+        }
+        catch (_) {
+            (() => { })();
+        }
+    }
+    if (!isValid) {
+        const pointB = new Point("B", 10, 0);
+        const pointC = new Point("C", 20, 1);
+        const pointA = (() => {
+            switch (sectorOfPointH) {
+                case "Entre $B$ et $C$":
+                    return new Point("A", 14, 7);
+                case "Après $C$":
+                    return new Point("A", 25, 7);
+                case "Avant $B$":
+                    return new Point("A", 5, 7);
+                default:
+                    throw new Error("Unsupported opts.sectorOfPointH: " + opts.sectorOfPointH);
+            }
+        })();
+        const vecBC = VectorConstructor.fromPoints(pointB, pointC);
+        const nodeLengthBC = vecBC.getNorm().evaluate().toTree();
+        const vecBCUnited = vecBC.times(frac(1, nodeLengthBC));
+        const vecBA = VectorConstructor.fromPoints(pointB, pointA);
+        const vecBH = vecBCUnited.times(frac(vecBA.scalarProduct(vecBC), nodeLengthBC));
+        const pointHRaw = vecBH.getEndPoint(pointB, "H");
+        const pointH = new Point("H", pointHRaw.x.evaluate(), pointHRaw.y.evaluate());
+        const [B, A, C, H] = [pointB, pointA, pointC, pointH];
+        const triangle = new Triangle([A, B, C]);
+        const identifiersDefault = {
+            triangleIds: triangle.toIdentifiers(),
+            pointIdsH: H.toIdentifiers(),
+        };
+        identifiers = identifiersDefault;
+    }
+    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),
+        options: opts,
+    };
+};
+const optsDefault = {
+    sectorOfPointH: ["Entre $B$ et $C$"],
+};
+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,
+    },
+];
+export const scalarProductAlKashiBH = {
+    id: "scalarProductAlKashiBH",
+    connector: "=",
+    label: "Connaissant les longueurs de trois côtés d'un triangle $ABC$, calculer $BH$ ($H$ étant le pied de la hauteur issue de $A$)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductAlKashiBHQuestion(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,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasGeogebra: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductAlKashiSideLength.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiSideLength.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAoBnD,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4SF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAsBhE,CAAC"}