math-exercises 3.0.157 → 3.0.159

package/lib/exercises/math/trigonometry/triangle/trigonometrySohcahtoaUse.js

@@ -0,0 +1,386 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { RightTriangleConstructor } from "../../../../math/geometry/triangles/rightTriangle.js";
+import { TriangleConstructor, } from "../../../../math/geometry/triangles/triangle.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { getAllPicks } from "../../../../utils/arrays/getAllPicks.js";
+const trigoFuncsDict = {
+    sin: {
+        id: "sin",
+        strFrench: "sinus",
+        funcTex: (content) => `\\sin(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [1, 0];
+                case 2:
+                    return [2, 0];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\sin(\\text{angle}) = \\frac{\\text{opposé}}{\\text{hypoténuse}}",
+    },
+    cos: {
+        id: "cos",
+        strFrench: "cosinus",
+        funcTex: (content) => `\\cos(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [2, 0];
+                case 2:
+                    return [1, 0];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\cos(\\text{angle}) = \\frac{\\text{adjacent}}{\\text{hypoténuse}}",
+    },
+    tan: {
+        id: "tan",
+        strFrench: "tangente",
+        funcTex: (content) => `\\tan(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [1, 2];
+                case 2:
+                    return [2, 1];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\tan(\\text{angle}) = \\frac{\\text{opposé}}{\\text{adjacent}}",
+    },
+};
+const getTrigoFuncEntryForTargetAngle = (indexTarget, indexesGivenSegments) => {
+    return Object.entries(trigoFuncsDict).find(([_, trigoFunc]) => {
+        const indexesSegment = trigoFunc.funcIndexesSegment(indexTarget);
+        return ([...new Set([...indexesSegment, ...indexesGivenSegments])].length === 2);
+    });
+};
+const getTrigoFuncEntryForTargetSide = (indexTarget, indexGivenSegment, indexGivenAngle) => {
+    return Object.entries(trigoFuncsDict).find(([_, trigoFunc]) => {
+        const indexesSegment = trigoFunc.funcIndexesSegment(indexGivenAngle);
+        return ([...new Set([...indexesSegment, ...[indexTarget, indexGivenSegment]])]
+            .length === 2);
+    });
+};
+const getTrigoFuncAndIndexesSegmentDict = (targetType, indexTarget, indexesGivenSegments, indexGivenAngle) => {
+    let trigoFunc;
+    let indexesSegment;
+    switch (targetType) {
+        case "angle":
+            {
+                [, trigoFunc] = getTrigoFuncEntryForTargetAngle(indexTarget, indexesGivenSegments);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexTarget);
+            }
+            break;
+        case "segment":
+            {
+                [, trigoFunc] = getTrigoFuncEntryForTargetSide(indexTarget, indexesGivenSegments[0], indexGivenAngle);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexGivenAngle);
+            }
+            break;
+    }
+    return { trigoFunc, indexesSegment };
+};
+const getInstruction = (identifiers) => {
+    const { targetType, indexTarget, triangleIdentifiers, indexesGivenSegments, indexGivenAngle, } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    switch (identifiers.questionType) {
+        case "frac":
+            {
+                switch (targetType) {
+                    case "angle": {
+                        const texAngle = `\\widehat{${triangle.points[indexTarget].toTex()}}`;
+                        return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la longueur $${triangle.sides[indexesGivenSegments[1]].toInsideName()}$. Quel rapport trigonométrique doit-on utiliser pour calculer la mesure de $${texAngle}$ ?`;
+                    }
+                    case "segment": {
+                        return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la mesure de l'angle $\\widehat{${triangle.points[indexGivenAngle].toTex()}}$. Quel rapport trigonométrique doit-on utiliser pour calculer la longueur $${triangle.sides[indexTarget].toInsideName()}$ ?`;
+                    }
+                }
+            }
+            break;
+        case "func": {
+            switch (targetType) {
+                case "angle": {
+                    const texAngle = `\\widehat{${triangle.points[indexTarget].toTex()}}`;
+                    return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la longueur $${triangle.sides[indexesGivenSegments[1]].toInsideName()}$. Quelle fonction trigonométrique doit-on utiliser pour calculer la mesure de $${texAngle}$ ?`;
+                }
+                case "segment": {
+                    return `Dans le triangle $${triangle.name}$ ci-dessous, on connaît la longueur $${triangle.sides[indexesGivenSegments[0]].toInsideName()}$ et la mesure de l'angle $\\widehat{${triangle.points[indexGivenAngle].toTex()}}$. Quelle fonction trigonométrique doit-on utiliser pour calculer la longueur $${triangle.sides[indexTarget].toInsideName()}$ ?`;
+                }
+            }
+        }
+    }
+};
+const getAnswerNode = (identifiers) => {
+    const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments, triangleIdentifiers, } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    let indexesSegment;
+    switch (targetType) {
+        case "angle":
+            {
+                const [, trigoFunc] = getTrigoFuncEntryForTargetAngle(indexTarget, indexesGivenSegments);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexTarget);
+            }
+            break;
+        case "segment":
+            {
+                const [, trigoFunc] = getTrigoFuncEntryForTargetSide(indexTarget, indexesGivenSegments[0], indexGivenAngle);
+                indexesSegment = trigoFunc.funcIndexesSegment(indexGivenAngle);
+            }
+            break;
+    }
+    const [nodeNum, nodeDen] = indexesSegment.map((indexSegment) => new VariableNode(`${triangle.sides[indexSegment].toInsideName()}`));
+    const fractionNode = frac(nodeNum, nodeDen);
+    return fractionNode;
+};
+const getAnswer = (identifiers) => {
+    switch (identifiers.questionType) {
+        case "frac": {
+            return getAnswerNode(identifiers).toTex();
+        }
+        case "func": {
+            const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments } = identifiers;
+            const { trigoFunc } = getTrigoFuncAndIndexesSegmentDict(targetType, indexTarget, indexesGivenSegments, indexGivenAngle);
+            const nameTrigoFunc = trigoFunc.id;
+            const tex = `\\text{${nameTrigoFunc}}`;
+            return tex;
+        }
+    }
+};
+const getHint = () => {
+    return `Identifie le côté opposé, le côté adjacent et l'hypoténuse du triangle. Puis cherche la bonne formule de trigonométrie, en te rappelant de : 
+  
+$$
+\\text{SOHCAHTOA}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments, triangleIdentifiers, } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const { trigoFunc, indexesSegment } = getTrigoFuncAndIndexesSegmentDict(targetType, indexTarget, indexesGivenSegments, indexGivenAngle);
+    const [segmentNum, segmentDen] = indexesSegment.map((i) => triangle.sides[i]);
+    const [nameNum, nameDen] = [segmentNum, segmentDen].map((segment) => `${segment.pointA.name}${segment.pointB.name}`);
+    const texAngle = `\\widehat{${triangle.points[indexGivenAngle ?? indexTarget].toTex()}}`;
+    return `On a :
+  
+$$
+${trigoFunc.funcTex(texAngle)} = \\frac{${nameNum}}{${nameDen}}
+$$
+
+${(() => {
+        switch (identifiers.questionType) {
+            case "frac": {
+                return `Le rapport recherché est $${`\\frac{${nameNum}}{${nameDen}}`}$.`;
+            }
+            case "func": {
+                return `La fonction recherchée est la fonction ${trigoFunc.strFrench}.`;
+            }
+        }
+    })()}`;
+};
+const getGGBOptions = (identifiers) => {
+    const { targetType, indexTarget, indexGivenAngle, indexesGivenSegments, triangleIdentifiers, } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    switch (targetType) {
+        case "angle":
+            {
+                //target
+                triangle.highlightAngle(indexTarget, {
+                    color: blueMain,
+                    showValue: false,
+                });
+                //given
+                indexesGivenSegments.forEach((indexSegment) => {
+                    triangle.highlightSide(indexSegment, { color: red });
+                });
+            }
+            break;
+        case "segment":
+            {
+                //target
+                triangle.highlightSide(indexTarget, {
+                    color: blueMain,
+                });
+                //given
+                if (indexGivenAngle) {
+                    triangle.highlightAngle(indexGivenAngle, {
+                        color: red,
+                        showValue: false,
+                    });
+                }
+                indexesGivenSegments.forEach((indexSegment) => {
+                    triangle.highlightSide(indexSegment, { color: red });
+                });
+            }
+            break;
+    }
+    const ggb = new GeogebraConstructor({
+        commands: triangle.commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    switch (identifiers.questionType) {
+        case "frac": {
+            const { triangleIdentifiers } = identifiers;
+            const propositions = [];
+            const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+            addValidProp(propositions, answer);
+            getAllPicks([0, 1, 2])
+                .filter((arrSegment) => arrSegment.length === 2)
+                .forEach((indexesSegment) => {
+                const [nodeNum, nodeDen] = indexesSegment.map((indexSegment) => new VariableNode(`${triangle.sides[indexSegment].toInsideName()}`));
+                const fractionNode1 = frac(nodeNum, nodeDen);
+                tryToAddWrongProp(propositions, fractionNode1.toTex());
+                const fractionNode2 = frac(nodeDen, nodeNum);
+                tryToAddWrongProp(propositions, fractionNode2.toTex());
+            });
+            return shuffleProps(propositions, n);
+        }
+        case "func": {
+            const propositions = [];
+            ["sin", "cos", "tan"].forEach((nameTrigoFunc) => {
+                const tex = `\\text{${nameTrigoFunc}}`;
+                if (tex === answer) {
+                    addValidProp(propositions, tex);
+                }
+                else {
+                    tryToAddWrongProp(propositions, tex);
+                }
+            });
+            return shuffle(propositions);
+        }
+    }
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getKeys = (identifiers) => {
+    switch (identifiers.questionType) {
+        case "frac": {
+            const { triangleIdentifiers } = identifiers;
+            const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+            return [
+                ...triangle.sides.map((side) => {
+                    const strLength = side.toInsideName();
+                    return {
+                        id: "custom",
+                        label: strLength,
+                        labelType: "tex",
+                        mathfieldInstructions: {
+                            method: "write",
+                            content: strLength,
+                        },
+                    };
+                }),
+            ];
+        }
+        case "func": {
+            return ["sin", "cos", "tan"];
+        }
+    }
+};
+const getTrigonometrySohcahtoaUseQuestion = (optsIn) => {
+    const targetTypes = optsIn?.targetTypes ?? optsDefault.targetTypes;
+    const opts = Object.assign(optsIn, { targetTypes });
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const targetType = random(targetTypes);
+    const indexTarget = randint(1, 3);
+    let indexGivenAngle;
+    const indexesGivenSegments = [];
+    switch (targetType) {
+        case "angle":
+            {
+                indexesGivenSegments.push(...randomMany([0, 1, 2], 2));
+            }
+            break;
+        case "segment":
+            {
+                indexGivenAngle = randint(1, 3);
+                indexesGivenSegments.push(3 - indexTarget);
+            }
+            break;
+    }
+    const identifiers = {
+        questionType: opts.questionType,
+        targetType,
+        indexTarget,
+        indexGivenAngle,
+        indexesGivenSegments,
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        options: opts,
+    };
+};
+const optsDefault = {
+    targetTypes: ["angle", "segment"],
+};
+const options = [
+    {
+        id: "targetType",
+        label: "Mesure recherchée",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["angle", "segment"],
+        defaultValue: optsDefault.targetTypes,
+    },
+];
+export const trigonometrySohcahtoaUseFrac = {
+    id: "trigonometrySohcahtoaUseFrac",
+    label: "Utiliser le bon rapport trigonométrique pour calculer la mesure d'un angle ou d'un segment",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigonometrySohcahtoaUseQuestion(Object.assign({}, { questionType: "frac" }, opts)), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};
+export const trigonometrySohcahtoaUseFunc = {
+    id: "trigonometrySohcahtoaUseFunc",
+    label: "Utiliser la bonne fonction trigonométrique pour calculer la mesure d'un angle ou d'un segment",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigonometrySohcahtoaUseQuestion(Object.assign({}, { questionType: "func" }, opts)), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+};

package/lib/exercises/pc/mathExosInPC.d.ts

@@ -25,6 +25,6 @@ export * from "../math/derivation/derivative/polynomial/usualderivative.js";
 export { thirdDegreeDerivative } from "../math/derivation/derivative/polynomial/thirdDegreeDerivative.js";
 export { firstDegreeDerivative } from "../math/derivation/derivative/polynomial/firstDegreeDerivative.js";
 export { secondDegreeDerivative } from "../math/derivation/derivative/polynomial/secondDegreeDerivative.js";
-export * from "../math/trigonometry/trigonometrySideCalcul.js";
-export * from "../math/trigonometry/trigonometryAngleCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometrySideCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometryAngleCalcul.js";
 //# sourceMappingURL=mathExosInPC.d.ts.map

package/lib/exercises/pc/mathExosInPC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mathExosInPC.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/mathExosInPC.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,cAAc,mCAAmC,CAAC;AAClD,cAAc,wDAAwD,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,uCAAuC,CAAC;AACtD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC;AAC9E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,6DAA6D,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,oEAAoE,CAAC;AAC5G,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iDAAiD,CAAC"}
+{"version":3,"file":"mathExosInPC.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/mathExosInPC.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,cAAc,mCAAmC,CAAC;AAClD,cAAc,wDAAwD,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,uCAAuC,CAAC;AACtD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC;AAC9E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,6DAA6D,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,oEAAoE,CAAC;AAC5G,cAAc,yDAAyD,CAAC;AACxE,cAAc,0DAA0D,CAAC"}

package/lib/exercises/pc/mathExosInPC.js

@@ -25,5 +25,5 @@ export * from "../math/derivation/derivative/polynomial/usualderivative.js";
 export { thirdDegreeDerivative } from "../math/derivation/derivative/polynomial/thirdDegreeDerivative.js";
 export { firstDegreeDerivative } from "../math/derivation/derivative/polynomial/firstDegreeDerivative.js";
 export { secondDegreeDerivative } from "../math/derivation/derivative/polynomial/secondDegreeDerivative.js";
-export * from "../math/trigonometry/trigonometrySideCalcul.js";
-export * from "../math/trigonometry/trigonometryAngleCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometrySideCalcul.js";
+export * from "../math/trigonometry/triangle/trigonometryAngleCalcul.js";

package/lib/exercises/vea/cartesianLineVEA.d.ts

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

package/lib/exercises/vea/cartesianLineVEA.d.ts.map

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

package/lib/exercises/vea/cartesianLineVEA.js

@@ -0,0 +1 @@
+export {};