math-exercises 3.0.200 → 3.0.201

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

@@ -0,0 +1,232 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.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 { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 { 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 { zip } from "../../../../utils/arrays/arrayZip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const findNodeFactor = (vec, vecWrt) => {
+    const [nodeNum, nodeDen] = zip([vec.x, vec.y, vec.z], [vecWrt.x, vecWrt.y, vecWrt.z]).find(([node1, node2]) => [node1, node2].every((node) => !NodeComparator.isEqualViaSub(node, (0).toTree()))) ?? [undefined, undefined];
+    if (nodeDen === undefined) {
+        return undefined;
+    }
+    else {
+        return frac(nodeNum, nodeDen).simplify({ towardsDistribute: true });
+    }
+};
+const vectorialProductRaw = (v1, v2) => {
+    return new SpaceVector(`w`, substract(multiply(v1.y, v2.z), multiply(v1.z, v2.y)), substract(multiply(v1.z, v2.x), multiply(v1.x, v2.z)), substract(multiply(v1.x, v2.y), multiply(v1.y, v2.x)));
+};
+const isVecNormalToPlane = (vec, [vecPlane1, vecPlane2]) => {
+    const vecProdProd = vecPlane1.vetorialProduct(vecPlane2).vetorialProduct(vec);
+    return [vecProdProd.x, vecProdProd.y, vecProdProd.z].every((node) => NodeComparator.isEqualViaSub(node, (0).toTree()));
+};
+const spaceVectorFromPointsRaw = (spacePointStart, spacePointEnd) => {
+    return new SpaceVector(`${spacePointStart.name}${spacePointEnd.name}`, substract(spacePointEnd.x, spacePointStart.x), substract(spacePointEnd.y, spacePointStart.y), substract(spacePointEnd.z, spacePointStart.z));
+};
+const simplifySpaceVector = (vec, opts = {}) => {
+    return new SpaceVector(vec.name, vec.x.simplify(opts), vec.y.simplify(opts), vec.z.simplify(opts));
+};
+const getHydrated = (identifiers) => {
+    const { spacePointIdsPlanePoints, spaceVectorIdsProposed } = identifiers;
+    const [A, B, C] = spacePointIdsPlanePoints.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const [vecAB, vecAC] = [
+        [A, B],
+        [A, C],
+    ].map(([spacePointStart, spacePointEnd]) => spaceVectorFromPointsRaw(spacePointStart, spacePointEnd));
+    const [vecABSimplified, vecACSimplified] = [vecAB, vecAC].map((vec) => simplifySpaceVector(vec, { towardsDistribute: true }));
+    const vecABProdAC = vectorialProductRaw(vecABSimplified, vecACSimplified);
+    const vecABProdACSimplified = simplifySpaceVector(vecABProdAC);
+    const vecsProposed = spaceVectorIdsProposed.map((spaceVectorIds) => SpaceVectorConstructor.fromIdentifiers(spaceVectorIds));
+    const vecNormal = vecsProposed.find((vecCandidate) => isVecNormalToPlane(vecCandidate, [vecABSimplified, vecACSimplified]));
+    const nodeK = findNodeFactor(vecNormal, vecABProdACSimplified);
+    return {
+        A,
+        B,
+        C,
+        vecAB,
+        vecABSimplified,
+        vecAC,
+        vecACSimplified,
+        vecABProdAC,
+        vecABProdACSimplified,
+        vecsProposed,
+        vecNormal,
+        nodeK,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { spacePointIdsPlanePoints } = identifiers;
+    const [A, B, C] = spacePointIdsPlanePoints.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    return `Soit $\\mathcal{P}$ le plan contenant les points :
+
+${alignTex([A, B, C].map((spacePoint) => [spacePoint.toTexWithCoords()]))}
+
+Parmi les vecteurs proposées, quel est celui qui est normal à $\\mathcal{P}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { vecNormal } = getHydrated(identifiers);
+    return vecNormal.toInlineCoordsTex();
+};
+const getHint = () => {
+    return `Soit $\\mathcal{P'}$ un plan ayant pour vecteurs de base $\\overrightarrow{u}$ et $\\overrightarrow{v}$. 
+  
+Un vecteur $\\overrightarrow{w}$ est normal à $\\mathcal{P'}$ si et seulement si
+
+$$
+\\overrightarrow{w} \\wedge (\\overrightarrow{u} \\wedge \\overrightarrow{v}) = \\overrightarrow{0}
+$$
+
+Autrement dit, il existe un réel $k$ non nul tel que : 
+
+$$
+\\overrightarrow{w} = k (\\overrightarrow{u} \\wedge \\overrightarrow{v})
+$$
+
+Détermine donc quel vecteur est colinéaire à $\\overrightarrow{AB} \\wedge \\overrightarrow{AC}$.
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { vecAB, vecAC, vecABSimplified, vecACSimplified, vecABProdAC, vecABProdACSimplified, vecNormal, nodeK, } = getHydrated(identifiers);
+    return `On commence par calculer $\\overrightarrow{AB}$ et $\\overrightarrow{AC}$ :
+
+${alignTex([
+        [vecAB, vecABSimplified],
+        [vecAC, vecACSimplified],
+    ].flatMap(([vec, vecSimplified]) => [
+        [vec.toTex(), "=", vec.toCoordsTex()],
+        ["", "=", vecSimplified.toCoordsTex()],
+    ]))}
+
+On peut maintenant calculer :
+  
+${alignTex([
+        ["", "\\overrightarrow{AB} \\wedge \\overrightarrow{AC}"],
+        ["=", vecABProdAC.toCoordsTex()],
+        ["=", vecABProdACSimplified.toCoordsTex()],
+    ])}
+
+Enfin, on constate que :
+
+$$
+${vecNormal.toCoordsTex()} = (${nodeK.toTex()}) ${vecABProdACSimplified.toCoordsTex()}
+$$
+
+Le vecteur normal à $\\mathcal{P}$ est donc $${vecNormal.toInlineCoordsTex()}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { vecsProposed, vecNormal } = getHydrated(identifiers);
+    vecsProposed.forEach((vec) => {
+        const isValid = zip([vec.x, vec.y, vec.z], [vecNormal.x, vecNormal.y, vecNormal.z]).every(([node1, node2]) => NodeComparator.isEqualViaSub(node1, node2));
+        (isValid ? addValidProp : tryToAddWrongProp)(propositions, vec.toInlineCoordsTex());
+    });
+    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();
+    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 A (Plane origin)
+    const A = new SpacePoint("A", randint(-7, 8).toTree(), randint(-7, 8).toTree(), randint(-7, 8).toTree());
+    const B = vecU.getEndPoint(A, "B");
+    const C = vecV.getEndPoint(A, "C");
+    const nbPropositions = 4;
+    const vecsProposed = shuffle([
+        true,
+        ...[...Array(nbPropositions - 1).keys()].map(() => false),
+    ]).map((isValid) => {
+        const isVecNormalToPlane = isValid;
+        const [factor1, factor2, factor3] = isVecNormalToPlane
+            ? [(0).toTree(), (0).toTree(), randint(-4, 5, [0]).toTree()]
+            : shuffle([coinFlip(), false, 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);
+        return vecW;
+    });
+    const identifiers = {
+        spacePointIdsPlanePoints: [A, B, C].map((spacePoint) => spacePoint.toIdentifiers()),
+        spaceVectorIdsProposed: vecsProposed.map((spaceVector) => spaceVector.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getFindNormalVectorFromPlanePointsCoordsQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, _opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findNormalVectorFromPlanePointsCoords = {
+    id: "findNormalVectorFromPlanePointsCoords",
+    label: "Choisir parmi plusieurs vecteurs celui qui est normal à un plan $(ABC)$, les coordonnées de $A$, $B$ et $C$ étant données",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindNormalVectorFromPlanePointsCoordsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -1,2 +1,6 @@
-export {};
+export * from "./checkIsPointBelongingToPlane.js";
+export * from "./planeEquationFromNormalVectorAndContainedPoint.js";
+export * from "./findNormalVectorFromPlaneEquation.js";
+export * from "./planeEquationFromOrthogonalLineAndContainedPoint.js";
+export * from "./planePlaneRelativePositions.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,qDAAqD,CAAC;AACpE,cAAc,wCAAwC,CAAC;AACvD,cAAc,uDAAuD,CAAC;AAEtE,cAAc,kCAAkC,CAAC"}

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

@@ -1,2 +1,6 @@
-export {};
-// export * from "./isPointOnCartesianPlane.js";
+export * from "./checkIsPointBelongingToPlane.js";
+export * from "./planeEquationFromNormalVectorAndContainedPoint.js";
+export * from "./findNormalVectorFromPlaneEquation.js";
+export * from "./planeEquationFromOrthogonalLineAndContainedPoint.js";
+// export * from "./findNormalVectorFromPlanePointsCoords.js";
+export * from "./planePlaneRelativePositions.js";

package/lib/exercises/math/spaceGeometry/planes/planeEquationFromNormalVectorAndContainedPoint.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 = {
+    spacePointIdsContainedPoint: SpacePointIdentifiers;
+    spaceVectorIdsNormalVec: SpaceVectorIdentifiers;
+};
+export declare const planeEquationFromNormalVectorAndContainedPoint: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=planeEquationFromNormalVectorAndContainedPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planeEquationFromNormalVectorAndContainedPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/planeEquationFromNormalVectorAndContainedPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AA4F5C,KAAK,WAAW,GAAG;IACjB,2BAA2B,EAAE,qBAAqB,CAAC;IACnD,uBAAuB,EAAE,sBAAsB,CAAC;CACjD,CAAC;AAoVF,eAAO,MAAM,8CAA8C,EAAE,QAAQ,CAAC,WAAW,CAoB9E,CAAC"}

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

@@ -0,0 +1,273 @@
+import { addValidProp, tryToAddWrongProp, propWhile, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector, SpaceVectorConstructor, } 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 { 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 { 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 { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const [nodeVarX, nodeVarY, nodeVarZ] = ["x", "y", "z"].map((name) => new VariableNode(name));
+const isProportionalByCheckingCrossProductsOfSlidingWindow = (arrNode1, arrNode2) => {
+    return zip(zip(arrNode1.slice(0, -1), arrNode1.slice(1)), zip(arrNode2.slice(0, -1), arrNode2.slice(1))).every(([[node1A, node1B], [node2A, node2B]]) => {
+        const nodeCrossProduct1 = multiply(node1A, node2B);
+        const nodeCrossProduct2 = multiply(node1B, node2A);
+        return (NodeComparator.isEqualViaSub(nodeCrossProduct1, nodeCrossProduct2) ||
+            NodeComparator.isEqualViaFrac(nodeCrossProduct1, nodeCrossProduct2));
+    });
+};
+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 }));
+    console.log("[nodeA, nodeB, nodeC, nodeD]", [nodeA, nodeB, nodeC, nodeD].map((node) => node.toTex()));
+    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 { spacePointIdsContainedPoint, spaceVectorIdsNormalVec } = identifiers;
+    const spacePointContained = SpacePointConstructor.fromIdentifiers(spacePointIdsContainedPoint);
+    const vecNormal = SpaceVectorConstructor.fromIdentifiers(spaceVectorIdsNormalVec);
+    const nodePlaneEquationWithVarD = (() => {
+        const [nodeA, nodeB, nodeC] = [vecNormal.x, vecNormal.y, vecNormal.z];
+        const nodeD = new VariableNode("d");
+        const nodeLhs = add(add(multiply(nodeA, nodeVarX), add(multiply(nodeB, nodeVarY), multiply(nodeC, nodeVarZ))), nodeD).simplify({ towardsDistribute: true, forbidFactorize: true });
+        return new EqualNode(nodeLhs, (0).toTree());
+    })();
+    const [nodeA, nodeB, nodeC] = [vecNormal.x, vecNormal.y, vecNormal.z];
+    const nodeDFormula = opposite(add(multiply(nodeA, spacePointContained.x), add(multiply(nodeB, spacePointContained.y), multiply(nodeC, spacePointContained.z))));
+    const nodePlaneEquation = (() => {
+        const [nodeA, nodeB, nodeC] = [vecNormal.x, vecNormal.y, vecNormal.z];
+        const nodeLhs = add(add(multiply(nodeA, nodeVarX), add(multiply(nodeB, nodeVarY), multiply(nodeC, nodeVarZ))), nodeDFormula.simplify({ towardsDistribute: true, forbidFactorize: true })).simplify({ towardsDistribute: true, forbidFactorize: true });
+        return new EqualNode(nodeLhs, (0).toTree());
+    })();
+    return {
+        spacePointContained,
+        vecNormal,
+        nodePlaneEquationWithVarD,
+        nodePlaneEquation,
+        nodeDFormula,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { spacePointIdsContainedPoint, spaceVectorIdsNormalVec } = identifiers;
+    const spacePointContained = SpacePointConstructor.fromIdentifiers(spacePointIdsContainedPoint);
+    const vecNormal = SpaceVectorConstructor.fromIdentifiers(spaceVectorIdsNormalVec);
+    return `Soit $${spacePointContained.name}$ le point de coordonnées $${spacePointContained.toCoords()}$.
+
+Soit $${vecNormal.toTex()}$ le vecteur tel que:
+
+$$
+${vecNormal.toTex()}=${vecNormal.toCoordsTex()}
+$$
+
+Donner une équation du plan contenant $${spacePointContained.name}$ et dont $${vecNormal.toTex()}$ est un vecteur normal.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodePlaneEquation } = getHydrated(identifiers);
+    return nodePlaneEquation;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    const P = new SpacePoint("P", new VariableNode("p_{x}"), new VariableNode("p_{y}"), new VariableNode("p_{z}"));
+    const vecV = new SpaceVector("v", "a".toTree(), "b".toTree(), "c".toTree());
+    const [nodeA, nodeB, nodeC, nodeD] = ["a", "b", "c", "d"].map((letter) => new VariableNode(letter));
+    const nodeDFormula = opposite(add(multiply(nodeA, P.x), add(multiply(nodeB, P.y), multiply(nodeC, P.z))));
+    const nodePlaneEquationLhs = add(add(multiply(nodeA, nodeVarX), add(multiply(nodeB, nodeVarY), multiply(nodeC, nodeVarZ))), nodeD).simplify({ towardsDistribute: true, forbidFactorize: true });
+    const nodePlaneEquation = new EqualNode(nodePlaneEquationLhs, (0).toTree());
+    return `Soit $P$ le point de coordonnées $${P.toCoords()}$.
+Soit $${vecV.toTex()}$ le vecteur tel que : 
+
+$$
+${vecV.toTex()} = ${vecV.toCoordsTex()}
+$$
+
+Une équation du plan contenant $P$ et dont $${vecV.toTex()}$ est un vecteur normal est :
+
+$$
+${nodePlaneEquation.toTex()}
+$$
+
+avec 
+
+$$
+d = ${nodeDFormula.toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodePlaneEquationWithVarD, nodePlaneEquation, nodeDFormula } = getHydrated(identifiers);
+    return `Une équation du plan recherché est :
+
+$$
+${nodePlaneEquationWithVarD.toTex()}
+$$
+
+avec 
+
+$$
+d = ${nodeDFormula.toTex()}
+$$
+
+ce qui donne :
+
+$$
+${nodePlaneEquation.toTex()}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { spacePointIdsContainedPoint, spaceVectorIdsNormalVec } = identifiers;
+    const spacePointContained = SpacePointConstructor.fromIdentifiers(spacePointIdsContainedPoint);
+    const vecNormal = SpaceVectorConstructor.fromIdentifiers(spaceVectorIdsNormalVec);
+    const nodeD = (() => {
+        const [nodeA, nodeB, nodeC] = [vecNormal.x, vecNormal.y, vecNormal.z];
+        const nodeDFormula = opposite(add(multiply(nodeA, spacePointContained.x), add(multiply(nodeB, spacePointContained.y), multiply(nodeC, spacePointContained.z))));
+        return nodeDFormula.simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+    })();
+    const [vecNormalWrong, spacePointContainedWrong] = [
+        new SpaceVector(spacePointContained.name, spacePointContained.x, spacePointContained.y, spacePointContained.z),
+        new SpacePoint(vecNormal.name, vecNormal.x, vecNormal.y, vecNormal.z),
+    ];
+    propWhile(propositions, n, () => {
+        const [nbWrongProp1, nbWrongProp2] = random([
+            [0, 3],
+            [1, 2],
+            [2, 1],
+        ]);
+        [
+            [vecNormal, spacePointContained, nbWrongProp1],
+            [vecNormalWrong, spacePointContainedWrong, nbWrongProp2],
+        ].forEach(([vecNormal, _spacePointContained, nbWrongProp]) => {
+            [...Array(nbWrongProp).keys()].forEach(() => {
+                const nodeDWrong = random([
+                    opposite(nodeD),
+                    add(nodeD, randint(-10, 10, [0])),
+                    opposite(add(nodeD, randint(-10, 10, [0]))),
+                ]).simplify({ towardsDistribute: true, forbidFactorize: true });
+                const nodePlaneEquation = (() => {
+                    const [nodeA, nodeB, nodeC] = [vecNormal.x, vecNormal.y, vecNormal.z];
+                    const nodeLhs = add(add(multiply(nodeA, nodeVarX), add(multiply(nodeB, nodeVarY), multiply(nodeC, nodeVarZ))), nodeDWrong).simplify({ towardsDistribute: true, forbidFactorize: true });
+                    return new EqualNode(nodeLhs, (0).toTree());
+                })();
+                tryToAddWrongProp(propositions, nodePlaneEquation.toTex());
+            });
+        });
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["x", "y", "z"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        if (!ans.includes("=")) {
+            return false;
+        }
+        const [nodeAnsLhs, nodeAnsRhs] = ans
+            .split("=")
+            .map((str) => parseAlgebraic(str));
+        const nodeAns = new EqualNode(nodeAnsLhs, nodeAnsRhs);
+        const nodeAnsRefined = new EqualNode(substract(nodeAns.leftChild, nodeAns.rightChild).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        }), (0).toTree());
+        const nodeAnswer = getAnswerNode(identifiers);
+        return isProportionalByCheckingCrossProductsOfSlidingWindow(...[nodeAnsRefined, nodeAnswer].map(getCoeffsCorrespondingToPlaneEquation));
+    }
+    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 identifiers = {
+        spacePointIdsContainedPoint: spacePointContained.toIdentifiers(),
+        spaceVectorIdsNormalVec: vecNormal.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getPlaneEquationFromNormalVectorAndContainedPointQuestion = () => {
+    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 planeEquationFromNormalVectorAndContainedPoint = {
+    id: "planeEquationFromNormalVectorAndContainedPoint",
+    label: "Déterminer une équation de plan de vecteur normal donné et passant par un point",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlaneEquationFromNormalVectorAndContainedPointQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+type Identifiers = {
+    spacePointIdsContainedPoint: SpacePointIdentifiers;
+    spacePointIdsParallelLine: SpacePointIdentifiers[];
+};
+type Options = {
+    typeDataForParallelLine: string;
+};
+export declare const planeEquationFromOrthogonalLineAndContainedPoint: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=planeEquationFromOrthogonalLineAndContainedPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planeEquationFromOrthogonalLineAndContainedPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/planeEquationFromOrthogonalLineAndContainedPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAoH3C,KAAK,WAAW,GAAG;IACjB,2BAA2B,EAAE,qBAAqB,CAAC;IACnD,yBAAyB,EAAE,qBAAqB,EAAE,CAAC;CACpD,CAAC;AAkfF,KAAK,OAAO,GAAG;IACb,uBAAuB,EAAE,MAAM,CAAC;CACjC,CAAC;AAeF,eAAO,MAAM,gDAAgD,EAAE,QAAQ,CACrE,WAAW,EACX,OAAO,CAqBR,CAAC"}