math-exercises 3.0.158 → 3.0.159

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnPerpendicularBisector.js

@@ -0,0 +1,180 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../../../math/geometry/point.js";
+import { Vector, VectorConstructor, } from "../../../../../../math/geometry/vector.js";
+import { randomVecs2 } from "../../../../../../math/utils/geometry/randomVecs2.js";
+import { randint } from "../../../../../../math/utils/random/randint.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 { substract } from "../../../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../../../utils/arrays/arrayZip.js";
+import { alignTex } from "../../../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { vecIdsU, vecIdsV, pointIds, pointNames } = identifiers;
+    const vecU = VectorConstructor.fromIdentifiers(vecIdsU);
+    const vecV = VectorConstructor.fromIdentifiers(vecIdsV);
+    const [nameP1, nameP2, nameP3] = pointNames;
+    const pointI = PointConstructor.fromIdentifiers(pointIds);
+    const point1 = vecU.times((-1).toTree()).getEndPoint(pointI, nameP1);
+    const point2 = vecU.getEndPoint(pointI, nameP2);
+    const point3 = vecV.getEndPoint(pointI, nameP3);
+    return {
+        vecU,
+        vecV,
+        [point1.name]: point1,
+        [point2.name]: point2,
+        [point3.name]: point3,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { pointNames } = identifiers;
+    const { A, B, C } = getHydrated(identifiers);
+    return `Soient trois points : 
+  
+${[A, B, C].map((point) => `- $${point.toTexWithCoords()}$`).join(`
+  
+`)}
+  
+Le point $${pointNames[2]}$ appartient-il à la médiatrice du segment $[${pointNames[0]}${pointNames[1]}]$ ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { vecU, vecV } = getHydrated(identifiers);
+    const nodesU = [vecU.x, vecU.y];
+    const nodesV = [vecV.x, vecV.y];
+    return zip(nodesU, nodesV)
+        .map(([nodeUX, nodeVX]) => multiply(nodeUX, nodeVX))
+        .reduce((acc, nodeX) => add(acc, nodeX));
+};
+const getAnswer = (identifiers) => {
+    const answerNode = getAnswerNode(identifiers);
+    const isOrthogonal = answerNode.simplify().evaluate() === 0;
+    return ["Oui", "Non"][isOrthogonal ? 0 : 1];
+};
+const getHint = () => {
+    const [a, b] = ["a", "b"].map((letter) => `\\overrightarrow{${letter}}`);
+    return `Deux vecteurs $${a}$ et $${b}$ sont orthogonaux si et seulement si $${a} \\cdot ${b} = 0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { pointNames, pointIds } = identifiers;
+    const { vecU, vecV, A, B, C } = getHydrated(identifiers);
+    const pointsDict = { A, B, C };
+    const [point1, point2, point3] = pointNames.map((pointName) => pointsDict[pointName]);
+    const vecOI = new Vector(`OI`, frac(add(point1.x, point2.x), 2), frac(add(point1.y, point2.y), 2));
+    function createVecComputation(pointStart, pointEnd) {
+        const nodeX = substract(pointEnd.x, pointStart.x);
+        const nodeY = substract(pointEnd.y, pointStart.y);
+        return new Vector(`${pointStart.name}${pointEnd.name}`, nodeX, nodeY);
+    }
+    const pointI = PointConstructor.fromIdentifiers(pointIds);
+    const vecComputation2U = createVecComputation(point1, point2);
+    const vecComputationV = createVecComputation(pointI, point3);
+    const isOrthogonal = getAnswerNode(identifiers).simplify().evaluate() === 0;
+    const nodeScalarProduct = vecU.scalarProduct(vecV);
+    return `On nomme $O$ l'origine du repère et $I$ le milieu de $[${point1.name}${point2.name}]$. On a :
+
+${alignTex([
+        [
+            "\\overrightarrow{OI}",
+            "=",
+            `\\frac{\\overrightarrow{O${point1.name}} + \\overrightarrow{O${point2.name}}}{2}`,
+        ],
+        ["", "=", `${vecOI.toCoords()}`],
+        ["", "=", `${vecOI.simplify().toCoords()}`],
+    ])}
+
+On peut calculer les coordonnées des vecteurs :
+
+${zip([vecComputation2U, vecComputationV], [vecU.times((2).toTree()).simplify(), vecV]).map(([vecComputation, vec]) => `
+
+${alignTex([
+        [vecComputation.toTex(), "=", vecComputation.toCoords()],
+        ["", "=", vec.toCoords()],
+    ])}
+
+`).join(`
+    
+`)}
+
+${alignTex([
+        [
+            `${vecComputation2U.toTex()} \\cdot ${vecComputationV.toTex()}`,
+            "=",
+            `${nodeScalarProduct.toTex()}`,
+        ],
+        ["", "=", `${nodeScalarProduct.simplify().toTex()}`],
+    ])}
+  
+${(() => {
+        if (isOrthogonal) {
+            return `Les vecteurs $${vecComputation2U.toTex()}$ et $${vecComputationV.toTex()}$ sont donc orthogonaux.
+Le point $${point3.name}$ appartient donc à la médiatrice de $[${point1.name}${point2.name}]$.`;
+        }
+        else {
+            return `Les vecteurs $${vecComputation2U.toTex()}$ et $${vecComputationV.toTex()}$ ne sont donc pas orthogonaux.
+Le point $${point3.name}$ n'appartient donc pas à la médiatrice de $[${point1.name}${point2.name}]$.`;
+        }
+    })()}`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const propositions = [];
+    const answerFromIdentifiers = getAnswer(identifiers);
+    ["Oui", "Non"].forEach((strProp) => {
+        if (strProp === answerFromIdentifiers) {
+            addValidProp(propositions, strProp, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, strProp, "raw");
+        }
+    });
+    return propositions;
+};
+const getScalarProductIsPointOnPerpendicularBisectorQuestion = () => {
+    const isOrthogonal = coinFlip();
+    const { vecU, vecV } = randomVecs2(isOrthogonal);
+    const x = Math.ceil(-Math.max(vecU.x.evaluate(), vecV.x.evaluate()) / 2) +
+        randint(0, 3);
+    const y = Math.ceil(-Math.max(vecU.y.evaluate(), vecV.y.evaluate()) / 2) +
+        randint(0, 3);
+    const pointI = new Point("I", x, y);
+    const pointNames = shuffle(["A", "B", "C"]);
+    const identifiers = {
+        vecIdsU: vecU.toIdentifiers(),
+        vecIdsV: vecV.toIdentifiers(),
+        pointIds: pointI.toIdentifiers(),
+        pointNames,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+};
+export const scalarProductIsPointOnPerpendicularBisector = {
+    id: "scalarProductIsPointOnPerpendicularBisector",
+    connector: "=",
+    label: "Déterminer si un point appartient à la médiatrice d'un segment",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getScalarProductIsPointOnPerpendicularBisectorQuestion(), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsRightTriangleUsingPointCoords.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../../math/geometry/point.js";
+import { VectorIdentifiers } from "../../../../../../math/geometry/vector.js";
+type Identifiers = {
+    vecIdsU: VectorIdentifiers;
+    vecIdsV: VectorIdentifiers;
+    pointIds: PointIdentifiers;
+    pointNames: string[];
+};
+export declare const scalarProductIsRightTriangleUsingPointCoords: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductIsRightTriangleUsingPointCoords.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductIsRightTriangleUsingPointCoords.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsRightTriangleUsingPointCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAYvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAiQF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAuB5E,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsRightTriangleUsingPointCoords.js

@@ -0,0 +1,235 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../../../math/geometry/point.js";
+import { Vector, VectorConstructor, } from "../../../../../../math/geometry/vector.js";
+import { randomVecs2 } from "../../../../../../math/utils/geometry/randomVecs2.js";
+import { randint } from "../../../../../../math/utils/random/randint.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 { coinFlip } from "../../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../../../utils/arrays/arrayZip.js";
+import { alignTex } from "../../../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { vecIdsU, vecIdsV, pointIds, pointNames } = identifiers;
+    // u = point2 - point1
+    const vecU = VectorConstructor.fromIdentifiers(vecIdsU);
+    // v = point3 - point1
+    const vecV = VectorConstructor.fromIdentifiers(vecIdsV);
+    //w = point3 - point2 = v - u
+    const vecW = (() => {
+        const vecVMinusU = vecV.substract(vecU);
+        return new Vector("w", vecVMinusU.x, vecVMinusU.y);
+    })();
+    const [nameP1, nameP2, nameP3] = pointNames;
+    const point1 = (() => {
+        const pointP = PointConstructor.fromIdentifiers(pointIds);
+        return new Point(nameP1, pointP.x, pointP.y);
+    })();
+    const point2 = vecU.getEndPoint(point1, nameP2);
+    const point3 = vecV.getEndPoint(point1, nameP3);
+    return {
+        vecU,
+        vecV,
+        vecW,
+        [point1.name]: point1,
+        [point2.name]: point2,
+        [point3.name]: point3,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { A, B, C } = getHydrated(identifiers);
+    return `Soient trois points : 
+  
+${[A, B, C].map((point) => `- $${point.toTexWithCoords()}$`).join(`
+  
+`)}
+  
+Le triangle $ABC$ est-il un triangle rectangle ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { vecU, vecV } = getHydrated(identifiers);
+    const nodesU = [vecU.x, vecU.y];
+    const nodesV = [vecV.x, vecV.y];
+    return zip(nodesU, nodesV)
+        .map(([nodeUX, nodeVX]) => multiply(nodeUX, nodeVX))
+        .reduce((acc, nodeX) => add(acc, nodeX));
+};
+const getAnswer = (identifiers) => {
+    const answerNode = getAnswerNode(identifiers);
+    const isOrthogonal = answerNode.simplify().evaluate() === 0;
+    return ["Oui", "Non"][isOrthogonal ? 0 : 1];
+};
+const getHint = () => {
+    const [a, b] = ["a", "b"].map((letter) => `\\overrightarrow{${letter}}`);
+    return `Deux vecteurs $${a}$ et $${b}$ sont orthogonaux si et seulement si $${a} \\cdot ${b} = 0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { pointNames } = identifiers;
+    const { vecU, vecV, vecW, A, B, C } = getHydrated(identifiers);
+    const pointsDict = { A, B, C };
+    function createVecComputation(pointStart, pointEnd) {
+        const nodeX = substract(pointEnd.x, pointStart.x);
+        const nodeY = substract(pointEnd.y, pointStart.y);
+        return new Vector(`${pointStart.name}${pointEnd.name}`, nodeX, nodeY);
+    }
+    const [point1, point2, point3] = pointNames.map((pointName) => pointsDict[pointName]);
+    const vecComputationU = createVecComputation(point1, point2);
+    const vecComputationV = createVecComputation(point1, point3);
+    const vecComputationW = createVecComputation(point2, point3);
+    const isOrthogonal = getAnswerNode(identifiers).simplify().evaluate() === 0;
+    return `On calcule les coordonnées des vecteurs :
+
+${zip([vecComputationU, vecComputationV, vecComputationW], [vecU, vecV, vecW]).map(([vecComputation, vec]) => `
+
+${alignTex([
+        [vecComputation.toTex(), "=", vecComputation.toCoords()],
+        ["", "=", vec.toCoords()],
+    ])}
+
+`).join(`
+    
+`)}
+  
+${(() => {
+        if (isOrthogonal) {
+            return `On remarque que : 
+
+${alignTex([
+                [
+                    `${vecComputationU.toTex()} \\cdot ${vecComputationV.toTex()}`,
+                    "=",
+                    `${vecU.scalarProduct(vecV).toTex()}`,
+                ],
+                ["", "=", "0"],
+            ])}
+  
+Les vecteurs $${vecComputationU.toTex()}$ et $${vecComputationV.toTex()}$ sont donc orthogonaux.
+Le triangle $ABC$ est rectangle en $${point1.name}$.`;
+        }
+        else {
+            const nodeScalarProductUV = vecU.scalarProduct(vecV);
+            const nodeScalarProductVW = vecV.scalarProduct(vecW);
+            const nodeScalarProductWU = vecW.scalarProduct(vecU);
+            return `On calcule les produits scalaires :
+
+${alignTex([
+                [
+                    `${vecComputationU.toTex()} \\cdot ${vecComputationV.toTex()}`,
+                    "=",
+                    `${nodeScalarProductUV.toTex()}`,
+                ],
+                ["", "=", `${nodeScalarProductUV.simplify().toTex()}`],
+            ])}
+
+${alignTex([
+                [
+                    `${vecComputationV.toTex()} \\cdot ${vecComputationW.toTex()}`,
+                    "=",
+                    `${nodeScalarProductVW.toTex()}`,
+                ],
+                ["", "=", `${nodeScalarProductVW.simplify().toTex()}`],
+            ])}
+
+${alignTex([
+                [
+                    `${vecComputationW.toTex()} \\cdot ${vecComputationU.toTex()}`,
+                    "=",
+                    `${nodeScalarProductWU.toTex()}`,
+                ],
+                ["", "=", `${nodeScalarProductWU.simplify().toTex()}`],
+            ])}
+  
+Tous les produits scalaires sont non-nuls.
+Le triangle $ABC$ n'est pas un triangle rectangle.`;
+        }
+    })()}`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const propositions = [];
+    const answerFromIdentifiers = getAnswer(identifiers);
+    ["Oui", "Non"].forEach((strProp) => {
+        if (strProp === answerFromIdentifiers) {
+            addValidProp(propositions, strProp, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, strProp, "raw");
+        }
+    });
+    return propositions;
+};
+const getScalarProductIsRightTriangleUsingPointCoordsQuestion = () => {
+    function createRandomVecs(isOrthogonal) {
+        if (isOrthogonal) {
+            return randomVecs2(isOrthogonal);
+        }
+        else {
+            //ensure there is no right angle elsewhere
+            let vecU;
+            let vecV;
+            let isValid = false;
+            let counter = -1;
+            while (!isValid && counter < 100) {
+                counter++;
+                const { vecU: vecUCandidate, vecV: vecVCandidate } = randomVecs2(isOrthogonal);
+                const vecWCandidate = vecVCandidate.substract(vecUCandidate);
+                isValid = vecWCandidate.scalarProduct(vecVCandidate).evaluate() !== 0;
+                if (isValid) {
+                    vecU = vecUCandidate;
+                    vecV = vecVCandidate;
+                }
+            }
+            if (!isValid) {
+                vecU = new Vector("u", (3).toTree(), (1).toTree());
+                vecV = new Vector("v", (2).toTree(), (-2).toTree());
+            }
+            return { vecU: vecU, vecV: vecV };
+        }
+    }
+    const isOrthogonal = coinFlip();
+    const { vecU, vecV } = createRandomVecs(isOrthogonal);
+    const x = Math.ceil(-Math.max(vecU.x.evaluate(), vecV.x.evaluate()) / 2) +
+        randint(0, 3);
+    const y = Math.ceil(-Math.max(vecU.y.evaluate(), vecV.y.evaluate()) / 2) +
+        randint(0, 3);
+    const pointP = new Point("P", x, y);
+    const pointNames = shuffle(["A", "B", "C"]);
+    const identifiers = {
+        vecIdsU: vecU.toIdentifiers(),
+        vecIdsV: vecV.toIdentifiers(),
+        pointIds: pointP.toIdentifiers(),
+        pointNames,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+};
+export const scalarProductIsRightTriangleUsingPointCoords = {
+    id: "scalarProductIsRightTriangleUsingPointCoords",
+    connector: "=",
+    label: "Déterminer si un triangle est rectangle à partir des coordonnées de ses sommets",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getScalarProductIsRightTriangleUsingPointCoordsQuestion(), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductComputeBH.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductComputeBH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAoBtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AA+bF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AA+BF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA6BjE,CAAC"}