math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/spaceGeometry/planes/checkIsPointBelongingToPlane.js

@@ -0,0 +1,208 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector } from "../../../../math/geometry/spaceVector.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const [nodeVarX, nodeVarY, nodeVarZ] = ["x", "y", "z"].map((name) => new VariableNode(name));
+const createPlaneEquationFromNormalVectorAndContainedPoint = (vec, spacePoint) => {
+    const [nodeA, nodeB, nodeC] = [vec.x, vec.y, vec.z];
+    const nodeD = opposite(add(multiply(nodeA, spacePoint.x), add(multiply(nodeB, spacePoint.y), multiply(nodeC, spacePoint.z))));
+    const nodeLhs = add(add(multiply(nodeA, nodeVarX), add(multiply(nodeB, nodeVarY), multiply(nodeC, nodeVarZ))), nodeD).simplify({ towardsDistribute: true });
+    return new EqualNode(nodeLhs, (0).toTree());
+};
+const getHydrated = (identifiers) => {
+    const { spacePointIds, nodeIdsPlaneEquation } = identifiers;
+    const A = SpacePointConstructor.fromIdentifiers(spacePointIds);
+    const nodePlaneEquation = NodeConstructor.fromIdentifiers(nodeIdsPlaneEquation);
+    const nodePlaneEquationLhs = nodePlaneEquation.leftChild;
+    const nodeCheck = (() => {
+        const [nodeX, nodeY, nodeZ] = [A.x, A.y, A.z];
+        return [
+            [nodeX, nodeVarX],
+            [nodeY, nodeVarY],
+            [nodeZ, nodeVarZ],
+        ].reduce((acc, [node, nodeVar]) => {
+            return nodeBySubstitutingVar(acc, node, nodeVar);
+        }, nodePlaneEquationLhs);
+    })();
+    return {
+        A,
+        nodePlaneEquation,
+        nodeCheck,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodePlaneEquation, A } = getHydrated(identifiers);
+    return `Soit $A$ le point de coordonnées $${A.toCoords()}$.
+
+Soit $P$ le plan d'équation $${nodePlaneEquation.toTex()}$. 
+
+Le point $A$ appartient-il au plan $P$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeCheck } = getHydrated(identifiers);
+    const isPlaneContainingPoint = NodeComparator.isEqualViaSub(nodeCheck, (0).toTree());
+    return isPlaneContainingPoint ? "Oui" : "Non";
+};
+const getHint = () => {
+    const P = new SpacePoint("P", new VariableNode("p_{x}"), new VariableNode("p_{y}"), new VariableNode("p_{z}"));
+    const [nodeA, nodeB, nodeC, nodeD] = ["a", "b", "c", "d"].map((letter) => new VariableNode(letter));
+    const nodePlaneEquationLhs = add(add(multiply(nodeA, nodeVarX), add(multiply(nodeB, nodeVarY), multiply(nodeC, nodeVarZ))), nodeD).simplify({ towardsDistribute: true });
+    const nodePlaneEquation = new EqualNode(nodePlaneEquationLhs, (0).toTree());
+    const nodeCheck = (() => {
+        const [nodeX, nodeY, nodeZ] = [P.x, P.y, P.z];
+        return [
+            [nodeX, nodeVarX],
+            [nodeY, nodeVarY],
+            [nodeZ, nodeVarZ],
+        ].reduce((acc, [node, nodeVar]) => {
+            return nodeBySubstitutingVar(acc, node, nodeVar);
+        }, nodePlaneEquationLhs);
+    })();
+    return `Le point $P$ de coordonnées $${P.toCoords()}$ appartient au plan d'équation $${nodePlaneEquation.toTex()}$ si et seulement si ses coordonnées satisfont l'équation du plan, autrement dit si et seulement si 
+
+$$
+${nodeCheck.toTex()} = 0
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { A, nodeCheck } = getHydrated(identifiers);
+    const isPlaneContainingPoint = NodeComparator.isEqualViaSub(nodeCheck, (0).toTree());
+    return `Pour vérifier si $A$ appartient à $P$, au membre de gauche de l'équation de $P$, on substitue $${A.x.toTex()}$ à $x$, on substitue $${A.y.toTex()}$ à $y$, et on substitue $${A.z.toTex()}$ à $z$
+et on calcule sa valeur.
+  
+${alignTex([
+        ["", nodeCheck.toTex()],
+        ["=", nodeCheck.simplify({ towardsDistribute: true }).toTex()],
+        !isPlaneContainingPoint ? ["\\neq", "0"] : [],
+    ])}
+
+${(() => {
+        if (isPlaneContainingPoint) {
+            return `Les coordonnées du point $A$ satisfont l'équation du plan $P$ donc $A$ appartient à $P$.`;
+        }
+        else {
+            return `Les coordonnées du point $A$ ne satisfont pas l'équation du plan $P$ donc $A$ n'appartient pas à $P$.`;
+        }
+    })()}`;
+};
+const getPropositions = (_n, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non", "On ne peut pas savoir"].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const createRandomIdentifiers = () => {
+    const funcRand1 = () => randint(-3, 4, coinFlip() ? [0] : []).toTree();
+    const funcRand2 = () => randint(-6, 7, coinFlip() ? [0] : []).toTree();
+    const funcRand3 = () => randint(-9, 10, coinFlip() ? [0] : []).toTree();
+    function createRandomOrthogonalVector(vecSrc) {
+        const [nodeX, nodeY, nodeZ] = [vecSrc.x, vecSrc.y, vecSrc.z];
+        const nodeZero = (0).toTree();
+        const vec1 = new SpaceVector("v1", opposite(nodeY), nodeX, nodeZero);
+        const vec2 = new SpaceVector("v2", nodeZero, opposite(nodeZ), nodeY);
+        const vec3 = new SpaceVector("v3", opposite(nodeZ), nodeZero, nodeX);
+        const [factor1, factor2, factor3] = shuffle(random([
+            [coinFlip(), false, false],
+            [coinFlip(), coinFlip(), false],
+        ])).map((isCanBeZero) => randint(-3, 4, isCanBeZero ? [] : [0]).toTree());
+        return vec1
+            .times(factor1)
+            .add(vec2.times(factor2))
+            .add(vec3.times(factor3));
+    }
+    //create vecR, vecS, vecT (base)
+    const vecR = (() => {
+        const [funcRandX, funcRandY, funcRandZ] = shuffle([
+            funcRand1,
+            funcRand2,
+            funcRand3,
+        ]);
+        return new SpaceVector("r", funcRandX(), funcRandY(), funcRandZ());
+    })();
+    const vecS = (() => {
+        const vecRaw = createRandomOrthogonalVector(vecR);
+        return new SpaceVector("s", vecRaw.x, vecRaw.y, vecRaw.z);
+    })();
+    const [vecU, vecV] = (() => {
+        const [vecURaw, vecVRaw] = shuffle([vecR, vecS]);
+        const vecU = new SpaceVector("u", vecURaw.x, vecURaw.y, vecURaw.z);
+        const nodeFactor = randint(-2, 3, [0]).toTree();
+        const vecVRawRescaled = vecVRaw.times(nodeFactor);
+        const vecV = new SpaceVector("v", vecVRawRescaled.x, vecVRawRescaled.y, vecVRawRescaled.z);
+        return [vecU, vecV];
+    })();
+    const vecT = vecU.vetorialProduct(vecV);
+    //create O (Plane origin)
+    const O = new SpacePoint("O", randint(-7, 8).toTree(), randint(-7, 8).toTree(), randint(-7, 8).toTree());
+    const nodePlaneEquation = createPlaneEquationFromNormalVectorAndContainedPoint(vecR, O);
+    const isPlaneContainingPoint = coinFlip();
+    const A = (() => {
+        const [factor1, factor2, factor3] = [
+            isPlaneContainingPoint ? (0).toTree() : randint(-2, 3).toTree(),
+            ...shuffle([coinFlip(), false]).map((isCanBeZero) => randint(-2, 3, isCanBeZero ? [] : [0]).toTree()),
+        ];
+        const vecWRaw = vecR
+            .times(factor1)
+            .add(vecS.times(factor2))
+            .add(vecT.times(factor3));
+        const vecW = new SpaceVector("w", vecWRaw.x, vecWRaw.y, vecWRaw.z);
+        const spacePointRaw = vecW.getEndPoint(O);
+        return new SpacePoint("A", spacePointRaw.x, spacePointRaw.y, spacePointRaw.z);
+    })();
+    const identifiers = {
+        spacePointIds: A.toIdentifiers(),
+        nodeIdsPlaneEquation: nodePlaneEquation.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getCheckIsPointBelongingToPlaneQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, _opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const checkIsPointBelongingToPlane = {
+    id: "checkIsPointBelongingToPlane",
+    label: "Vérifier si un point appartient ou non à un plan",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCheckIsPointBelongingToPlaneQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/spaceGeometry/planes/findNormalVectorFromPlaneEquation.d.ts

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

package/lib/exercises/math/spaceGeometry/planes/findNormalVectorFromPlaneEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findNormalVectorFromPlaneEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/findNormalVectorFromPlaneEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAsF7C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AA+QF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAmBnE,CAAC"}

package/lib/exercises/math/spaceGeometry/planes/findNormalVectorFromPlaneEquation.js

@@ -0,0 +1,255 @@
+import { addValidProp, tryToAddWrongProp, propWhile, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SpacePoint } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector } from "../../../../math/geometry/spaceVector.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const [nodeVarX, nodeVarY, nodeVarZ] = ["x", "y", "z"].map((name) => new VariableNode(name));
+const createPlaneEquationFromNormalVectorAndContainedPoint = (vec, spacePoint) => {
+    const [nodeA, nodeB, nodeC] = [vec.x, vec.y, vec.z];
+    const nodeD = opposite(add(multiply(nodeA, spacePoint.x), add(multiply(nodeB, spacePoint.y), multiply(nodeC, spacePoint.z))));
+    const nodeLhs = add(add(multiply(nodeA, nodeVarX), add(multiply(nodeB, nodeVarY), multiply(nodeC, nodeVarZ))), nodeD).simplify({ towardsDistribute: true });
+    return new EqualNode(nodeLhs, (0).toTree());
+};
+const getCoeffsCorrespondingToPlaneEquation = (nodePlaneEquation) => {
+    const [nodeZero, nodeOne] = [0, 1].map((v) => v.toTree());
+    const nodePlaneEquationLhs = nodePlaneEquation.leftChild;
+    const nodeD = [
+        [nodeZero, nodeVarX],
+        [nodeZero, nodeVarY],
+        [nodeZero, nodeVarZ],
+    ]
+        .reduce((acc, [node, nodeVar]) => {
+        return nodeBySubstitutingVar(acc, node, nodeVar);
+    }, nodePlaneEquationLhs)
+        .simplify({ towardsDistribute: true, forbidFactorize: true });
+    const [nodeA, nodeB, nodeC] = [
+        [nodeOne, nodeZero, nodeZero],
+        [nodeZero, nodeOne, nodeZero],
+        [nodeZero, nodeZero, nodeOne],
+    ].map(([nodeX, nodeY, nodeZ]) => substract([
+        [nodeX, nodeVarX],
+        [nodeY, nodeVarY],
+        [nodeZ, nodeVarZ],
+    ]
+        .reduce((acc, [node, nodeVar]) => nodeBySubstitutingVar(acc, node, nodeVar), nodePlaneEquationLhs)
+        .simplify({ towardsDistribute: true, forbidFactorize: true }), nodeD).simplify({ towardsDistribute: true, forbidFactorize: true }));
+    return [nodeA, nodeB, nodeC, nodeD];
+};
+const _getNormalVectorCorrespondingToPlaneOfEquation = (nodePlaneEquation) => {
+    const [nodeA, nodeB, nodeC] = getCoeffsCorrespondingToPlaneEquation(nodePlaneEquation);
+    return new SpaceVector("n", nodeA, nodeB, nodeC);
+};
+const getHydrated = (identifiers) => {
+    const { nodeIdsPlaneEquation } = identifiers;
+    const nodePlaneEquation = NodeConstructor.fromIdentifiers(nodeIdsPlaneEquation);
+    const [nodeA, nodeB, nodeC, nodeD] = getCoeffsCorrespondingToPlaneEquation(nodePlaneEquation);
+    const vecNormal = new SpaceVector("n", nodeA, nodeB, nodeC);
+    return {
+        nodePlaneEquation,
+        vecNormal,
+        nodeA,
+        nodeB,
+        nodeC,
+        nodeD,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsPlaneEquation } = identifiers;
+    const nodePlaneEquation = NodeConstructor.fromIdentifiers(nodeIdsPlaneEquation);
+    return `Soit le plan $\\mathcal{P}$ d'équation 
+
+$$
+(\\mathcal{P}): ${nodePlaneEquation.toTex()}
+$$
+
+Donner les coordonnées en ligne d'un vecteur normal à $\\mathcal{P}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { vecNormal } = getHydrated(identifiers);
+    return vecNormal.toInlineCoordsTex();
+};
+const getHint = () => {
+    const [nodeA, nodeB, nodeC, nodeD] = ["a", "b", "c", "d"].map((letter) => new VariableNode(letter));
+    const nodePlaneEquationLhs = add(add(multiply(nodeA, nodeVarX), add(multiply(nodeB, nodeVarY), multiply(nodeC, nodeVarZ))), nodeD).simplify({ towardsDistribute: true });
+    const nodePlaneEquation = new EqualNode(nodePlaneEquationLhs, (0).toTree());
+    const vecNormal = new SpaceVector("v", nodeA, nodeB, nodeC);
+    return `Le plan d'équation : 
+  
+$$
+${nodePlaneEquation.toTex()}
+$$
+
+admet pour vecteur normal le vecteur de coordonnées $${vecNormal.toInlineCoordsTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { vecNormal, nodePlaneEquation } = getHydrated(identifiers);
+    return `Dans l'équation :
+
+$$
+${nodePlaneEquation.toTex()}
+$$
+
+le coefficient devant $x$ est $${vecNormal.x.toTex()}$,
+le coefficient devant $y$ est $${vecNormal.y.toTex()}$,
+le coefficient devant $z$ est $${vecNormal.z.toTex()}$.
+
+Un vecteur normal à $\\mathcal{P}$ est donc $${vecNormal.toInlineCoordsTex()}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { vecNormal, nodeA, nodeB, nodeC, nodeD } = getHydrated(identifiers);
+    const nodeFactor = randint(-4, 5, [0, 1]).toTree();
+    //la bonne réponse
+    {
+        const vecNormalRefined = coinFlip()
+            ? vecNormal
+            : vecNormal.times(nodeFactor);
+        addValidProp(propositions, vecNormalRefined.toInlineCoordsTex());
+    }
+    const isWrongVector = (vec) => vec
+        .vetorialProduct(vecNormal)
+        .getEvaluatedCoords()
+        .some((v) => v !== 0);
+    {
+        const [nodeAW, nodeBW, nodeCW, nodeDW] = [nodeA, nodeB, nodeC, nodeD].map((node) => multiply(nodeFactor, node).simplify({ towardsDistribute: true }));
+        //student: shuffle
+        {
+            const vecNormalWrong = new SpaceVector("n", nodeCW, nodeBW, nodeAW);
+            if (isWrongVector(vecNormalWrong)) {
+                tryToAddWrongProp(propositions, vecNormalWrong.toInlineCoordsTex());
+            }
+        }
+        //student: (b,c,d) instead of (a,b,c)
+        {
+            const vecNormalWrong = new SpaceVector("n", nodeBW, nodeCW, nodeDW);
+            if (isWrongVector(vecNormalWrong)) {
+                tryToAddWrongProp(propositions, vecNormalWrong.toInlineCoordsTex());
+            }
+        }
+    }
+    propWhile(propositions, n, () => {
+        const nodeFactorW = randint(-4, 5, [0, 1]).toTree();
+        const arr = [nodeA, nodeB, nodeC, nodeD].map((node) => multiply(nodeFactorW, node).simplify({ towardsDistribute: true }));
+        {
+            const [nodeA, nodeB, nodeC, nodeD] = arr;
+            //student: shuffle
+            {
+                const vecNormalWrong = new SpaceVector("n", nodeC, nodeB, nodeA);
+                if (isWrongVector(vecNormalWrong)) {
+                    tryToAddWrongProp(propositions, vecNormalWrong.toInlineCoordsTex());
+                }
+            }
+            //student: (b,c,d) instead of (a,b,c)
+            {
+                const vecNormalWrong = new SpaceVector("n", nodeB, nodeC, nodeD);
+                if (isWrongVector(vecNormalWrong)) {
+                    tryToAddWrongProp(propositions, vecNormalWrong.toInlineCoordsTex());
+                }
+            }
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["semicolon", "x", "y", "z"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { vecNormal } = getHydrated(identifiers);
+    function matchGroups(regex, input) {
+        const match = regex.exec(input);
+        return match?.groups || undefined;
+    }
+    try {
+        const arrNodeAns = (() => {
+            const arrKey = [...Array(3).keys()]
+                .map((i) => i + 1)
+                .map((v) => `str${v}`);
+            //TODO: input is column of coords
+            // const strRegex = `^\\\\begin\\{pmatrix\\}\\(${arrKey
+            //   .map((strKey) => `(?<${strKey}>.*(?!\\w$))`)
+            //   .join("\\\\\\w")}\\\\end\\{pmatrix\\}\\)$`;
+            const strRegex = `^\\\\left\\(${arrKey
+                .map((strKey) => `(?<${strKey}>.*(?!;$))`)
+                .join(";")}\\\\right\\)$`;
+            const regex = new RegExp(strRegex);
+            const ansParts = matchGroups(regex, ans);
+            if (ansParts === undefined) {
+                throw new Error("Parsing error: ans is not a tuple");
+            }
+            const arrNode = Object.entries(ansParts).map(([_key, str]) => parseAlgebraic(str));
+            return arrNode;
+        })();
+        const vecAns = new SpaceVector("ans", ...arrNodeAns);
+        return vecNormal
+            .vetorialProduct(vecAns)
+            .getEvaluatedCoords()
+            .every((v) => v === 0);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const funcRand1 = () => randint(-3, 4, coinFlip() ? [0] : []).toTree();
+    const funcRand2 = () => randint(-6, 7, coinFlip() ? [0] : []).toTree();
+    const funcRand3 = () => randint(-9, 10, coinFlip() ? [0] : []).toTree();
+    const vecNormal = (() => {
+        const [funcRandX, funcRandY, funcRandZ] = shuffle([
+            funcRand1,
+            funcRand2,
+            funcRand3,
+        ]);
+        return new SpaceVector(random("rstuvw".split("")), funcRandX(), funcRandY(), funcRandZ());
+    })();
+    //contained point
+    const spacePointContained = new SpacePoint(random("ABCD".split("")), randint(-7, 8).toTree(), randint(-7, 8).toTree(), randint(-7, 8).toTree());
+    const nodePlaneEquation = createPlaneEquationFromNormalVectorAndContainedPoint(vecNormal, spacePointContained);
+    const identifiers = {
+        nodeIdsPlaneEquation: nodePlaneEquation.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getFindNormalVectorFromPlaneEquationQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, _opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findNormalVectorFromPlaneEquation = {
+    id: "findNormalVectorFromPlaneEquation",
+    label: "Connaissant une équation cartésienne de plan, donner un vecteur normal",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindNormalVectorFromPlaneEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/spaceGeometry/planes/findNormalVectorFromPlanePointsCoords.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVectorIdentifiers } from "../../../../math/geometry/spaceVector.js";
+type Identifiers = {
+    spacePointIdsPlanePoints: SpacePointIdentifiers[];
+    spaceVectorIdsProposed: SpaceVectorIdentifiers[];
+};
+export declare const findNormalVectorFromPlanePointsCoords: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findNormalVectorFromPlanePointsCoords.d.ts.map

package/lib/exercises/math/spaceGeometry/planes/findNormalVectorFromPlanePointsCoords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findNormalVectorFromPlanePointsCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/findNormalVectorFromPlanePointsCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAsE5C,KAAK,WAAW,GAAG;IACjB,wBAAwB,EAAE,qBAAqB,EAAE,CAAC;IAClD,sBAAsB,EAAE,sBAAsB,EAAE,CAAC;CAClD,CAAC;AAkRF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAmBvE,CAAC"}