math-exercises 3.0.200 → 3.0.202

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

@@ -0,0 +1,249 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.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 { round } from "../../../../math/utils/round.js";
+import { arccos } from "../../../../tree/nodes/functions/arccosNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.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 norm3DRaw = (spaceVector) => {
+    return sqrt(add(square(spaceVector.x), add(square(spaceVector.y), square(spaceVector.z))));
+};
+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 { spacePointIds } = identifiers;
+    const [A, B, C] = spacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const [vecBA, vecBC] = [
+        [B, A],
+        [B, C],
+    ].map(([spacePointStart, spacePointEnd]) => spaceVectorFromPointsRaw(spacePointStart, spacePointEnd));
+    const [vecBASimplified, vecBCSimplified] = [vecBA, vecBC].map((vec) => simplifySpaceVector(vec, { towardsDistribute: true }));
+    const nodeScalarProduct = vecBASimplified.scalarProduct(vecBCSimplified);
+    const [nodeNormBA, nodeNormBC] = [vecBASimplified, vecBCSimplified].map((vec) => norm3DRaw(vec));
+    const nodeCosABC = frac(nodeScalarProduct.simplify(), multiply(nodeNormBA.simplify(), nodeNormBC.simplify()));
+    const nodeABC = arccos(nodeCosABC.simplify());
+    return {
+        A,
+        B,
+        C,
+        vecBA,
+        vecBASimplified,
+        vecBC,
+        vecBCSimplified,
+        nodeScalarProduct,
+        nodeCosABC,
+        nodeABC,
+        nodeNormBA,
+        nodeNormBC,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { spacePointIds } = identifiers;
+    const [A, B, C] = spacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    return `Soient trois points $A$,$B$ et $C$ de coordonnées : 
+
+${alignTex([A, B, C].map((spacePoint) => [spacePoint.toTexWithCoords()]))}
+  
+Combien vaut $\\widehat{ABC}$ arrondi au degré près ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeABC } = getHydrated(identifiers);
+    const nodeABCInDegrees = multiply(frac(180, PiNode), nodeABC);
+    return round(nodeABCInDegrees.evaluate(), 0).frenchify();
+};
+const getHint = () => {
+    const vecU = new SpaceVector("u", new VariableNode("u_{x}"), new VariableNode("u_{y}"), new VariableNode("u_{z}"));
+    const vecV = new SpaceVector("v", new VariableNode("v_{x}"), new VariableNode("v_{y}"), new VariableNode("v_{z}"));
+    return `Pour commencer, calcule les coordonnées de $\\overrightarrow{BA}$ et de $\\overrightarrow{BC}$.
+
+Puis, tu peux calculer $\\cos(\\widehat{ABC})$ en reliant les deux façons d'écrire le produit scalaire $\\overrightarrow{BA} \\cdot \\overrightarrow{BC}$.
+
+La première façon en utlisant les coordonnées (si on pose $\\overrightarrow{u}=\\overrightarrow{BA}$ et $\\overrightarrow{v}=\\overrightarrow{BC}$) : 
+
+${alignTex([
+        ["", "\\overrightarrow{BA} \\cdot \\overrightarrow{BC}"],
+        ["=", "\\overrightarrow{u} \\cdot \\overrightarrow{v}"],
+        ["=", vecU.scalarProduct(vecV).toTex()],
+    ])}
+
+et la deuxième façon en utilisant l'angle $\\widehat{ABC}$ :
+
+${alignTex([
+        ["", "\\overrightarrow{BA} \\cdot \\overrightarrow{BC}"],
+        [
+            "=",
+            "\\lVert{\\overrightarrow{BA}}\\rVert \\times \\lVert{\\overrightarrow{BC}}\\rVert \\times \\cos(\\widehat{ABC})",
+        ],
+    ])}
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { vecBA, vecBC, vecBASimplified, vecBCSimplified, nodeScalarProduct, nodeABC, nodeCosABC, nodeNormBA, nodeNormBC, } = getHydrated(identifiers);
+    const nodeAnswer = (() => {
+        const nodeABCInDegrees = multiply(frac(180, PiNode), nodeABC);
+        return round(nodeABCInDegrees.evaluate(), 0).toTree();
+    })();
+    return `On a : 
+  
+${alignTex([
+        [vecBA, vecBASimplified],
+        [vecBC, vecBCSimplified],
+    ].flatMap(([vec, vecSimplified]) => [
+        [vec.toTex(), "=", vec.toCoordsTex()],
+        ["", "=", vecSimplified.toCoordsTex()],
+    ]))}
+
+Par conséquent :
+
+${alignTex([
+        [
+            "\\overrightarrow{BA} \\cdot \\overrightarrow{BC}",
+            "=",
+            nodeScalarProduct.toTex({
+                forceNoSimplification: true,
+                forceTimesSign: true,
+            }),
+        ],
+        ["", "=", nodeScalarProduct.simplify({ towardsDistribute: true }).toTex()],
+    ])}
+
+Or : 
+
+$$
+\\overrightarrow{AB} \\cdot \\overrightarrow{AC} = \\lVert{\\overrightarrow{BA}}\\rVert \\times \\lVert{\\overrightarrow{BC}}\\rVert \\times \\cos(\\widehat{ABC})
+$$
+
+et 
+
+${alignTex([
+        ["\\lVert{\\overrightarrow{BA}}\\rVert", "=", nodeNormBA.toTex()],
+        ["", "=", nodeNormBA.simplify().toTex()],
+    ])}
+
+${alignTex([
+        ["\\lVert{\\overrightarrow{BC}}\\rVert", "=", nodeNormBC.toTex()],
+        ["", "=", nodeNormBC.simplify().toTex()],
+    ])}
+
+Donc :
+
+$$
+\\cos(\\widehat{ABC}) = ${nodeCosABC.toTex()}
+$$
+
+$$
+\\widehat{ABC} = ${nodeABC.toTex()}
+$$
+
+L'angle mesure donc environ $${nodeAnswer.toTex()}°$.`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["semicolon"]; //pas gentil
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const funcRand1 = (isCanBeZero) => randint(-3, 4, isCanBeZero ? [] : [0]).toTree();
+    const funcRand2 = (isCanBeZero) => randint(-6, 7, isCanBeZero ? [] : [0]).toTree();
+    const funcRand3 = (isCanBeZero) => randint(-9, 10, isCanBeZero ? [] : [0]).toTree();
+    const [vec1, vec2] = zip(["u", "v"], [
+        [funcRand1, funcRand2, funcRand3],
+        [funcRand3, funcRand2, funcRand1],
+    ]).map(([name, arrFuncRand]) => {
+        const arrIsCanBeZero = shuffle(random([
+            [coinFlip(), false, false],
+            [coinFlip(), coinFlip(), false],
+        ]));
+        const [nodeX, nodeY, nodeZ] = zip(arrIsCanBeZero, arrFuncRand).map(([isCanBeZero, funcRand]) => funcRand(isCanBeZero));
+        return new SpaceVector(name, nodeX, nodeY, nodeZ);
+    });
+    const vecU = vec1;
+    const vecV = (() => {
+        const isVec2EqualsVec1 = vec2.equals(vec1);
+        if (isVec2EqualsVec1) {
+            const vec1Orth = vec1.getRandomOrthogonalVectorNonZero();
+            return vec2.add(vec1Orth);
+        }
+        else {
+            return vec2;
+        }
+    })();
+    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 = {
+        spacePointIds: [A, B, C].map((vec) => new SpacePoint(vec.name, vec.x, vec.y, vec.z).toIdentifiers()),
+    };
+    return identifiers;
+};
+const getAngleFromScalarProductFromSpacePointCoordsQuestion = () => {
+    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 angleFromScalarProductFromSpacePointCoords = {
+    id: "angleFromScalarProductFromSpacePointCoords",
+    label: "Déterminer une mesure de l'angle géométrique $\\widehat{ABC}$ à partir des coordonnées de $A$, $B$ et $C$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAngleFromScalarProductFromSpacePointCoordsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkIsOrthogonalLinesFromParametricReps.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/checkIsOrthogonalLinesFromParametricReps.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAY3C,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,qBAAqB,EAAE,CAAC;IAC5C,kBAAkB,EAAE,qBAAqB,EAAE,CAAC;CAC7C,CAAC;AA2PF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAmB1E,CAAC"}

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

@@ -0,0 +1,200 @@
+import { addValidProp, tryToAddWrongProp, } 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 } from "../../../../math/geometry/spaceVector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 getHydrated = (identifiers) => {
+    const { spacePointIdsForAB, spacePointIdsForUV } = identifiers;
+    const [A, B] = spacePointIdsForAB.map((pointIds) => SpacePointConstructor.fromIdentifiers(pointIds));
+    const [vecU, vecV] = spacePointIdsForUV.map((pointIds) => {
+        const spacePoint = SpacePointConstructor.fromIdentifiers(pointIds);
+        return new SpaceVector(spacePoint.name, spacePoint.x, spacePoint.y, spacePoint.z);
+    });
+    const [lineU, lineV] = [
+        [A, vecU],
+        [B, vecV],
+    ].map(([spacePoint, spaceVector]) => new ParametricLine(spacePoint, spaceVector));
+    const nodeScalarProduct = vecU.scalarProduct(vecV);
+    return {
+        lineU,
+        lineV,
+        vecU,
+        vecV,
+        nodeScalarProduct,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { lineU, lineV } = getHydrated(identifiers);
+    return `Soient deux droites $d_{1}$ et $d_{2}$ dont les équations paramétriques sont : 
+
+$$
+d_{1}: ${lineU.toTex()}
+$$
+
+$$
+d_{2}: ${lineV.toTex()}
+$$
+  
+Les droites $d_{1}$ et $d_{2}$ sont-elles orthogonales ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeScalarProduct } = getHydrated(identifiers);
+    const isOrthogonalVecs = NodeComparator.isEqualViaSub(nodeScalarProduct, (0).toTree());
+    return isOrthogonalVecs ? "Oui" : "Non";
+};
+const getHint = () => {
+    const A = new SpacePoint("A", new VariableNode("a_{x}"), new VariableNode("a_{y}"), new VariableNode("a_{z}"));
+    const vecU = new SpaceVector("u", new VariableNode("u_{x}"), new VariableNode("u_{y}"), new VariableNode("u_{z}"));
+    const line = new ParametricLine(A, vecU);
+    return `Deux droites sont orthogonales si et seulement si leurs vecteurs directeurs sont orthogonaux.
+
+Si $d$ est une droite d'équation paramétrique :
+
+$$
+d: ${line.toTex()}
+$$
+
+alors on peut extraire le vecteur directeur : 
+
+$$
+\\overrightarrow{u} = ${vecU.toCoordsTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { vecU, vecV, nodeScalarProduct } = getHydrated(identifiers);
+    const isOrthogonalVecs = NodeComparator.isEqualViaSub(nodeScalarProduct, (0).toTree());
+    return `Soient $\\overrightarrow{u}$ et $\\overrightarrow{v}$ les vecteurs directeurs respectifs des droites $d_{1}$ et $d_{2}$ : 
+
+$$
+\\overrightarrow{u} = ${vecU.toCoordsTex()}
+$$
+
+$$
+\\overrightarrow{v} = ${vecV.toCoordsTex()}
+$$
+
+On calcule :
+  
+${alignTex([
+        [
+            "\\overrightarrow{u} \\cdot \\overrightarrow{v}",
+            "=",
+            nodeScalarProduct.toTex({
+                forceNoSimplification: true,
+                forceTimesSign: true,
+            }),
+        ],
+        ["", "=", nodeScalarProduct.simplify({ towardsDistribute: true }).toTex()],
+        !isOrthogonalVecs ? ["", "\\neq", "0"] : [],
+    ])}
+
+${(() => {
+        if (isOrthogonalVecs) {
+            return `Le produit scalaire est nul donc les vecteurs directeurs sont orthogonaux. Les droites $d_{1}$ et $d_{2}$ sont donc orthogonales.`;
+        }
+        else {
+            return `Le produit scalaire n'est pas nul donc les vecteurs directeurs ne sont pas orthogonaux. Les droites $d_{1}$ et $d_{2}$ ne sont donc pas orthogonales.`;
+        }
+    })()}`;
+};
+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));
+    }
+    const [vecR, vecS] = zip(["r", "s"], [
+        [funcRand1, funcRand2, funcRand3],
+        [funcRand3, funcRand2, funcRand1],
+    ]).map(([name, [funcRandX, funcRandY, funcRandZ]]) => new SpaceVector(name, funcRandX(), funcRandY(), funcRandZ()));
+    const isOrthogonalVecs = coinFlip();
+    const [vecU, vecV] = (() => {
+        const [vecURaw, vecVRaw] = shuffle([vecR, vecS]);
+        const vecU = new SpaceVector("u", vecURaw.x, vecURaw.y, vecURaw.z);
+        if (isOrthogonalVecs) {
+            const vecV = (() => {
+                const vecRaw = createRandomOrthogonalVector(vecU);
+                return new SpaceVector("v", vecRaw.x, vecRaw.y, vecRaw.z);
+            })();
+            return [vecU, vecV];
+        }
+        else {
+            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 [A, B] = ["A", "B"].map((name) => new SpacePoint(name, randint(-4, 5).toTree(), randint(-4, 5).toTree(), randint(-4, 5).toTree()));
+    const identifiers = {
+        spacePointIdsForAB: [A, B].map((spacePoint) => spacePoint.toIdentifiers()),
+        spacePointIdsForUV: [vecU, vecV].map((vec) => new SpacePoint(vec.name, vec.x, vec.y, vec.z).toIdentifiers()),
+    };
+    return identifiers;
+};
+const getCheckIsOrthogonalLinesFromParametricRepsQuestion = () => {
+    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 checkIsOrthogonalLinesFromParametricReps = {
+    id: "checkIsOrthogonalLinesFromParametricReps",
+    label: "Déterminer si deux droites dont on donne les représentations paramétriques sont orthogonales",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCheckIsOrthogonalLinesFromParametricRepsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkIsOrthogonalSpaceVecsFromCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/checkIsOrthogonalSpaceVecsFromCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAY3C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,qBAAqB,EAAE,CAAC;CAC/C,CAAC;AAmNF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAkBtE,CAAC"}

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

@@ -0,0 +1,176 @@
+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 { 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 getHydrated = (identifiers) => {
+    const { spacePointIdsForVecs } = identifiers;
+    const [vecU, vecV] = spacePointIdsForVecs.map((pointIds) => {
+        const spacePoint = SpacePointConstructor.fromIdentifiers(pointIds);
+        return new SpaceVector(spacePoint.name, spacePoint.x, spacePoint.y, spacePoint.z);
+    });
+    const nodeScalarProduct = vecU.scalarProduct(vecV);
+    return {
+        vecU,
+        vecV,
+        nodeScalarProduct,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { vecU, vecV } = getHydrated(identifiers);
+    return `Soient deux vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ tels que : 
+
+$$
+\\overrightarrow{u} = ${vecU.toCoordsTex()}
+$$
+
+$$
+\\overrightarrow{v} = ${vecV.toCoordsTex()}
+$$
+  
+Les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ sont-ils orthogonaux ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeScalarProduct } = getHydrated(identifiers);
+    const isOrthogonalVecs = NodeComparator.isEqualViaSub(nodeScalarProduct, (0).toTree());
+    return isOrthogonalVecs ? "Oui" : "Non";
+};
+const getHint = () => {
+    const vecU = new SpaceVector("u", new VariableNode("u_{x}"), new VariableNode("u_{y}"), new VariableNode("u_{z}"));
+    const vecV = new SpaceVector("v", new VariableNode("v_{x}"), new VariableNode("v_{y}"), new VariableNode("v_{z}"));
+    return `Soit $${vecU.toTex()}$ et $${vecV.toTex()}$ deux vecteurs tels que : 
+  
+${alignTex([vecU, vecV].map((vec) => [vec.toTexWithCoords()]))}
+
+Les vecteurs $${vecU.toTex()}$ et $${vecV.toTex()}$ sont orthogonaux si et seulement si :
+
+${alignTex([
+        ["", "\\overrightarrow{u} \\cdot \\overrightarrow{v}", "=", "0"],
+        ["\\Leftrightarrow", vecU.scalarProduct(vecV).toTex(), "=", "0"],
+    ])}
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeScalarProduct } = getHydrated(identifiers);
+    const isOrthogonalVecs = NodeComparator.isEqualViaSub(nodeScalarProduct, (0).toTree());
+    return `On calcule : 
+  
+${alignTex([
+        [
+            "\\overrightarrow{u} \\cdot \\overrightarrow{v}",
+            "=",
+            nodeScalarProduct.toTex({
+                forceNoSimplification: true,
+                forceTimesSign: true,
+            }),
+        ],
+        ["", "=", nodeScalarProduct.simplify({ towardsDistribute: true }).toTex()],
+        !isOrthogonalVecs ? ["", "\\neq", "0"] : [],
+    ])}
+
+${(() => {
+        if (isOrthogonalVecs) {
+            return `Le produit scalaire est nul donc les deux vecteurs sont orthogonaux.`;
+        }
+        else {
+            return `Le produit scalaire n'est pas nul donc les deux vecteurs ne sont pas orthogonaux.`;
+        }
+    })()}`;
+};
+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));
+    }
+    const [vecR, vecS] = zip(["r", "s"], [
+        [funcRand1, funcRand2, funcRand3],
+        [funcRand3, funcRand2, funcRand1],
+    ]).map(([name, [funcRandX, funcRandY, funcRandZ]]) => new SpaceVector(name, funcRandX(), funcRandY(), funcRandZ()));
+    const isOrthogonalVecs = coinFlip();
+    const [vecU, vecV] = (() => {
+        const [vecURaw, vecVRaw] = shuffle([vecR, vecS]);
+        const vecU = new SpaceVector("u", vecURaw.x, vecURaw.y, vecURaw.z);
+        if (isOrthogonalVecs) {
+            const vecV = (() => {
+                const vecRaw = createRandomOrthogonalVector(vecU);
+                return new SpaceVector("v", vecRaw.x, vecRaw.y, vecRaw.z);
+            })();
+            return [vecU, vecV];
+        }
+        else {
+            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 identifiers = {
+        spacePointIdsForVecs: [vecU, vecV].map((vec) => new SpacePoint(vec.name, vec.x, vec.y, vec.z).toIdentifiers()),
+    };
+    return identifiers;
+};
+const getCheckIsOrthogonalSpaceVecsFromCoordsQuestion = () => {
+    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 checkIsOrthogonalSpaceVecsFromCoords = {
+    id: "checkIsOrthogonalSpaceVecsFromCoords",
+    label: "Déterminer si deux vecteurs de coordonnées données sont orthogonaux",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCheckIsOrthogonalSpaceVecsFromCoordsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkIsSpaceVecOrthogonalToPlaneFromCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/checkIsSpaceVecOrthogonalToPlaneFromCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAiC3C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,qBAAqB,CAAC;IAC5C,qBAAqB,EAAE,qBAAqB,EAAE,CAAC;CAChD,CAAC;AA+UF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAoB1E,CAAC"}