math-exercises 3.0.199 → 3.0.201

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

@@ -0,0 +1,509 @@
+import { addValidProp, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } 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 } 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 [nodeVarX, nodeVarY, nodeVarZ] = ["x", "y", "z"].map((name) => new VariableNode(name));
+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 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 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 { idsP1, idsP2 } = identifiers;
+    const [dictP1, dictP2] = [idsP1, idsP2].map((idsP) => {
+        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 [arrNodeP1, arrNodeP2] = [dictP1, dictP2].map(({ nodePlaneEquation }) => getCoeffsCorrespondingToPlaneEquation(nodePlaneEquation));
+    const strTypePlanePlaneRelativePosition = (() => {
+        if (isProportionalByCheckingCrossProductsOfSlidingWindow(arrNodeP1.slice(0, -1), arrNodeP2.slice(0, -1))) {
+            const [nodeNonZero1, nodeNonZero2] = zip(arrNodeP1.slice(0, -1), arrNodeP2.slice(0, -1)).find(([node1, node2]) => [node1, node2].every((node) => !NodeComparator.isEqualViaSub(node, (0).toTree())));
+            const [[nodeD1], [nodeD2]] = [arrNodeP1, arrNodeP2].map((arrNode) => arrNode.slice(-1));
+            if (isProportionalByCheckingCrossProductsOfSlidingWindow([nodeNonZero1, nodeD1], [nodeNonZero2, nodeD2])) {
+                return "Ils sont confondus.";
+            }
+            else {
+                return "Ils sont strictement parallèles.";
+            }
+        }
+        else {
+            return "Ils sont sécants.";
+        }
+    })();
+    return {
+        dictP1,
+        dictP2,
+        strTypePlanePlaneRelativePosition,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { dictP1, dictP2 } = getHydrated(identifiers);
+    return `${[dictP1, dictP2].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(`
+`)}
+
+Quelle est la position relative des plans $${dictP1.texName}$ et $${dictP2.texName}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { strTypePlanePlaneRelativePosition } = getHydrated(identifiers);
+    return strTypePlanePlaneRelativePosition;
+};
+const getHint = (identifiers) => {
+    const { idsP1, idsP2 } = identifiers;
+    const [[texName1, typeDataForPlane1], [texName2, typeDataForPlane2]] = [
+        idsP1,
+        idsP2,
+    ].map((idsP) => [idsP.texName, idsP.typeDefinitionData]);
+    return `${[
+        [texName1, typeDataForPlane1],
+        [texName2, typeDataForPlane2],
+    ].map(([texName, typeDataForPlane]) => {
+        switch (typeDataForPlane) {
+            case "point et vecteur normal":
+                return `Calcule l'équation du plan $${texName}$.`;
+            default:
+                return "";
+        }
+    }).join(`
+`)}
+
+Si les équations sont telles que :
+
+$$
+(\\mathcal{P}_{1}): ax+by+cx+d=0
+$$
+
+$$
+(\\mathcal{P}_{2}): akx+bky+ckx+kd=0
+$$
+
+alors les plans sont confondus (leurs équations sont équivalentes).
+
+Si les équations sont telles que :
+
+$$
+(\\mathcal{P}_{1}): ax+by+cx+d=0
+$$
+
+$$
+(\\mathcal{P}_{2}): akx+bky+ckx+D=0
+$$
+
+avec $D \\neq kd$
+
+alors les plans sont strictement parallèles.
+
+Sinon, les plans sont sécants.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { dictP1, dictP2, strTypePlanePlaneRelativePosition } = getHydrated(identifiers);
+    return `${(() => {
+        return strTypePlanePlaneRelativePosition === "Ils sont sécants."
+            ? ""
+            : `${[dictP1, dictP2].map(({ texName, typeDefinitionData, nodePlaneEquation, spacePointContained, spaceVectorNormal, }) => {
+                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()}
+$$      
+        
+`;
+                    }
+                    default:
+                        return "";
+                }
+            }).join(`
+
+`)}`;
+    })()}
+
+${(() => {
+        switch (strTypePlanePlaneRelativePosition) {
+            case "Ils sont confondus.":
+                return `Les équations sont telles que :
+
+$$
+(\\mathcal{P}_{1}): ax+by+cx+d=0
+$$
+
+$$
+(\\mathcal{P}_{2}): akx+bky+ckx+kd=0
+$$
+
+Les plans sont donc confondus (leurs équations sont équivalentes).
+`;
+            case "Ils sont strictement parallèles.":
+                return `Les équations sont telles que :
+
+$$
+(\\mathcal{P}_{1}): ax+by+cx+d=0
+$$
+
+$$
+(\\mathcal{P}_{2}): akx+bky+ckx+D=0
+$$
+
+avec $D \\neq kd$
+
+Les plans sont donc strictement parallèles.
+`;
+            case "Ils sont sécants.": {
+                const [{ spaceVectorNormal: v1 }, { spaceVectorNormal: v2 }] = [
+                    dictP1,
+                    dictP2,
+                ];
+                const v1Prodv2 = vectorialProductRaw(v1, v2);
+                const v1Prodv2Simplified = simplifySpaceVector(v1Prodv2);
+                return `Les vecteurs normaux des deux plans $\\mathcal{P}_{1}$ et $\\mathcal{P}_{2}$ sont respectivement:
+
+$$
+\\overrightarrow{v_{1}} = ${dictP1.spaceVectorNormal.toCoordsTex()}
+$$
+
+$$
+\\overrightarrow{v_{2}} = ${dictP2.spaceVectorNormal.toCoordsTex()}
+$$
+
+On a :
+
+${alignTex([
+                    ["", "\\overrightarrow{v_{1}} \\wedge \\overrightarrow{v_{2}}"],
+                    ["=", v1Prodv2.toCoordsTex()],
+                    ["=", v1Prodv2Simplified.toCoordsTex()],
+                    ["\\neq", `\\overrightarrow{0}`],
+                ])}
+
+Les plans sont donc sécants.
+
+`;
+            }
+            default:
+                throw new Error("Unsupported strTypePlanePlaneRelativePosition: " +
+                    strTypePlanePlaneRelativePosition);
+        }
+    })()}
+
+`;
+};
+const getPropositions = (_n, { answer }) => {
+    const propositions = [];
+    [
+        "Ils sont sécants.",
+        "Ils sont strictement parallèles.",
+        "Ils sont confondus.",
+        "On ne peut pas savoir.",
+    ].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const createRandomIdentifiers = (opts) => {
+    const { typeDataForPlane1, typeDataForPlane2 } = 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 A (Plane origin)
+    const A = new SpacePoint("A", randint(-7, 8).toTree(), randint(-7, 8).toTree(), randint(-7, 8).toTree());
+    const nodePlaneEquationP1 = createPlaneEquationFromNormalVectorAndContainedPoint(vecT, A);
+    const typePlanePlaneRelativePositions = random([
+        "equal",
+        "strictly parallel",
+        "cutting",
+    ]);
+    const { B, vecNormalP2 } = (() => {
+        switch (typePlanePlaneRelativePositions) {
+            case "equal": {
+                const B = (() => {
+                    const [factor1, factor2, factor3] = [
+                        ...shuffle([coinFlip(), false]).map((isCanBeZero) => randint(-2, 3, isCanBeZero ? [] : [0]).toTree()),
+                        (0).toTree(),
+                    ];
+                    const vecWRaw = vecR
+                        .times(factor1)
+                        .add(vecS.times(factor2))
+                        .add(vecT.times(factor3));
+                    const vecW = new SpaceVector("w", vecWRaw.x, vecWRaw.y, vecWRaw.z);
+                    const spacePointRaw = vecW.getEndPoint(A);
+                    return new SpacePoint("B", spacePointRaw.x, spacePointRaw.y, spacePointRaw.z);
+                })();
+                const vecNormalP2 = vecT.times(randint(-3, 4, [0]).toTree());
+                return { B, vecNormalP2 };
+            }
+            case "strictly parallel": {
+                const vecNormalP2 = vecT.times(randint(-3, 4, [0]).toTree());
+                const B = (() => {
+                    const [factor1, factor2, factor3] = [
+                        ...shuffle([coinFlip(), false]).map((isCanBeZero) => randint(-2, 3, isCanBeZero ? [] : [0]).toTree()),
+                        randint(-2, 3).toTree(),
+                    ];
+                    const vecWRaw = vecR
+                        .times(factor1)
+                        .add(vecS.times(factor2))
+                        .add(vecT.times(factor3));
+                    const vecW = new SpaceVector("w", vecWRaw.x, vecWRaw.y, vecWRaw.z);
+                    const spacePointRaw = vecW.getEndPoint(A);
+                    return new SpacePoint("B", spacePointRaw.x, spacePointRaw.y, spacePointRaw.z);
+                })();
+                return { B, vecNormalP2 };
+            }
+            case "cutting": {
+                const B = SpacePointConstructor.random("B");
+                const vecNormalP2 = (() => {
+                    const [factor1, factor2, factor3] = [
+                        ...shuffle([coinFlip(), false]).map((isCanBeZero) => randint(-2, 3, isCanBeZero ? [] : [0]).toTree()),
+                        randint(-2, 3).toTree(),
+                    ];
+                    return vecR
+                        .times(factor1)
+                        .add(vecS.times(factor2))
+                        .add(vecT.times(factor3));
+                })();
+                return { B, vecNormalP2 };
+            }
+            default:
+                throw new Error("Unsupported typePlanePlaneRelativePositions: " +
+                    typePlanePlaneRelativePositions);
+        }
+    })();
+    const nodePlaneEquationP2 = createPlaneEquationFromNormalVectorAndContainedPoint(vecNormalP2, B);
+    const identifiers = {
+        idsP1: {
+            spacePointIdsContained: A.toIdentifiers(),
+            spaceVectorIdsNormal: vecT.toIdentifiers(),
+            nodeIdsPlaneEquation: nodePlaneEquationP1.toIdentifiers(),
+            typeDefinitionData: typeDataForPlane1,
+            texName: "\\mathcal{P}_{1}",
+        },
+        idsP2: {
+            spacePointIdsContained: B.toIdentifiers(),
+            spaceVectorIdsNormal: vecNormalP2.toIdentifiers(),
+            nodeIdsPlaneEquation: nodePlaneEquationP2.toIdentifiers(),
+            typeDefinitionData: typeDataForPlane2,
+            texName: "\\mathcal{P}_{2}",
+        },
+    };
+    return identifiers;
+};
+const getPlanePlaneRelativePositionsQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        typeDataForPlane1: random(arrayedOpts.typeDataForPlane1),
+        typeDataForPlane2: random(arrayedOpts.typeDataForPlane2),
+    };
+    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 = {
+    typeDataForPlane1: ["équation"],
+    typeDataForPlane2: ["équation"],
+};
+const options = [
+    {
+        id: "typeDataForPlane1",
+        label: "Définition du plan $\\mathcal{P}_{1}$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["équation", "point et vecteur normal"],
+        defaultValue: arrayedOptsDefault.typeDataForPlane1,
+    },
+    {
+        id: "typeDataForPlane2",
+        label: "Définition du plan $\\mathcal{P}_{2}$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["équation", "point et vecteur normal"],
+        defaultValue: arrayedOptsDefault.typeDataForPlane2,
+    },
+];
+export const planePlaneRelativePositions = {
+    id: "planePlaneRelativePositions",
+    label: "Déterminer si deux plans sont sécants, parallèles strictement ou confondus",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlanePlaneRelativePositionsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/spaceGeometry/scalarProduct/angleFromScalarProductFromSpacePointCoords.d.ts

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

package/lib/exercises/math/spaceGeometry/scalarProduct/angleFromScalarProductFromSpacePointCoords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angleFromScalarProductFromSpacePointCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/angleFromScalarProductFromSpacePointCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAiD3C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,qBAAqB,EAAE,CAAC;CACxC,CAAC;AA+QF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAoB1E,CAAC"}