math-exercises 3.0.158 → 3.0.160

package/lib/exercises/math/geometry/vectors/scalarProduct/alKashi/scalarProductAlKashiSideLength.js

@@ -0,0 +1,253 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../../geogebra/geogebraConstructor.js";
+import { TriangleConstructor, } from "../../../../../../math/geometry/triangles/triangle.js";
+import { randfloat } from "../../../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../../math/utils/round.js";
+import { cos } from "../../../../../../tree/nodes/functions/cosNode.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 { power } from "../../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../../../tree/parsers/latexParser.js";
+import { probaFlip } from "../../../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../../../utils/alea/random.js";
+import { arrayRotation } from "../../../../../../utils/arrays/rotation.js";
+import { handleVEAError } from "../../../../../../utils/errors/handleVEAError.js";
+const precision = 2;
+const getHydrated = (identifiers) => {
+    const { indexSide } = identifiers;
+    const indexAngle = indexSide;
+    const { triangleIds } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIds);
+    const sides = arrayRotation(triangle.sides, indexAngle);
+    return {
+        triangle,
+        sides,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { indexSide } = identifiers;
+    const indexAngle = indexSide;
+    const { triangle } = getHydrated(identifiers);
+    return `Soit $${triangle.name}$ un triangle. On a :
+  
+${triangle.sides
+        .filter((_, i) => i !== indexSide)
+        .map((segment) => `- $${segment.toInsideName()} = ${segment.getLength().frenchify()}$`).join(`
+  
+`)}
+
+- $${triangle.angles[indexAngle].toTexMini()} \\approx ${triangle.angles[indexAngle]
+        .evaluate()
+        .frenchify()} {}^{\\circ} $
+  
+Combien le segment $${triangle.sides[indexSide].toTex()}$ mesure-t-il ? 
+Donner une valeur approchée en degrés avec $${precision}$ décimales.`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { indexSide } = identifiers;
+    const indexAngle = indexSide;
+    const { triangle, sides } = getHydrated(identifiers);
+    const nodeAngleInDegrees = triangle.angles[indexAngle].evaluate().toTree();
+    const nodeAngleInRadians = multiply(nodeAngleInDegrees, frac(PiNode, 180));
+    const nodeLengthSquared = substract(add(power(sides[1].getLengthNode(), 2), power(sides[2].getLengthNode(), 2)), multiply(2, multiply(multiply(sides[1].getLengthNode(), sides[2].getLengthNode()), cos(nodeAngleInRadians))));
+    const nodeLength = sqrt(nodeLengthSquared);
+    return {
+        nodeLengthSquared,
+        nodeLength,
+    };
+};
+const getAnswerNode = (identifiers) => {
+    return getAnswerStuff(identifiers).nodeLength;
+};
+const getAnswer = (identifiers) => {
+    return round(getAnswerNode(identifiers).evaluate(), precision).frenchify();
+};
+const getHint = (identifiers) => {
+    const { triangle } = getHydrated(identifiers);
+    const { indexSide } = identifiers;
+    const indexAngle = indexSide;
+    return `Applique le théorème d'Al Kashi dans le triangle $ABC$ pour l'angle $${triangle.angles[indexAngle].toTexMini()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { indexSide } = identifiers;
+    const indexAngle = indexSide;
+    const { triangle } = getHydrated(identifiers);
+    const sideNames = arrayRotation(triangle.sides, indexAngle)
+        .map((segment) => segment.toInsideName())
+        .map((name) => {
+        return {
+            AB: "c",
+            AC: "b",
+            BC: "a",
+        }[name];
+    });
+    const angleNames = arrayRotation(triangle.angles, indexAngle).map((angle) => angle.toTexMini());
+    const { nodeLengthSquared, nodeLength } = getAnswerStuff(identifiers);
+    return `On applique le théorème d'Al Kashi dans le triangle $ABC$.
+
+On utilise les notations suivantes : 
+
+$$
+a \\ = \\ BC \\ ; \\ b \\ = \\ AC \\ ; \\ c \\ = \\ AB \\ 
+$$
+
+$$
+${sideNames[0]}^2 = ${sideNames[1]}^2 + ${sideNames[2]}^2 - 2 ${sideNames[1]}  ${sideNames[2]}  \\cos(${angleNames[0]})
+$$
+
+Avant de prendre le cosinus, il faut convertir l'angle en radians :
+
+$$
+${angleNames[0]}_{rad} = ${angleNames[0]}_{deg} \\times \\frac{${PiNode.toTex()}}{180}
+$$
+
+$$
+${sideNames[0]}^2 = ${nodeLengthSquared.toTex()}
+$$
+
+$$
+${sideNames[0]} = ${nodeLength.toTex()}
+$$
+
+On arrondit à la toute fin :
+
+$$
+${sideNames[0]}  \\approx ${getAnswer(identifiers)}
+$$
+
+`;
+};
+//too helpful for student ?
+const getGGBOptions = (identifiers) => {
+    const { triangle } = getHydrated(identifiers);
+    // const { indexAngle } = identifiers;
+    // const angle = arrayRotation(triangle.angles, indexAngle)[0];
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //triangle
+            ...triangle.commands,
+            // //angle
+            // `Ang = Angle(${angle.points
+            //   .reverse()
+            //   .map((point) => point.name)
+            //   .join(",")})`,
+            // `ShowLabel(Ang, false)`,
+        ],
+        hideAxes: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(triangle.points),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { indexSide } = identifiers;
+    const indexAngle = indexSide;
+    const { triangle, sides } = getHydrated(identifiers);
+    const answerStuff = getAnswerStuff(identifiers);
+    const arrValueWrong = [];
+    //student: cos(angleInDegrees) instead of cos(angleInRadians)
+    {
+        const nodeAngleInDegrees = triangle.angles[indexAngle].evaluate().toTree();
+        const nodeLengthSquared = substract(add(power(sides[1].getLengthNode(), 2), power(sides[2].getLengthNode(), 2)), multiply(2, multiply(multiply(sides[1].getLengthNode(), sides[2].getLengthNode()), cos(nodeAngleInDegrees))));
+        const nodeLength = sqrt(nodeLengthSquared);
+        const vLength = nodeLength.evaluate();
+        if (vLength > 0) {
+            arrValueWrong.push(vLength);
+            tryToAddWrongProp(propositions, round(vLength, precision).frenchify());
+        }
+    }
+    //student: sign error
+    {
+        const nodeAngleInDegrees = triangle.angles[indexAngle].evaluate().toTree();
+        const nodeAngleInRadians = multiply(nodeAngleInDegrees, frac(PiNode, 180));
+        const nodeLengthSquared = substract(add(power(sides[1].getLengthNode(), 2), power(sides[2].getLengthNode(), 2)), multiply(-2, multiply(multiply(sides[1].getLengthNode(), sides[2].getLengthNode()), cos(nodeAngleInRadians))));
+        const nodeLength = sqrt(nodeLengthSquared);
+        const vLength = nodeLength.evaluate();
+        if (vLength > 0) {
+            arrValueWrong.push(vLength);
+            tryToAddWrongProp(propositions, round(vLength, precision).frenchify());
+        }
+    }
+    //terror: around answer, _most of the time_
+    {
+        const value = (() => {
+            const vAnswer = answerStuff.nodeLength.evaluate();
+            if (probaFlip(0.6)) {
+                return vAnswer;
+            }
+            else {
+                return random([...arrValueWrong, vAnswer]);
+            }
+        })();
+        [...Array(4).keys()].forEach(() => {
+            const valueAnswerOffsetted = value + randfloat(-2, 2, 2, [0]);
+            if (valueAnswerOffsetted > 0) {
+                tryToAddWrongProp(propositions, round(valueAnswerOffsetted, precision).frenchify());
+            }
+        });
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(5, 15, 2).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScalarProductAlKashiSideLengthQuestion = () => {
+    const triangle = TriangleConstructor.randomNiceSides({});
+    const indexSide = randint(0, 3);
+    const identifiers = {
+        triangleIds: triangle.toIdentifiers(),
+        indexSide,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const scalarProductAlKashiSideLength = {
+    id: "scalarProductAlKashiSideLength",
+    connector: "=",
+    label: "Connaissant un angle entre deux longueurs, calculer le côté opposé",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductAlKashiSideLengthQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasGeogebra: true,
+};

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./scalarProductIdentities.js";
+export * from "./scalarProductLamdbaULambdaV.js";
+export * from "./scalarProductInOrthonormalBasisIJ.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alg/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wCAAwC,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/index.js

@@ -0,0 +1,3 @@
+export * from "./scalarProductIdentities.js";
+export * from "./scalarProductLamdbaULambdaV.js";
+export * from "./scalarProductInOrthonormalBasisIJ.js";

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductIdentities.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../../../exercises/exercise.js";
+type Identifiers = {
+    type: number;
+    normU: number;
+    normV: number;
+    udotv: number;
+};
+export declare const scalarProductIdentities: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductIdentities.d.ts.map

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductIdentities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductIdentities.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductIdentities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAkBzD,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductIdentities.js

@@ -0,0 +1,174 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../../math/utils/random/randint.js";
+import { add } from "../../../../../../tree/nodes/operators/addNode.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 { parseAlgebraic } from "../../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-30, 30) + "");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { type, normU, normV, udotv } = identifiers;
+    switch (type) {
+        case 0:
+            return add(square(normU), add(multiply(2, udotv), square(normV)))
+                .simplify()
+                .toTex();
+        case 1:
+            return add(square(normU), add(multiply(-2, udotv), square(normV)))
+                .simplify()
+                .toTex();
+        case 2:
+        default:
+            return substract(square(normU), square(normV)).simplify().toTex();
+    }
+};
+const getStatementNode = (identifiers) => {
+    const { type } = identifiers;
+    const u = "\\overrightarrow u";
+    const v = "\\overrightarrow v";
+    switch (type) {
+        case 0:
+            return square(add(u, v));
+        case 1:
+            return square(substract(u, v));
+        case 2:
+        default:
+            return multiply(add(u, v), substract(u, v));
+    }
+};
+const getInstruction = (identifiers) => {
+    const { normU, normV, udotv } = identifiers;
+    const u = "\\overrightarrow u";
+    const v = "\\overrightarrow v";
+    return `Soit $${u}$ et $${v}$ deux vecteurs tels que $\\lVert ${u}\\rVert = ${normU}$, $\\lVert ${v}\\rVert = ${normV}$ et $${u} \\cdot ${v} = ${udotv}$. 
+  
+Calculer : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Utilise une identité remarquable, puis utilise le fait que pour tout vecteur $\\overrightarrow{u}$ : 
+  
+$$
+\\overrightarrow{u}^2 = \\lVert \\overrightarrow{u} \\rVert^2
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { type, normU, normV, udotv } = identifiers;
+    const u = "\\overrightarrow u";
+    const v = "\\overrightarrow v";
+    const vertU = `\\lVert \\overrightarrow{u} \\rVert`;
+    const vertV = `\\lVert \\overrightarrow{v} \\rVert`;
+    const ps = `${u}\\cdot ${v}`;
+    const statement = getStatementNode(identifiers);
+    const steps = type === 0
+        ? [
+            ["", statement.toTex()],
+            ["=", add(square(u), add(multiply(2, ps), square(v))).toTex()],
+            [
+                "=",
+                add(square(vertU), add(multiply(2, ps), square(vertV))).toTex(),
+            ],
+            [
+                "=",
+                add(square(normU), add(multiply(2, udotv), square(normV))).toTex(),
+            ],
+            ["=", getAnswer(identifiers)],
+        ]
+        : type === 1
+            ? [
+                ["", statement.toTex()],
+                ["=", add(square(u), add(multiply(-2, ps), square(v))).toTex()],
+                [
+                    "=",
+                    add(square(vertU), add(multiply(-2, ps), square(vertV))).toTex(),
+                ],
+                [
+                    "=",
+                    add(square(normU), add(multiply(-2, udotv), square(normV))).toTex(),
+                ],
+                ["=", getAnswer(identifiers)],
+            ]
+            : [
+                ["", statement.toTex()],
+                ["=", substract(square(u), square(v)).toTex()],
+                ["=", substract(square(vertU), square(vertV)).toTex()],
+                ["=", substract(square(normU), square(normV)).toTex()],
+                ["=", getAnswer(identifiers)],
+            ];
+    return `On utilies une identité remarquable, ainsi que le fait que pour tout vecteur $\\overrightarrow{u}$ : 
+  
+$$
+\\overrightarrow{u}^2 = \\lVert \\overrightarrow{u} \\rVert^2
+$$
+
+Cela donne : 
+
+${alignTex(steps)}`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScalarProductIdentitiesQuestion = () => {
+    const type = randint(0, 3);
+    const normU = randint(1, 10);
+    const normV = randint(1, 10);
+    const udotv = randint(-9, 10);
+    const identifiers = {
+        normU,
+        normV,
+        type,
+        udotv,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const scalarProductIdentities = {
+    id: "scalarProductIdentities",
+    connector: "=",
+    label: "Identités remarquables avec des vecteurs (produit scalaire)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductIdentitiesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductInOrthonormalBasisIJ.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsU: NodeIdentifiers[];
+    nodeIdsV: NodeIdentifiers[];
+};
+export declare const scalarProductInOrthonormalBasisIJ: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scalarProductInOrthonormalBasisIJ.d.ts.map

package/lib/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductInOrthonormalBasisIJ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductInOrthonormalBasisIJ.d.ts","sourceRoot":"","sources":["../../../../../../../src/exercises/math/geometry/vectors/scalarProduct/alg/scalarProductInOrthonormalBasisIJ.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AA+PF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAsBnE,CAAC"}