math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/spaceGeometry/scalarProduct/checkIsSpaceVecOrthogonalToPlaneFromCoords.js

@@ -0,0 +1,263 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector } from "../../../../math/geometry/spaceVector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 { alignTex } from "../../../../utils/latex/alignTex.js";
+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 { spacePointIdsForVecW, spacePointIdsForPlane } = identifiers;
+    const vecW = (() => {
+        const spacePoint = SpacePointConstructor.fromIdentifiers(spacePointIdsForVecW);
+        return new SpaceVector(spacePoint.name, spacePoint.x, spacePoint.y, spacePoint.z);
+    })();
+    const [A, B, C] = spacePointIdsForPlane.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 [nodeScalarProductWAB, nodeScalarProductWAC] = [
+        vecABSimplified,
+        vecACSimplified,
+    ].map((vec) => vecW.scalarProduct(vec));
+    return {
+        vecW,
+        A,
+        B,
+        C,
+        vecAB,
+        vecABSimplified,
+        vecAC,
+        vecACSimplified,
+        nodeScalarProductWAB,
+        nodeScalarProductWAC,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { spacePointIdsForVecW, spacePointIdsForPlane } = identifiers;
+    const vecW = (() => {
+        const spacePoint = SpacePointConstructor.fromIdentifiers(spacePointIdsForVecW);
+        return new SpaceVector(spacePoint.name, spacePoint.x, spacePoint.y, spacePoint.z);
+    })();
+    const [A, B, C] = spacePointIdsForPlane.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    return `Soient $A$, $B$ et $C$ trois points de coordonnées : 
+
+${alignTex([A, B, C].map((spacePoint) => [spacePoint.toTexWithCoords()]))}
+
+Soit $\\overrightarrow{w}$ le vecteur tel que : 
+
+$$
+\\overrightarrow{w} = ${vecW.toCoordsTex()}
+$$
+
+Le vecteur $\\overrightarrow{w}$ est-il orthogonal au plan défini par $A$,$B$ et $C$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeScalarProductWAB, nodeScalarProductWAC } = getHydrated(identifiers);
+    const isVecOrthogonalToPlane = NodeComparator.isEqualViaSub(nodeScalarProductWAB, (0).toTree()) &&
+        NodeComparator.isEqualViaSub(nodeScalarProductWAC, (0).toTree());
+    return isVecOrthogonalToPlane ? "Oui" : "Non";
+};
+const getHint = () => {
+    return `Commence par calculer les coordonnées des vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{AC}$.
+
+Ensuite, tu peux utiliser la propriété suivante :
+
+$\\overrightarrow{w}$ est orthogonal au plan défini par $A$,$B$,$C$ si et seulement si
+
+$$
+\\overrightarrow{w} \\wedge (\\overrightarrow{AB} \\wedge \\overrightarrow{AC}) = \\overrightarrow{0}
+$$
+
+Ou alors, tu peux utiliser la propriété suivante (qui demande moins d'efforts) : 
+
+$\\overrightarrow{w}$ (non nul) est orthogonal au plan défini par $A$,$B$,$C$ si et seulement si
+
+$$
+\\overrightarrow{w} \\cdot \\overrightarrow{AB} = 0 \\ \\text{et} \\ \\overrightarrow{w} \\cdot \\overrightarrow{AC} = 0
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { vecAB, vecABSimplified, vecAC, vecACSimplified, nodeScalarProductWAB, nodeScalarProductWAC, } = getHydrated(identifiers);
+    const [isOrthogonalVecsWAB, isOrthogonalVecsWAC] = [
+        nodeScalarProductWAB,
+        nodeScalarProductWAC,
+    ].map((nodeScalarProduct) => NodeComparator.isEqualViaSub(nodeScalarProduct, (0).toTree()));
+    const isVecOrthogonalToPlane = isOrthogonalVecsWAB && isOrthogonalVecsWAC;
+    return `On calcule :
+  
+${alignTex([
+        [vecAB, vecABSimplified],
+        [vecAC, vecACSimplified],
+    ].flatMap(([vec, vecSimplified]) => [
+        [vec.toTex(), "=", vec.toCoordsTex()],
+        ["", "=", vecSimplified.toCoordsTex()],
+    ]))}
+
+On peut maintenant calculer :
+  
+${alignTex([
+        ["", "\\overrightarrow{w} \\cdot \\overrightarrow{AB}"],
+        [
+            "=",
+            nodeScalarProductWAB.toTex({
+                forceNoSimplification: true,
+                forceTimesSign: true,
+            }),
+        ],
+        ["=", nodeScalarProductWAB.simplify({ towardsDistribute: true }).toTex()],
+        !isOrthogonalVecsWAB ? ["\\neq", "0"] : [],
+    ])}
+
+${alignTex([
+        ["", "\\overrightarrow{w} \\cdot \\overrightarrow{AC}"],
+        [
+            "=",
+            nodeScalarProductWAC.toTex({
+                forceNoSimplification: true,
+                forceTimesSign: true,
+            }),
+        ],
+        ["=", nodeScalarProductWAC.simplify({ towardsDistribute: true }).toTex()],
+        !isOrthogonalVecsWAC ? ["\\neq", "0"] : [],
+    ])}
+
+${(() => {
+        if (isVecOrthogonalToPlane) {
+            return `Les produits scalaires $\\overrightarrow{w} \\cdot \\overrightarrow{AB}$ et $\\overrightarrow{w} \\cdot \\overrightarrow{AC}$ sont tous deux nuls donc $\\overrightarrow{w}$ est orthogonal au plan défini par $A$,$B$ et $C$.`;
+        }
+        else {
+            return `Les produits scalaires $\\overrightarrow{w} \\cdot \\overrightarrow{AB}$ et $\\overrightarrow{w} \\cdot \\overrightarrow{AC}$ ne sont pas tous deux nuls donc $\\overrightarrow{w}$ n'est pas orthogonal au plan défini par $A$,$B$ et $C$.`;
+        }
+    })()}`;
+};
+const getPropositions = (_n, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non", "On ne peut pas savoir"].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+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(-4, 5, [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 vecW and A,B,C
+    const isVecOrthogonalToPlane = coinFlip();
+    const vecW = (() => {
+        if (isVecOrthogonalToPlane) {
+            const nodeFactor = randint(-3, 4, [0]).toTree();
+            const vecTRescaled = vecT.times(nodeFactor);
+            const vecW = new SpaceVector("w", vecTRescaled.x, vecTRescaled.y, vecTRescaled.z);
+            return vecW;
+        }
+        else {
+            const [factor1, factor2, factor3] = shuffle(random([[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 A = new SpacePoint("A", randint(-5, 6).toTree(), randint(-5, 6).toTree(), randint(-5, 6).toTree());
+    const [B, C] = [
+        ["B", vecU],
+        ["C", vecV],
+    ].map(([name, vec]) => {
+        const spacePointRaw = vec.getEndPoint(A);
+        return new SpacePoint(name, spacePointRaw.x, spacePointRaw.y, spacePointRaw.z);
+    });
+    const identifiers = {
+        spacePointIdsForVecW: new SpacePoint(vecW.name, vecW.x, vecW.y, vecW.z).toIdentifiers(),
+        spacePointIdsForPlane: [A, B, C].map((spacePoint) => spacePoint.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getCheckIsSpaceVecOrthogonalToPlaneFromCoordsQuestion = () => {
+    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 checkIsSpaceVecOrthogonalToPlaneFromCoords = {
+    id: "checkIsSpaceVecOrthogonalToPlaneFromCoords",
+    label: "Vérifier si un vecteur de coordonnées données est orthogonal à un plan défini par trois points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCheckIsSpaceVecOrthogonalToPlaneFromCoordsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,6 @@
+export * from "./scalarProductFromCubeOuterPoints.js";
+export * from "./scalarProductFromSpacePointCoords.js";
+export * from "./checkIsOrthogonalSpaceVecsFromCoords.js";
+export * from "./checkIsSpaceVecOrthogonalToPlaneFromCoords.js";
+export * from "./checkIsOrthogonalLinesFromParametricReps.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AAEvD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iDAAiD,CAAC;AAChE,cAAc,+CAA+C,CAAC"}

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

@@ -0,0 +1,6 @@
+export * from "./scalarProductFromCubeOuterPoints.js";
+export * from "./scalarProductFromSpacePointCoords.js";
+// export * from "./angleFromScalarProductFromSpacePointCoords.js";
+export * from "./checkIsOrthogonalSpaceVecsFromCoords.js";
+export * from "./checkIsSpaceVecOrthogonalToPlaneFromCoords.js";
+export * from "./checkIsOrthogonalLinesFromParametricReps.js";

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

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    spacePointIds: SpacePointIdentifiers[];
+    nodeIdsSideLength: NodeIdentifiers;
+};
+type Options = {
+    typeSideLength: string;
+    isIncludeMidpoints: boolean;
+};
+export declare const scalarProductFromCubeOuterPoints: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=scalarProductFromCubeOuterPoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductFromCubeOuterPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/scalarProductFromCubeOuterPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAO3C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAqL7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,qBAAqB,EAAE,CAAC;IACvC,iBAAiB,EAAE,eAAe,CAAC;CACpC,CAAC;AA+dF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAuBF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBzE,CAAC"}