math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/spaceGeometry/parametricLine/lineLineRelativePositionsFromParametricLines.js

@@ -0,0 +1,325 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { ParametricLine } from "../../../../math/geometry/parametricLine.js";
+import { SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVectorConstructor, } from "../../../../math/geometry/spaceVector.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+const texForSystem = (spacePointLhs, parametricLineRhs) => {
+    return `\\left\\{\\begin{matrix}
+${spacePointLhs.x.toTex()}=${parametricLineRhs.equations[0].toTex()} \\\\
+${spacePointLhs.y.toTex()}=${parametricLineRhs.equations[1].toTex()} \\\\
+${spacePointLhs.z.toTex()}=${parametricLineRhs.equations[2].toTex()} 
+\\end{matrix}
+\\right.`;
+};
+const findNodeParameterForSpacePointOnParametricLine = (spacePoint, parametricLine, varNameOfParameter) => {
+    if (!parametricLine.hasPoint(spacePoint)) {
+        return undefined;
+    }
+    else {
+        const [nodeRhs, index] = parametricLine.equations
+            .map((node, i) => [node, i])
+            .find(([node]) => node.toTex().includes(varNameOfParameter));
+        const [_varNamePointWise, nodePointCoord] = zip(["x", "y", "z"], [spacePoint.x, spacePoint.y, spacePoint.z])[index];
+        const nodeA = nodeRhs
+            .derivative(varNameOfParameter)
+            .simplify({ towardsDistribute: true });
+        const nodeB = nodeBySubstitutingVar(nodeRhs, (0).toTree(), new VariableNode(varNameOfParameter)).simplify({ towardsDistribute: true });
+        //xOrYOrZ=at+b <=> t = (xOrYOrZ-b)/a
+        return frac(substract(nodePointCoord, nodeB), nodeA);
+    }
+};
+const isSpacePointIntersectionOfParametricLines = (spacePoint, parametricLine1, parametricLine2) => {
+    return (parametricLine1.hasPoint(spacePoint) && parametricLine2.hasPoint(spacePoint));
+};
+const createMyPropositions = (identifiers) => {
+    const { A, B, parametricLine1, parametricLine2 } = getHydrated(identifiers);
+    const propositions = [];
+    let isValidAlreadyGiven = false;
+    //intersection is point
+    [A, B].forEach((spacePoint) => {
+        const str = `Le point d'intersection de $d_{1}$ et $d_{2}$ est $${spacePoint.toTexWithCoords()}$.`;
+        if (isSpacePointIntersectionOfParametricLines(spacePoint, parametricLine1, parametricLine2)) {
+            addValidProp(propositions, str, "raw");
+            isValidAlreadyGiven = true;
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    //lines are parallel
+    {
+        const str = `$d_{1}$ et $d_{2}$ sont parallèles.`;
+        if (parametricLine1.vector.isColinear(parametricLine2.vector)) {
+            addValidProp(propositions, str, "raw");
+            isValidAlreadyGiven = true;
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    }
+    //lines are non-coplanar
+    {
+        const str = `$d_{1}$ et $d_{2}$ sont non coplanaires.`;
+        if (!isValidAlreadyGiven) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    }
+    return propositions;
+};
+const getHydrated = (identifiers) => {
+    const { spacePointIdsAB, spaceLineIds } = identifiers;
+    const [A, B] = spacePointIdsAB.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const [parametricLine1, parametricLine2] = zip(["t", "t'"], spaceLineIds).map(([varName, { spacePointIds, spaceVectorIds }]) => {
+        const spacePoint = SpacePointConstructor.fromIdentifiers(spacePointIds);
+        const spaceVector = SpaceVectorConstructor.fromIdentifiers(spaceVectorIds);
+        return new ParametricLine(spacePoint, spaceVector, varName);
+    });
+    return {
+        A,
+        B,
+        parametricLine1,
+        parametricLine2,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { parametricLine1, parametricLine2 } = getHydrated(identifiers);
+    return `Soient $d_{1}$ et $d_{2}$ deux droites telles que : 
+  
+$$
+(d_{1}): ${parametricLine1.toTex()} \\ (t \\in \\mathbb{R})
+$$
+
+$$
+(d_{2}): ${parametricLine2.toTex()} \\ (t' \\in \\mathbb{R})
+$$
+
+Parmi les propositions ci-dessous, déterminer celle qui est vraie.`;
+};
+const getAnswer = (identifiers) => {
+    return createMyPropositions(identifiers).find((proposition) => proposition.isRightAnswer).statement;
+};
+const getHint = () => {
+    return `Deux droites coplanaires sont soit sécantes soit parallèles. Autrement dit, deux droites non coplanaires ne sont ni sécantes ni parallèles. 
+  
+Procède donc par élimination. 
+Premièrement, vérifie s'il y a un point dont les coordonnées peuvent être générées avec chacune des $2$ équations paramétriques. 
+Dans ce cas les droites sont sécantes en ce point.
+Sinon, regarde si les deux droites ont des vecteurs directeurs colinéaires : 
+s'ils sont colinéaires, les droites sont parallèles
+et s'ils ne sont pas colinéaires alors les droites ne sont pas coplanaires.`;
+};
+const getCorrection = (identifiers) => {
+    const { A, B, parametricLine1, parametricLine2 } = getHydrated(identifiers);
+    const [[texSystem1A, texSystem2A], [texSystem1B, texSystem2B]] = [A, B].map((spacePoint) => [parametricLine1, parametricLine2].map((parametricLine) => texForSystem(spacePoint, parametricLine)));
+    const [_, indexRightAnswer] = createMyPropositions(identifiers)
+        .map((proposition, i) => [proposition, i])
+        .find(([proposition, _]) => proposition.isRightAnswer);
+    const texAIsIntersection = `On commence par vérifier si $A$ est un point d'intersection.
+  
+Pour $A$ :
+
+$$
+${texSystem1A}
+$$
+
+${(() => {
+        const nodeT = findNodeParameterForSpacePointOnParametricLine(A, parametricLine1, "t")?.simplify({ towardsDistribute: true });
+        if (nodeT !== undefined) {
+            return `admet pour solution $t=${nodeT.toTex()}$`;
+        }
+        else {
+            return `n'admet pas de solution.`;
+        }
+    })()}
+
+$$
+${texSystem2A}
+$$
+
+${(() => {
+        const nodeTPrime = findNodeParameterForSpacePointOnParametricLine(A, parametricLine2, "t'")?.simplify({ towardsDistribute: true });
+        if (nodeTPrime !== undefined) {
+            return `admet pour solution $t'=${nodeTPrime.toTex()}$`;
+        }
+        else {
+            return `n'admet pas de solution.`;
+        }
+    })()}
+
+${indexRightAnswer === 0
+        ? `Donc $A$ est le point d'intersection de $d_{1}$ et $d_{2}$.`
+        : `Donc $A$ n'est pas le point d'intersection de $d_{1}$ et $d_{2}$.`}`;
+    const texBIsIntersection = `Pour $B$ :
+
+$$
+${texSystem1B}
+$$
+
+${(() => {
+        const nodeT = findNodeParameterForSpacePointOnParametricLine(B, parametricLine1, "t")?.simplify({ towardsDistribute: true });
+        if (nodeT !== undefined) {
+            return `admet pour solution $t=${nodeT.toTex()}$`;
+        }
+        else {
+            return `n'admet pas de solution.`;
+        }
+    })()}
+
+$$
+${texSystem2B}
+$$
+
+${(() => {
+        const nodeTPrime = findNodeParameterForSpacePointOnParametricLine(B, parametricLine2, "t'")?.simplify({ towardsDistribute: true });
+        if (nodeTPrime !== undefined) {
+            return `admet pour solution $t'=${nodeTPrime.toTex()}$`;
+        }
+        else {
+            return `n'admet pas de solution.`;
+        }
+    })()}
+
+${indexRightAnswer === 1
+        ? `Donc $B$ est le point d'intersection de $d_{1}$ et $d_{2}$.`
+        : `Donc $B$ n'est pas le point d'intersection de $d_{1}$ et $d_{2}$.`}`;
+    const texParallel = `Les vecteurs directeurs respectifs des droites $d_{1}$ et $d_{2}$ sont : 
+
+$$
+\\overrightarrow{v_{1}} = ${parametricLine1.vector.toCoordsTex()}
+$$
+
+$$
+\\overrightarrow{v_{2}} = ${parametricLine2.vector.toCoordsTex()}
+$$
+
+${indexRightAnswer === 2
+        ? `Ils sont colinéaires donc $d_{1}$ et $d_{2}$ sont parallèles.`
+        : `Ils ne sont pas colinéaires donc $d_{1}$ et $d_{2}$ ne sont pas parallèles.`}`;
+    const texNonSecant = "Les droites ne sont ni sécantes ni parallèles. Elles sont donc non coplanaires.";
+    return [
+        texAIsIntersection,
+        texBIsIntersection,
+        texParallel,
+        texNonSecant,
+    ].reduce((acc, tex, i) => {
+        return i <= indexRightAnswer
+            ? [acc, tex].join(`
+
+`)
+            : acc;
+    }, "");
+};
+const getPropositions = (_n, { answer, ...identifiers }) => {
+    return createMyPropositions(identifiers);
+};
+const createRandomIdentifiers = () => {
+    const [vecU, vecV] = ["u", "v"].reduce((acc, name) => {
+        let vec;
+        do {
+            vec = SpaceVectorConstructor.random(name, false);
+        } while (acc.some((vecExisting) => vec.isColinear(vecExisting)));
+        return [...acc, vec];
+    }, []);
+    const [A, B] = SpacePointConstructor.randomDifferent(["A", "B", "C"]);
+    const [[P1, vec1], [P2, vec2]] = (() => {
+        const rand = randint(0, 4);
+        switch (rand) {
+            case 0: {
+                const [vec1, vec2] = [vecU, vecV];
+                const [P1, P2] = zip([vec1, vec2], shuffle([false, coinFlip()])).map(([vec, isZeroAllowed]) => vec
+                    .times(randint(-2, 3, isZeroAllowed ? [] : [0]).toTree())
+                    .getEndPoint(A));
+                return [
+                    [P1, vec1],
+                    [P2, vec2],
+                ];
+            }
+            case 1: {
+                const [vec1, vec2] = [vecU, vecV];
+                const [P1, P2] = zip([vec1, vec2], shuffle([false, coinFlip()])).map(([vec, isZeroAllowed]) => vec
+                    .times(randint(-2, 3, isZeroAllowed ? [] : [0]).toTree())
+                    .getEndPoint(B));
+                return [
+                    [P1, vec1],
+                    [P2, vec2],
+                ];
+            }
+            case 2: {
+                const [vec1, vec2] = coinFlip() ? [vecU, vecU] : [vecV, vecV];
+                const [P1, P2] = zip([A, B], zip([vec1, vec2], shuffle([false, coinFlip()]))).map(([spacePoint, [vec, isZeroAllowed]]) => vec
+                    .times(randint(-2, 3, isZeroAllowed ? [] : [0]).toTree())
+                    .getEndPoint(spacePoint));
+                return [
+                    [P1, vec1],
+                    [P2, vec2],
+                ];
+            }
+            case 3: {
+                const [vec1, vec2] = [vecU, vecV];
+                const [P1, P2] = zip([A, B], zip([vec1, vec2], shuffle([false, coinFlip()]))).map(([spacePoint, [vec, isZeroAllowed]]) => vec
+                    .times(randint(-2, 3, isZeroAllowed ? [] : [0]).toTree())
+                    .getEndPoint(spacePoint));
+                return [
+                    [P1, vec1],
+                    [P2, vec2],
+                ];
+            }
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    })();
+    const identifiers = {
+        spacePointIdsAB: [A, B].map((spacePoint) => spacePoint.toIdentifiers()),
+        spaceLineIds: [
+            [P1, vec1],
+            [P2, vec2],
+        ].map(([spacePoint, spaceVector]) => {
+            return {
+                spacePointIds: spacePoint.toIdentifiers(),
+                spaceVectorIds: spaceVector.toIdentifiers(),
+            };
+        }),
+    };
+    return identifiers;
+};
+const getLineLineRelativePositionsFromParametricLinesQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, _opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const lineLineRelativePositionsFromParametricLines = {
+    id: "lineLineRelativePositionsFromParametricLines",
+    label: "Déterminer les positions relatives de deux droites dont sont données les représentations paramétriques",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getLineLineRelativePositionsFromParametricLinesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/spaceGeometry/parametricLine/parametricLineFromPointAndDirectionVector.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVectorIdentifiers } from "../../../../math/geometry/spaceVector.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    spacePointIds: SpacePointIdentifiers;
+    spaceVectorIds: SpaceVectorIdentifiers;
+    randInstr: number;
+    nodeIdsFactor: NodeIdentifiers;
+};
+export declare const parametricLineFromPointAndDirectionVector: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parametricLineFromPointAndDirectionVector.d.ts.map

package/lib/exercises/math/spaceGeometry/parametricLine/parametricLineFromPointAndDirectionVector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametricLineFromPointAndDirectionVector.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/parametricLine/parametricLineFromPointAndDirectionVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAK5C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,qBAAqB,CAAC;IACrC,cAAc,EAAE,sBAAsB,CAAC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,eAAe,CAAC;CAChC,CAAC;AAgQF,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAAC,WAAW,CAoBzE,CAAC"}

package/lib/exercises/math/spaceGeometry/parametricLine/parametricLineFromPointAndDirectionVector.js

@@ -0,0 +1,181 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { ParametricLine } from "../../../../math/geometry/parametricLine.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector, SpaceVectorConstructor, } from "../../../../math/geometry/spaceVector.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+const getHydrated = (identifiers) => {
+    const { spacePointIds, spaceVectorIds, nodeIdsFactor } = identifiers;
+    const spacePoint = SpacePointConstructor.fromIdentifiers(spacePointIds);
+    const spaceVector = SpaceVectorConstructor.fromIdentifiers(spaceVectorIds);
+    const nodeFactor = NodeConstructor.fromIdentifiers(nodeIdsFactor);
+    const spaceVectorScaled = spaceVector.times(nodeFactor);
+    const parametricLineAnswer = new ParametricLine(spacePoint, spaceVectorScaled);
+    return {
+        spacePoint,
+        spaceVector,
+        spaceVectorScaled,
+        parametricLineAnswer,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { randInstr } = identifiers;
+    const { spacePoint, spaceVector } = getHydrated(identifiers);
+    switch (randInstr) {
+        case 0:
+            return `Donner l'équation paramétrique de la droite de vecteur directeur $${spaceVector.toCoordsTex()}$ passant par le point $${spacePoint.toTexWithCoords()}$`;
+        case 1:
+            return `Donner l'équation paramétrique de la droite passant par le point $${spacePoint.toTexWithCoords()}$ et dont $${spaceVector.toCoordsTex()}$ est un vecteur directeur.`;
+        default:
+            throw new Error("Unsupported randInstr: " + randInstr);
+    }
+};
+const getAnswer = (identifiers) => {
+    const { parametricLineAnswer } = getHydrated(identifiers);
+    return `${parametricLineAnswer.toTex()} \\ (t \\in \\mathbb{R})`;
+};
+const getHint = () => {
+    const I = new SpacePoint("I", new VariableNode("x_{I}"), new VariableNode("y_{I}"), new VariableNode("z_{I}"));
+    const vecU = new SpaceVector("u", new VariableNode("u_{x}"), new VariableNode("u_{y}"), new VariableNode("u_{z}"));
+    const parametricLine = new ParametricLine(I, vecU);
+    return `La droite $d$ passant par le point $${I.toTexWithCoords()}$ et dont $${vecU.toTexWithCoords()}$ est un vecteur directeur a pour équation paramétrique :
+
+$$
+${parametricLine.toTex()} \\ (t \\in \\mathbb{R})
+$$
+
+De plus, si $\\overrightarrow{u}$ est un vecteur directeur de $d$ alors $k\\overrightarrow{u}$ ($k \\in \\mathbb{R}, k \\neq 0$) est aussi un vecteur directeur de $d$.
+ 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { spacePoint, spaceVector, parametricLineAnswer } = getHydrated(identifiers);
+    return `La droite passant par le point $${spacePoint.toTexWithCoords()}$ et dont $${spaceVector.toTexWithCoords()}$ est un vecteur directeur a pour équation paramétrique :
+
+$$
+${parametricLineAnswer.toTex()} \\ (t \\in \\mathbb{R})
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { spacePoint, spaceVector } = getHydrated(identifiers);
+    //student: "+point" -> "-point"
+    {
+        const identifiersWrong = {
+            ...identifiers,
+            spacePointIds: new SpacePoint("v", opposite(spacePoint.x), opposite(spacePoint.y), opposite(spacePoint.z)).toIdentifiers(),
+        };
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //student: point <-> vector
+    {
+        const identifiersWrong = {
+            ...identifiers,
+            spacePointIds: new SpacePoint(spacePoint.name, spaceVector.x, spaceVector.y, spaceVector.z).toIdentifiers(),
+            spaceVectorIds: new SpaceVector("v", spacePoint.x, spacePoint.y, spacePoint.z).toIdentifiers(),
+        };
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //student: t, t', t'' as parameters
+    {
+        const pointCoords = [spacePoint.x, spacePoint.y, spacePoint.z];
+        const vectorCoords = [spaceVector.x, spaceVector.y, spaceVector.z];
+        const equations = ["t", "t'", "t''"].map((varName, i) => add(pointCoords[i], multiply(vectorCoords[i], new VariableNode(varName))).simplify({ forbidFactorize: true }));
+        const texSystem = `\\left\\{\\begin{matrix}
+      x=${equations[0].toTex()} \\\\
+      y=${equations[1].toTex()} \\\\
+      z=${equations[2].toTex()} 
+      \\end{matrix}
+      \\right.`;
+        const texWrong = `${texSystem} \\ ((t,t',t'') \\in \\mathbb{R}^{3})`;
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //student: x,y,z  as parameters
+    {
+        const pointCoords = [spacePoint.x, spacePoint.y, spacePoint.z];
+        const vectorCoords = [spaceVector.x, spaceVector.y, spaceVector.z];
+        const equations = ["x", "y", "z"].map((varName, i) => add(pointCoords[i], multiply(vectorCoords[i], new VariableNode(varName))).simplify({ forbidFactorize: true }));
+        const texSystem = `\\left\\{\\begin{matrix}
+      x=${equations[0].toTex()} \\\\
+      y=${equations[1].toTex()} \\\\
+      z=${equations[2].toTex()} 
+      \\end{matrix}
+      \\right.`;
+        const texWrong = `${texSystem}`;
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //student: plane equation
+    {
+        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 planeEquation = createPlaneEquationFromNormalVectorAndContainedPoint(spaceVector, spacePoint);
+        tryToAddWrongProp(propositions, planeEquation.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+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 [vecV] = zip(["v"], [shuffle([funcRand3, funcRand2, funcRand1])]).map(([name, [funcRandX, funcRandY, funcRandZ]]) => new SpaceVector(name, funcRandX(), funcRandY(), funcRandZ()));
+    const spacePoint = new SpacePoint(random("ABCDRST".split("")), randint(-4, 5).toTree(), randint(-4, 5).toTree(), randint(-4, 5).toTree());
+    const randInstr = randint(0, 2);
+    const nodeFactor = randint(-4, 5, [0]).toTree();
+    const identifiers = {
+        spacePointIds: spacePoint.toIdentifiers(),
+        spaceVectorIds: vecV.toIdentifiers(),
+        randInstr,
+        nodeIdsFactor: nodeFactor.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getParametricLineFromPointAndDirectionVectorQuestion = () => {
+    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 parametricLineFromPointAndDirectionVector = {
+    id: "parametricLineFromPointAndDirectionVector",
+    label: "Déterminer une représentation paramétrique d'une droite connaissant un point et un vecteur directeur",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParametricLineFromPointAndDirectionVectorQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkIsPointBelongingToPlane.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/checkIsPointBelongingToPlane.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAO3C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAqC7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,qBAAqB,CAAC;IACrC,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AAyPF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAkB9D,CAAC"}