math-exercises 3.0.200 → 3.0.201

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

@@ -0,0 +1,398 @@
+import { addValidProp, tryToAddWrongProp, propWhile, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, } 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 { 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";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const [nodeVarX, nodeVarY, nodeVarZ] = ["x", "y", "z"].map((name) => new VariableNode(name));
+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 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 }));
+    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, spacePointIdsParallelLine } = identifiers;
+    const spacePointContained = SpacePointConstructor.fromIdentifiers(spacePointIdsContainedPoint);
+    const [A, B] = spacePointIdsParallelLine.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const vecNormalRaw = spaceVectorFromPointsRaw(A, B);
+    const vecNormal = simplifySpaceVector(vecNormalRaw);
+    const parametricLine = new ParametricLine(A, vecNormal);
+    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,
+        A,
+        B,
+        parametricLine,
+        vecNormalRaw,
+        vecNormal,
+        nodePlaneEquationWithVarD,
+        nodePlaneEquation,
+        nodeDFormula,
+    };
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const typeDataForParallelLine = opts.typeDataForParallelLine;
+    const { spacePointIdsContainedPoint, spacePointIdsParallelLine } = identifiers;
+    const spacePointContained = SpacePointConstructor.fromIdentifiers(spacePointIdsContainedPoint);
+    const [A, B] = spacePointIdsParallelLine.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    switch (typeDataForParallelLine) {
+        case "définie par $2$ points": {
+            return `Soit $${spacePointContained.name}$ le point de coordonnées $${spacePointContained.toCoords()}$.
+
+Soit $l$ la droite passant par les points :
+
+${alignTex([A, B].map((spacePoint) => [spacePoint.toTexWithCoords()]))}
+
+Donner une équation du plan $\\mathcal{P}$ contenant $${spacePointContained.name}$ et perpendiculaire à la droite $l$.`;
+        }
+        case "représentation paramétrique": {
+            const vecNormalRaw = spaceVectorFromPointsRaw(A, B);
+            const vecNormal = simplifySpaceVector(vecNormalRaw);
+            const parametricLine = new ParametricLine(A, vecNormal);
+            return `Soit $${spacePointContained.name}$ le point de coordonnées $${spacePointContained.toCoords()}$.
+
+Soit $l$ la droite dont la représentation paramétrique est :
+
+$$
+(d): ${parametricLine.toTex()} \\ \\ (t \\in \\mathbb{R})
+$$
+
+Donner une équation du plan contenant $${spacePointContained.name}$ et perpendiculaire à la droite $l$.`;
+        }
+        default:
+            throw new Error("Unsupported typeDataForParallelLine: " + typeDataForParallelLine);
+    }
+};
+const getAnswerNode = (identifiers) => {
+    const { nodePlaneEquation } = getHydrated(identifiers);
+    return nodePlaneEquation;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (_identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const typeDataForParallelLine = opts.typeDataForParallelLine;
+    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()}
+$$
+
+${(() => {
+        switch (typeDataForParallelLine) {
+            case "définie par $2$ points": {
+                const [A, B] = [
+                    ["A", "a"],
+                    ["B", "b"],
+                ].map(([name, letter]) => new SpacePoint(name, new VariableNode(`${letter}_{x}`), new VariableNode(`${letter}_{y}`), new VariableNode(`${letter}_{z}`)));
+                const vecAB = SpaceVectorConstructor.fromPoints(A, B);
+                return `Si $l$ est la droite passant par les points :
+
+${alignTex([A, B].map((spacePoint) => [spacePoint.toTexWithCoords()]))}
+
+Un vecteur directeur de $l$ est : 
+
+$$
+${vecAB.toTex()} = ${vecAB.toCoordsTex()}
+$$
+
+`;
+            }
+            case "représentation paramétrique": {
+                const A = new SpacePoint("A", new VariableNode("r"), new VariableNode("s"), new VariableNode("t"));
+                const vec = new SpaceVector("v", new VariableNode("a"), new VariableNode("b"), new VariableNode("c"));
+                const parametricLine = new ParametricLine(A, vec);
+                return `Si $l$ est la droite de représentation paramétrique :
+
+$$
+(d): ${parametricLine.toTex()} \\ \\ (t \\in \\mathbb{R})
+$$
+
+alors un vecteur directeur de $l$ est :
+
+$$
+${vec.toTex()} = ${vec.toCoordsTex()}
+$$
+
+`;
+            }
+            default:
+                throw new Error("Unsupported typeDataForParallelLine: " + typeDataForParallelLine);
+        }
+    })()}
+
+`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const typeDataForParallelLine = opts.typeDataForParallelLine;
+    const { vecNormalRaw, vecNormal, nodePlaneEquationWithVarD, nodePlaneEquation, nodeDFormula, } = getHydrated(identifiers);
+    return `Un vecteur directeur de $l$ est : 
+
+${(() => {
+        switch (typeDataForParallelLine) {
+            case "définie par $2$ points": {
+                return `
+
+${alignTex([
+                    ["\\overrightarrow{v}", "=", vecNormalRaw.toCoordsTex()],
+                    ["", "=", vecNormal.toCoordsTex()],
+                ])}
+
+`;
+            }
+            case "représentation paramétrique": {
+                return `
+
+${alignTex([["\\overrightarrow{v}", "=", vecNormal.toCoordsTex()]])}
+
+`;
+            }
+            default:
+                throw new Error("Unsupported typeDataForParallelLine: " + typeDataForParallelLine);
+        }
+    })()}
+
+Le plan $\\mathcal{P}$ recherché est orthogonal à $l$ si $\\overrightarrow{v}$ est un vecteur normal à $\\mathcal{P}$.
+  
+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 { spacePointContained, vecNormal } = getHydrated(identifiers);
+    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());
+    })();
+    //points of parallel line
+    const A = new SpacePoint("A", randint(-7, 8).toTree(), randint(-7, 8).toTree(), randint(-7, 8).toTree());
+    const B = vecNormal.getEndPoint(A, "B");
+    //contained point
+    const spacePointContained = new SpacePoint(random("C".split("")), randint(-7, 8).toTree(), randint(-7, 8).toTree(), randint(-7, 8).toTree());
+    const identifiers = {
+        spacePointIdsContainedPoint: spacePointContained.toIdentifiers(),
+        spacePointIdsParallelLine: [A, B].map((spacePoint) => spacePoint.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getPlaneEquationFromOrthogonalLineAndContainedPointQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    typeDataForParallelLine: "définie par $2$ points",
+};
+const options = [
+    {
+        id: "typeDataForParallelLine",
+        label: "Définition de la droite parallèle",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["définie par $2$ points", "représentation paramétrique"],
+        defaultValue: optsDefault.typeDataForParallelLine,
+    },
+];
+export const planeEquationFromOrthogonalLineAndContainedPoint = {
+    id: "planeEquationFromOrthogonalLineAndContainedPoint",
+    label: "Déterminer une équation de plan perpendiculaire à une droite et passant par un point",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlaneEquationFromOrthogonalLineAndContainedPointQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,22 @@
+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 PlaneIds = {
+    spacePointIdsContained: SpacePointIdentifiers;
+    spaceVectorIdsNormal: SpaceVectorIdentifiers;
+    nodeIdsPlaneEquation: NodeIdentifiers;
+    typeDefinitionData: string;
+    texName: string;
+};
+type Identifiers = {
+    idsP1: PlaneIds;
+    idsP2: PlaneIds;
+};
+type Options = {
+    typeDataForPlane1: string;
+    typeDataForPlane2: string;
+};
+export declare const planePlaneRelativePositions: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=planePlaneRelativePositions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planePlaneRelativePositions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/planes/planePlaneRelativePositions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAS5C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkH7C,KAAK,QAAQ,GAAG;IACd,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,oBAAoB,EAAE,sBAAsB,CAAC;IAC7C,oBAAoB,EAAE,eAAe,CAAC;IACtC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,QAAQ,CAAC;IAChB,KAAK,EAAE,QAAQ,CAAC;CACjB,CAAC;AAsiBF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AA8BF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBtE,CAAC"}