math-exercises 3.0.158 → 3.0.159

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

@@ -0,0 +1,202 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { randomVecs2 } from "../../../../../../math/utils/geometry/randomVecs2.js";
+import { NodeConstructor, } from "../../../../../../tree/nodes/nodeConstructor.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 { zip } from "../../../../../../utils/arrays/arrayZip.js";
+import { alignTex } from "../../../../../../utils/latex/alignTex.js";
+const getHydratedNodes = (identifiers) => {
+    const { nodeIdsU, nodeIdsV } = identifiers;
+    return {
+        nodesU: nodeIdsU.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)),
+        nodesV: nodeIdsV.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodesU, nodesV } = getHydratedNodes(identifiers);
+    const [i, j, u, v] = ["i", "j", "u", "v"].map((letter) => `\\overrightarrow{${letter}}`);
+    const [texUI, texVI] = [nodesU[0], nodesV[0]].map((node) => {
+        const v = node.evaluate();
+        if (v === -1) {
+            return "-";
+        }
+        else if (v === 1) {
+            return "";
+        }
+        else {
+            return node.toTex();
+        }
+    });
+    const [texUJ, texVJ] = [nodesU[1], nodesV[1]].map((node) => {
+        const v = node.evaluate();
+        if (v >= 0) {
+            return v === 1 ? "+" : `+ ${node.toTex()}`;
+        }
+        else {
+            return v === -1 ? "-" : node.toTex();
+        }
+    });
+    return `Soient $${i}$ et $${j}$ deux vecteurs formant une base orthonormale du plan.
+  
+Soient $${u}$ et $${v}$ deux vecteurs tels que : 
+  
+$$
+${u} = ${texUI}${i} ${texUJ}${j} 
+$$
+
+$$
+${v} = ${texVI}${i} ${texVJ}${j} 
+$$
+  
+Les vecteurs $u$ et $v$ sont-ils orthogonaux ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodesU, nodesV } = getHydratedNodes(identifiers);
+    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 [i, j] = ["i", "j"].map((letter) => `\\overrightarrow{${letter}}`);
+    return `Les vecteurs $${i}$ et $${j}$ forment une base orthonormale.
+  
+Autrement dit : 
+
+$$
+${i} \\cdot ${i} = ${j} \\cdot ${j} = 1
+$$
+
+et
+
+$$
+${i} \\cdot ${j} = 0
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodesU, nodesV } = getHydratedNodes(identifiers);
+    const [i, j, u, v] = ["i", "j", "u", "v"].map((letter) => `\\overrightarrow{${letter}}`);
+    const [texUI, texVI] = [nodesU[0], nodesV[0]].map((node) => {
+        const v = node.evaluate();
+        if (v === -1) {
+            return "-";
+        }
+        else if (v === 1) {
+            return "";
+        }
+        else {
+            return node.toTex();
+        }
+    });
+    const [texUJ, texVJ] = [nodesU[1], nodesV[1]].map((node) => {
+        const v = node.evaluate();
+        if (v >= 0) {
+            return v === 1 ? "+" : `+ ${node.toTex()}`;
+        }
+        else {
+            return v === -1 ? "-" : node.toTex();
+        }
+    });
+    const isOrthogonal = getAnswerNode(identifiers).simplify().evaluate() === 0;
+    return `On développe : 
+
+${alignTex([
+        ["", `${u} \\cdot ${v}`],
+        ["=", `(${texUI}${i} ${texUJ}${j}) \\cdot (${texVI}${i} ${texVJ}${j})`],
+        [
+            "=",
+            `(${multiply(nodesU[0], nodesV[0]).toTex()})(${i} \\cdot ${i}) + (${multiply(nodesU[1], nodesV[1]).toTex()})(${j} \\cdot ${j}) + 0`,
+        ],
+    ])}
+
+On s'est épargné le calcul des autres produits car 
+
+$$
+${i} \\cdot ${j} = ${j} \\cdot ${i} = 0
+$$
+
+On peut donc calculer le produit scalaire en utilisant les coordonnées dans la base $(${i},${j})$ de la même manière que lorsque l'on travaille dans la base canonique du plan. 
+
+${alignTex([
+        ["", `${u} \\cdot ${v}`],
+        [
+            "=",
+            `${getAnswerNode(identifiers).toTex({
+                forceTimesSign: true,
+                forceNoSimplification: true,
+            })}`,
+        ],
+        ["=", `${getAnswerNode(identifiers).simplify().toTex()}`],
+    ])}
+
+${(() => {
+        if (isOrthogonal) {
+            return `Le produit scalaire $${u} \\cdot ${v}$ est nul, les vecteurs $${u}$ et $${v}$ sont donc orthogonaux.`;
+        }
+        else {
+            return `Le produit scalaire $${u} \\cdot ${v}$ n'est pas nul, les vecteurs $${u}$ et $${v}$ ne sont donc pas orthogonaux.`;
+        }
+    })()}`;
+};
+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 getScalarProductIsOrthogonalVecsBasisIJQuestion = () => {
+    const isOrthogonal = coinFlip();
+    const { vecU, vecV } = randomVecs2(isOrthogonal);
+    const nodesU = [vecU.x, vecU.y];
+    const nodesV = [vecV.x, vecV.y];
+    const identifiers = {
+        nodeIdsU: nodesU.map((node) => node.toIdentifiers()),
+        nodeIdsV: nodesV.map((node) => node.toIdentifiers()),
+    };
+    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 scalarProductIsOrthogonalVecsBasisIJ = {
+    id: "scalarProductIsOrthogonalVecsBasisIJ",
+    connector: "=",
+    label: "Déterminer si deux vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ exprimés dans une base orthonormée $(\\overrightarrow{i},\\overrightarrow{j})$ sont orthogonaux",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getScalarProductIsOrthogonalVecsBasisIJQuestion(), 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/scalarProductIsOrthogonalVecsUsingCoords.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../../../exercises/exercise.js";
+import { VectorIdentifiers } from "../../../../../../math/geometry/vector.js";
+type Identifiers = {
+    vecIdsU: VectorIdentifiers;
+    vecIdsV: VectorIdentifiers;
+};
+export declare const scalarProductIsOrthogonalVecsUsingCoords: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductIsOrthogonalVecsUsingCoords.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductIsOrthogonalVecsUsingCoords.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsOrthogonalVecsUsingCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AASvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;CAC5B,CAAC;AAgIF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAqB1E,CAAC"}

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

@@ -0,0 +1,127 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { VectorConstructor, } from "../../../../../../math/geometry/vector.js";
+import { randomVecs2 } from "../../../../../../math/utils/geometry/randomVecs2.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 { zip } from "../../../../../../utils/arrays/arrayZip.js";
+import { alignTex } from "../../../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { vecIdsU, vecIdsV } = identifiers;
+    return {
+        vecU: VectorConstructor.fromIdentifiers(vecIdsU),
+        vecV: VectorConstructor.fromIdentifiers(vecIdsV),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { vecU, vecV } = getHydrated(identifiers);
+    const [u, v] = [vecU, vecV].map((vec) => vec.toTex());
+    return `Soient $${vecU.toTex()}$ et $${vecV.toTex()}$ deux vecteurs tels que : 
+  
+$$
+${u} = ${vecU.toCoords()}
+$$
+
+$$
+${v} = ${vecV.toCoords()}
+$$
+  
+Les vecteurs $u$ et $v$ sont-ils orthogonaux ?`;
+};
+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 { vecU, vecV } = getHydrated(identifiers);
+    const [u, v] = [vecU, vecV].map((vec) => vec.toTex());
+    const nodesU = [vecU.x, vecU.y];
+    const nodesV = [vecV.x, vecV.y];
+    const isOrthogonal = getAnswerNode(identifiers).simplify().evaluate() === 0;
+    return `On calcule le produit scalaire : 
+
+${alignTex([
+        ["", `${u} \\cdot ${v}`],
+        ["=", `${vecU.toCoords()} \\cdot ${vecV.toCoords()}`],
+        [
+            "=",
+            `(${multiply(nodesU[0], nodesV[0]).toTex()}) + (${multiply(nodesU[1], nodesV[1]).toTex()})`,
+        ],
+        ["=", `${getAnswerNode(identifiers).simplify().toTex()}`],
+    ])}
+
+${(() => {
+        if (isOrthogonal) {
+            return `Le produit scalaire $${u} \\cdot ${v}$ est nul, les vecteurs $${u}$ et $${v}$ sont donc orthogonaux.`;
+        }
+        else {
+            return `Le produit scalaire $${u} \\cdot ${v}$ n'est pas nul, les vecteurs $${u}$ et $${v}$ ne sont donc pas orthogonaux.`;
+        }
+    })()}`;
+};
+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 getScalarProductIsOrthogonalVecsUsingCoordsQuestion = () => {
+    const isOrthogonal = coinFlip();
+    const { vecU, vecV } = randomVecs2(isOrthogonal);
+    const identifiers = {
+        vecIdsU: vecU.toIdentifiers(),
+        vecIdsV: vecV.toIdentifiers(),
+    };
+    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 scalarProductIsOrthogonalVecsUsingCoords = {
+    id: "scalarProductIsOrthogonalVecsUsingCoords",
+    connector: "=",
+    label: "Déterminer si deux vecteurs de coordonnées données sont orthogonaux",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getScalarProductIsOrthogonalVecsUsingCoordsQuestion(), 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/scalarProductIsPointOnCircle.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 scalarProductIsPointOnCircle: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductIsPointOnCircle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductIsPointOnCircle.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnCircle.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;AA8LF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAmB9D,CAAC"}

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

@@ -0,0 +1,167 @@
+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;
+    const vecU = VectorConstructor.fromIdentifiers(vecIdsU);
+    const vecV = VectorConstructor.fromIdentifiers(vecIdsV);
+    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,
+        [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[0]}$ appartient-il au cercle $\\mathcal{C}$ de diamètre $[${pointNames[1]}${pointNames[2]}]$ ?`;
+};
+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, A, B, C } = getHydrated(identifiers);
+    const pointsDict = { A, B, C };
+    const [point1, point2, point3] = pointNames.map((pointName) => pointsDict[pointName]);
+    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 vecComputationU = createVecComputation(point1, point2);
+    const vecComputationV = createVecComputation(point1, point3);
+    const isOrthogonal = getAnswerNode(identifiers).simplify().evaluate() === 0;
+    const nodeScalarProduct = vecU.scalarProduct(vecV);
+    return `On calcule les coordonnées des vecteurs :
+
+${zip([vecComputationU, vecComputationV], [vecU, vecV]).map(([vecComputation, vec]) => `
+
+${alignTex([
+        [vecComputation.toTex(), "=", vecComputation.toCoords()],
+        ["", "=", vec.toCoords()],
+    ])}
+
+`).join(`
+    
+`)}
+
+${alignTex([
+        [
+            `${vecComputationU.toTex()} \\cdot ${vecComputationV.toTex()}`,
+            "=",
+            `${nodeScalarProduct.toTex()}`,
+        ],
+        ["", "=", `${nodeScalarProduct.simplify().toTex()}`],
+    ])}
+  
+${(() => {
+        if (isOrthogonal) {
+            return `Les vecteurs $${vecComputationU.toTex()}$ et $${vecComputationV.toTex()}$ sont donc orthogonaux.
+Le point $${point1.name}$ appartient donc au cercle de diamètre $[${point2.name}${point3.name}]$.`;
+        }
+        else {
+            return `Les vecteurs $${vecComputationU.toTex()}$ et $${vecComputationV.toTex()}$ ne sont donc pas orthogonaux.
+Le point $${point1.name}$ n'appartient donc pas au cercle de diamètre $[${point2.name}${point3.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 getScalarProductIsPointOnCircleQuestion = () => {
+    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 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 scalarProductIsPointOnCircle = {
+    id: "scalarProductIsPointOnCircle",
+    connector: "=",
+    label: "Déterminer si un point appartient ou non à un cercle de diamètre donné",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getScalarProductIsPointOnCircleQuestion(), 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/scalarProductIsPointOnPerpendicularBisector.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 scalarProductIsPointOnPerpendicularBisector: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductIsPointOnPerpendicularBisector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductIsPointOnPerpendicularBisector.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/orth/scalarProductIsPointOnPerpendicularBisector.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;AAavC,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;AAmNF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAAC,WAAW,CAsB3E,CAAC"}