math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/spaceGeometry/orthogonalProjection/findOrthogonalProjectionOfPointOnPlane.js

@@ -0,0 +1,366 @@
+import { addValidProp, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.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 { 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 { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } 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 createNodeCheckForIsPointBelongingToPlane = (spacePoint, nodePlaneEquation) => {
+    const nodePlaneEquationRefined = new EqualNode(substract(nodePlaneEquation.leftChild, nodePlaneEquation.rightChild).simplify({ towardsDistribute: true, forbidFactorize: true }), (0).toTree());
+    const nodePlaneEquationLhs = nodePlaneEquationRefined.leftChild;
+    const nodeCheck = (() => {
+        const [nodeX, nodeY, nodeZ] = [spacePoint.x, spacePoint.y, spacePoint.z];
+        return [
+            [nodeX, nodeVarX],
+            [nodeY, nodeVarY],
+            [nodeZ, nodeVarZ],
+        ].reduce((acc, [node, nodeVar]) => {
+            return nodeBySubstitutingVar(acc, node, nodeVar);
+        }, nodePlaneEquationLhs);
+    })();
+    return nodeCheck;
+};
+const isCollinearVecs = (vec1, vec2) => {
+    const vecABVProdAC = vectorialProductRaw(vec1, vec2);
+    const vecABVProdACSimplified = simplifySpaceVector(vecABVProdAC);
+    const isCollinear = vecABVProdACSimplified.equals(new SpaceVector("0", (0).toTree(), (0).toTree(), (0).toTree()));
+    return isCollinear;
+};
+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 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 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 { idsP, spacePointIdsA, spacePointIdsProposed } = identifiers;
+    const dictP = (() => {
+        const { spacePointIdsContained, spaceVectorIdsNormal, nodeIdsPlaneEquation, typeDefinitionData, texName, } = idsP;
+        const spacePointContained = SpacePointConstructor.fromIdentifiers(spacePointIdsContained);
+        const spaceVectorNormal = SpaceVectorConstructor.fromIdentifiers(spaceVectorIdsNormal);
+        const nodePlaneEquation = NodeConstructor.fromIdentifiers(nodeIdsPlaneEquation);
+        return {
+            spacePointContained,
+            spaceVectorNormal,
+            nodePlaneEquation,
+            typeDefinitionData,
+            texName,
+        };
+    })();
+    const arrSpacePointProposed = spacePointIdsProposed.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const A = SpacePointConstructor.fromIdentifiers(spacePointIdsA);
+    const { spacePoint: spacePointAnswer, vec, vecSimplified, nodeCheck, } = arrSpacePointProposed
+        .map((spacePoint) => {
+        const vec = spaceVectorFromPointsRaw(A, spacePoint);
+        const vecSimplified = simplifySpaceVector(vec);
+        const nodeCheck = createNodeCheckForIsPointBelongingToPlane(spacePoint, dictP.nodePlaneEquation);
+        return { spacePoint, vec, vecSimplified, nodeCheck };
+    })
+        .find(({ vecSimplified, nodeCheck }) => {
+        const isPointBelongingToPlane = NodeComparator.isEqualViaSub(nodeCheck, (0).toTree());
+        return (isPointBelongingToPlane &&
+            isCollinearVecs(vecSimplified, dictP.spaceVectorNormal));
+    });
+    return {
+        dictP,
+        A,
+        arrSpacePointProposed,
+        spacePointAnswer,
+        vec,
+        vecSimplified,
+        nodeCheck,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { dictP, A } = getHydrated(identifiers);
+    return `${[dictP].map((dictP) => {
+        const { typeDefinitionData } = dictP;
+        switch (typeDefinitionData) {
+            case "équation": {
+                const { texName, nodePlaneEquation } = dictP;
+                return `Soit $${texName}$ le plan d'équation 
+        
+$$
+${nodePlaneEquation.toTex()}
+$$
+
+`;
+            }
+            case "point et vecteur normal": {
+                const { texName, spacePointContained, spaceVectorNormal } = dictP;
+                return `Soit $${texName}$ le plan contenant le point de coordonnées $${spacePointContained.toCoords()}$ et dont un vecteur normal est $${spaceVectorNormal.toCoordsTex()}$.`;
+            }
+            default:
+                throw new Error("Unsupported typeDefinitionData: " + typeDefinitionData);
+        }
+    }).join(`
+`)}
+
+Soit $A$ le point de coordonnées $${A.toCoords()}$.
+
+Quelles sont les coordonnées du point $H$, projeté orthogonal de $${A.toTex()}$ sur le plan $${dictP.texName}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { spacePointAnswer } = getHydrated(identifiers);
+    return spacePointAnswer.toCoords();
+};
+const getHint = () => {
+    return `Le point $H$, projeté orthogonal du point $A$ sur le plan $\\mathcal{P}$ doit vérifier ces $2$ conditions :
+
+- $H$ est un point de $\\mathcal{P}$ (autrement dit, les coordonnées de $H$ sont solution de l'équation de $\\mathcal{P}$)
+
+- $\\overrightarrow{AH}$ est colinéaire à un vecteur normal de $\\mathcal{P}$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { dictP, spacePointAnswer, vec, vecSimplified, nodeCheck } = getHydrated(identifiers);
+    return `${(() => {
+        const { typeDefinitionData, spaceVectorNormal, spacePointContained, texName, nodePlaneEquation, } = dictP;
+        switch (typeDefinitionData) {
+            case "point et vecteur normal": {
+                const [nodeA, nodeB, nodeC] = [
+                    spaceVectorNormal.x,
+                    spaceVectorNormal.y,
+                    spacePointContained.z,
+                ];
+                const nodePlaneEquationWithVarD = (() => {
+                    const [nodeA, nodeB, nodeC] = [
+                        spaceVectorNormal.x,
+                        spaceVectorNormal.y,
+                        spaceVectorNormal.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 nodeDFormula = opposite(add(multiply(nodeA, spacePointContained.x), add(multiply(nodeB, spacePointContained.y), multiply(nodeC, spacePointContained.z))));
+                return `On calcule l'équation du plan $${texName}$.
+
+$$
+${nodePlaneEquationWithVarD.toTex()}
+$$
+
+avec 
+
+$$
+d = ${nodeDFormula.toTex()}
+$$
+
+ce qui donne :
+
+$$
+(${texName}):
+$$
+
+$$
+${nodePlaneEquation.toTex()}
+$$      
+        
+`;
+            }
+            case "équation":
+                return `Voici un vecteur normal de $${dictP.texName}$ :
+
+$$
+\\overrightarrow{v} = ${dictP.spaceVectorNormal.toCoordsTex()}
+$$`;
+            default:
+                throw new Error("Unsupported typeDefinitionData: " + typeDefinitionData);
+        }
+    })()}
+  
+Nommons pour l'instant $I$ le point de coordonnées $${spacePointAnswer.toCoords()}$.
+
+- $I$ point appartient à $${dictP.texName}$ car ses coordonnées sont solution de l'équation cartésienne de $${dictP.texName}$ :
+
+$$
+${nodeCheck.toTex()} = 0
+$$
+
+- De plus, on observe que $\\overrightarrow{AI}$ et $\\overrightarrow{v}$ sont colinéaires.
+
+En effet:
+
+${alignTex([
+        ["\\overrightarrow{AI}", "=", vec.toCoordsTex()],
+        ["", "=", vecSimplified.toCoordsTex()],
+    ])}
+
+Le projeté orthogonal de $A$ est donc le point de coordonnées $${spacePointAnswer.toCoords()}$.
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { arrSpacePointProposed } = getHydrated(identifiers);
+    const propositions = [];
+    arrSpacePointProposed.forEach((spacePoint) => {
+        const tex = spacePoint.toCoords();
+        if (tex === answer) {
+            addValidProp(propositions, tex);
+        }
+        else {
+            tryToAddWrongProp(propositions, tex);
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = (opts) => {
+    const { typeDataForPlane } = opts;
+    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(-200, 201).toTree(), randint(-200, 201).toTree(), randint(-200, 201).toTree());
+    const nodePlaneEquationP1 = createPlaneEquationFromNormalVectorAndContainedPoint(vecT, O);
+    const [A, B, C, D] = (() => {
+        const [factor1, factor2, [factor3A, factor3B]] = [
+            randint(-2, 3, [0]).toTree(),
+            randint(-2, 3, [0]).toTree(),
+            randomMany([-2, -1, 1, 2], 2).map((v) => v.toTree()),
+        ];
+        return [
+            [(0).toTree(), (0).toTree(), factor3A],
+            [(0).toTree(), (0).toTree(), factor3B],
+            [factor1, factor2, (0).toTree()],
+            [factor1, factor2, coinFlip() ? factor3A : factor3B],
+        ].map(([factorX, factorY, factorZ]) => {
+            const vecWRaw = vecR
+                .times(factorX)
+                .add(vecS.times(factorY))
+                .add(vecT.times(factorZ));
+            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 spacePointProposed = (() => {
+        const H1 = O;
+        const H2 = B;
+        const H3 = C;
+        const H4 = D;
+        return shuffle([H1, H2, H3, H4]);
+    })();
+    const identifiers = {
+        idsP: {
+            spacePointIdsContained: A.toIdentifiers(),
+            spaceVectorIdsNormal: vecT.toIdentifiers(),
+            nodeIdsPlaneEquation: nodePlaneEquationP1.toIdentifiers(),
+            typeDefinitionData: typeDataForPlane,
+            texName: "\\mathcal{P}",
+        },
+        spacePointIdsA: A.toIdentifiers(),
+        spacePointIdsProposed: spacePointProposed.map((spacePointProposed) => spacePointProposed.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getFindOrthogonalProjectionOfPointOnPlaneQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        typeDataForPlane: random(arrayedOpts.typeDataForPlane),
+    };
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    typeDataForPlane: ["équation"],
+};
+const options = [
+    {
+        id: "typeDataForPlane",
+        label: "Définition du plan $\\mathcal{P}_{1}$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["équation", "point et vecteur normal"],
+        defaultValue: arrayedOptsDefault.typeDataForPlane,
+    },
+];
+export const findOrthogonalProjectionOfPointOnPlane = {
+    id: "findOrthogonalProjectionOfPointOnPlane",
+    label: "Déterminer les coordonnées du projeté orthogonal d'un point sur un plan",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindOrthogonalProjectionOfPointOnPlaneQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/orthogonalProjection/index.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,2 @@
+export {};
+// export * from "./findOrthogonalProjectionOfPointOnPlane.js";

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

@@ -0,0 +1,3 @@
+export * from "./parametricLineFromPointAndDirectionVector.js";
+export * from "./lineLineRelativePositionsFromParametricLines.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/parametricLine/index.ts"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAC;AAC/D,cAAc,mDAAmD,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from "./parametricLineFromPointAndDirectionVector.js";
+export * from "./lineLineRelativePositionsFromParametricLines.js";

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

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVectorIdentifiers } from "../../../../math/geometry/spaceVector.js";
+type SpaceLineIds = {
+    spacePointIds: SpacePointIdentifiers;
+    spaceVectorIds: SpaceVectorIdentifiers;
+};
+type Identifiers = {
+    spacePointIdsAB: SpacePointIdentifiers[];
+    spaceLineIds: SpaceLineIds[];
+};
+export declare const lineLineRelativePositionsFromParametricLines: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=lineLineRelativePositionsFromParametricLines.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lineLineRelativePositionsFromParametricLines.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/parametricLine/lineLineRelativePositionsFromParametricLines.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAgH5C,KAAK,YAAY,GAAG;IAClB,aAAa,EAAE,qBAAqB,CAAC;IACrC,cAAc,EAAE,sBAAsB,CAAC;CACxC,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,qBAAqB,EAAE,CAAC;IACzC,YAAY,EAAE,YAAY,EAAE,CAAC;CAC9B,CAAC;AAyTF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAoB5E,CAAC"}