math-exercises 3.0.214 → 3.0.215

package/lib/exercises/math/complex/geometric/complexGeomAffixTrigFromPoint.js

@@ -0,0 +1,485 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueDark, colorWithOpacity } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { createTypeAngleSectorNWSESecondary } from "../../../../math/utils/geometry/angleNWSE.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 { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { isSqrtNode, sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac, isFractionNode, } 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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+//TODO: frac does not simplify "i"
+// const nodeI = new ComplexNode((0).toTree(), (1).toTree());
+const nodeI = new VariableNode("i");
+const _degreesToRadians = (angleInDegrees, precision) => {
+    const oneOver180 = 0.00555555555555555;
+    return round(multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(), precision);
+};
+const rotateVector = (vec, angle, name) => {
+    //x' = cos(t)*x -sin(t)*y
+    //y' = sin(t)*x + cos(t)*y
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return new Vector(name, substract(multiply(cos, vec.x), multiply(sin, vec.y)).evaluate().toTree(), add(multiply(sin, vec.x), multiply(cos, vec.y)).evaluate().toTree());
+};
+const rotatePoint = (target, angle, center, name, precision = 2) => {
+    const vSrc = createVector(center, target, "vSrc", precision);
+    const vRotated = rotateVector(vSrc, angle, "vRotated");
+    return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
+};
+const createVector = (from, to, name, precision = 5) => {
+    return new Vector(name, round(substract(to.x, from.x).evaluate(), precision).toTree(), round(substract(to.y, from.y).evaluate(), precision).toTree());
+};
+const createPoint = (x, y, name, precision = 5) => {
+    return new Point(name, round(x, precision), round(y, precision));
+};
+const getHydrated = (identifiers) => {
+    const { nodeIdsModule, nodeIdsArgument, isAngleInDegrees } = identifiers;
+    const [nodeModule, nodeArgument] = [nodeIdsModule, nodeIdsArgument].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeArgumentSimplified = nodeArgument.simplify({
+        towardsDistribute: false,
+    });
+    const nodeAngleInDegrees = isAngleInDegrees
+        ? multiply(frac(180, PiNode), nodeArgument).simplify({
+            towardsDistribute: false,
+        })
+        : undefined;
+    const nodeAffixTrig = (() => {
+        const nodeArgumentUsed = isAngleInDegrees
+            ? nodeArgument
+            : nodeArgumentSimplified;
+        return multiply(nodeModule, add(cos(nodeArgumentUsed), multiply(nodeI, sin(nodeArgumentUsed))));
+    })();
+    return {
+        nodeModule,
+        nodeArgument,
+        nodeArgumentSimplified,
+        nodeAngleInDegrees,
+        nodeAffixTrig,
+    };
+};
+const getInstruction = (_identifiers) => {
+    return `Donner l'affixe du point $M$, sous forme trigonométrique.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeAffixTrig } = getHydrated(identifiers);
+    return nodeAffixTrig;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { isAngleInDegrees } = identifiers;
+    return `Soit $z$ l'affixe du point $M$. 
+L'écriture sous forme trigonométrique de $z$ est :
+  
+$$
+m (\\cos(\\alpha) + i \\sin(\\alpha))
+$$
+
+avec $m$ le module de $z$ et $\\alpha$ un argument de $z$.
+
+Le module de $z$ est la distance du point $M$ à l'origine $O$.
+L'argument principal de $z$ est l'angle orienté $(\\overrightarrow{OM}, \\overrightarrow{u})$, avec $\\overrightarrow{u}$ le vecteur unitaire de l'axe des réels.
+
+${(() => {
+        if (isAngleInDegrees) {
+            return "Attention à bien convertir l'angle donné en degrés en un angle en radians.";
+        }
+        else {
+            return "";
+        }
+    })()}
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { isAngleInDegrees } = identifiers;
+    const { nodeModule, nodeArgument, nodeArgumentSimplified, nodeAffixTrig } = getHydrated(identifiers);
+    return `Soit $z$ l'affixe du point $M$.
+  
+On lit : 
+
+$$
+\\lvert z \\rvert = ${nodeModule.toTex()}
+$$
+
+${(() => {
+        if (isAngleInDegrees) {
+            return `On convertit l'angle donné en degrés en un angle en radians :
+    
+$$
+\\arg(z) = ${nodeArgument.toTex()}
+$$
+    
+`;
+        }
+        else {
+            return `
+    
+$$
+\\arg(z) = ${nodeArgumentSimplified.toTex()}
+$$
+
+`;
+        }
+    })()}
+
+  
+L'affixe du point $M$ est donc $${nodeAffixTrig.toTex()}$.`;
+};
+const getGGBOptions = (identifiers, _optsIn) => {
+    const { isAngleInDegrees } = identifiers;
+    const { nodeArgumentSimplified, nodeModule, nodeAngleInDegrees } = getHydrated(identifiers);
+    const pointO = new Point("O", 0, 0);
+    const pointA = new Point("A", 1, 0);
+    const precision = 5;
+    const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const pointAM = new Point("AM", nodeModule, 0);
+    const pointM = rotatePoint(pointAM, nodeArgumentSimplified.evaluate(), pointO, "M", precision);
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        xAxis: {
+            hideNumbers: true,
+        },
+        yAxis: {
+            hideNumbers: true,
+        },
+        commands: [
+            //pointO
+            ...[
+                `O = ${pointO.toMathString()}`,
+                `SetFixed(O, true, false)`,
+                `ShowLabel(O, true)`,
+            ],
+            //pointM
+            ...[
+                `M = ${pointM.toMathString()}`,
+                `SetFixed(M, true, false)`,
+                `ShowLabel(M, true)`,
+            ],
+            //radius
+            ...(() => {
+                const valueNodeArgumentSimplified = nodeArgumentSimplified.evaluate();
+                function createStrCaptionSpacing(valueAngle) {
+                    const typeAngleSector = createTypeAngleSectorNWSESecondary(valueAngle);
+                    switch (typeAngleSector) {
+                        case "WSW":
+                            return "\\\\ \\\\ \\ \\ \\ \\ ";
+                        case "SSW":
+                            return "\\ \\ \\ \\ ";
+                        case "SSE":
+                            return "\\\\ \\\\ \\\\ ";
+                        case "ESE":
+                        case "ENE":
+                            return "\\\\ \\\\ ";
+                        case "NNE":
+                        case "NNW":
+                        case "WNW":
+                            return "\\ ";
+                    }
+                }
+                const strCaptionSpacing = createStrCaptionSpacing(valueNodeArgumentSimplified);
+                return [
+                    `segRadius = Segment(${pointO.toMathString()}, ${pointM.toMathString()})`,
+                    `SetColor(segRadius, ${strLineColor})`,
+                    `SetLineThickness(segRadius, 5)`,
+                    `SetLineStyle(segRadius, 2)`,
+                    `SetCaption(segRadius, "$${strCaptionSpacing} \\footnotesize{${nodeModule.toTex()}}$")`,
+                    `ShowLabel(segRadius, true)`,
+                ];
+            })(),
+            //argument
+            ...(() => {
+                const valueNodeArgumentSimplified = nodeArgumentSimplified.evaluate();
+                function createStrCaptionSpacing(valueAngle) {
+                    const typeAngleSector = createTypeAngleSectorNWSESecondary(valueAngle);
+                    switch (typeAngleSector) {
+                        case "SSE":
+                            return "\\\\ \\ \\ \\ \\ ";
+                        case "ESE": {
+                            if (createTypeAngleSectorNWSESecondary(valueAngle - 0.4) === "SSE") {
+                                return "\\\\ \\ \\ \\ \\ ";
+                            }
+                            else {
+                                return "\\\\ \\\\ \\\\ \\\\ ";
+                            }
+                        }
+                        default:
+                            return "\\\\ \\\\ \\\\ \\ \\ \\ \\ ";
+                    }
+                }
+                const strCaptionSpacing = createStrCaptionSpacing(valueNodeArgumentSimplified);
+                const isClockwise = valueNodeArgumentSimplified > 0;
+                return [
+                    `rayOA = Ray(${pointO.toMathString()}, ${pointA.toMathString()})`,
+                    `rayOM = Ray(${pointO.toMathString()}, ${pointM.toMathString()})`,
+                    `SetVisibleInView(rayOA, 1, false)`,
+                    `SetVisibleInView(rayOM, 1, false)`,
+                    `angArg = ${isClockwise ? "Angle(rayOA, rayOM)" : "Angle(rayOM, rayOA)"}`,
+                    `SetDecoration(angArg, ${isClockwise ? 6 : 7})`,
+                    `SetColor(angArg, "${blueDark}")`,
+                    `SetCaption(angArg, "$${strCaptionSpacing}\\footnotesize{${(() => {
+                        if (isAngleInDegrees) {
+                            return `${nodeAngleInDegrees.toTex()}°`;
+                        }
+                        else {
+                            return `${nodeArgumentSimplified.toTex()}`;
+                        }
+                    })()}}$")`,
+                    `ShowLabel(angArg, true)`,
+                ];
+            })(),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([pointO, pointM]),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }, _optsIn) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { isAngleInDegrees } = identifiers;
+    const { nodeModule: nodeModulePure, nodeAngleInDegrees, nodeArgumentSimplified, } = getHydrated(identifiers);
+    function createNodeAffixTrig(nodeModule, nodeArgument) {
+        const nodeAffixTrig = multiply(nodeModule, add(cos(nodeArgument), multiply(nodeI, sin(nodeArgument))));
+        return nodeAffixTrig;
+    }
+    //student: reprocesses read module: module becomes sqrt(...)
+    {
+        if (!isSqrtNode(nodeModulePure) && !isFractionNode(nodeModulePure)) {
+            const nodeModuleWrong = sqrt(nodeModulePure);
+            const nodeAffixTrigWrong = createNodeAffixTrig(nodeModuleWrong, nodeArgumentSimplified);
+            tryToAddWrongProp(propositions, nodeAffixTrigWrong.toTex());
+        }
+    }
+    const isTerrorWrtModule = probaFlip(0.39);
+    const nodeModule = (() => {
+        if (isTerrorWrtModule) {
+            if (isSqrtNode(nodeModulePure)) {
+                return square(nodeModulePure).simplify({
+                    calculatePowers: true,
+                });
+            }
+            else if (isFractionNode(nodeModulePure)) {
+                return nodeModulePure;
+            }
+            else {
+                return sqrt(nodeModulePure);
+            }
+        }
+        else {
+            return nodeModulePure;
+        }
+    })();
+    //student: module <-> argument
+    {
+        const nodeAffixTrigWrong = createNodeAffixTrig(nodeArgumentSimplified, nodeModule);
+        tryToAddWrongProp(propositions, nodeAffixTrigWrong.toTex());
+    }
+    if (isAngleInDegrees) {
+        const nodeAngleInDeg = nodeAngleInDegrees;
+        //student: forgets to convert to radians
+        {
+            const nodeAffixWrong = multiply(nodeModule, add(cos(nodeAngleInDeg), multiply(nodeI, sin(nodeAngleInDeg))));
+            tryToAddWrongProp(propositions, nodeAffixWrong.toTex());
+        }
+        //student: converts badly to radians
+        {
+            const nodeArgumentWrong = multiply(nodeAngleInDeg, frac(180, PiNode));
+            const nodeAffixWrong = multiply(nodeModule, add(cos(nodeArgumentWrong), multiply(nodeI, sin(nodeArgumentWrong))));
+            tryToAddWrongProp(propositions, nodeAffixWrong.toTex());
+        }
+    }
+    //student: |z|(cos + i sin) -> |z|cos + i sin
+    {
+        const nodeAffixWrong = add(multiply(nodeModule, cos(nodeArgumentSimplified)), sin(nodeArgumentSimplified));
+        tryToAddWrongProp(propositions, nodeAffixWrong.toTex());
+    }
+    //student: module -> 1
+    {
+        const nodeAffixTrigWrong = add(cos(nodeArgumentSimplified), multiply(nodeI, sin(nodeArgumentSimplified)));
+        tryToAddWrongProp(propositions, nodeAffixTrigWrong.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["cos", "sin", "pi"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeI = new VariableNode("i");
+        //todo: parse complex numbers
+        //todo: use regexps on algebraicNodes
+        const [nodeXAns, nodeYAns] = (() => {
+            const nodeXAns = nodeBySubstitutingVar(nodeAns, (0).toTree(), nodeI).simplify();
+            //pour chopper le terme en i...
+            const nodeYAns = nodeBySubstitutingVar(substract(nodeAns, nodeXAns), (1).toTree(), nodeI).simplify();
+            return [nodeXAns, nodeYAns];
+        })();
+        const { nodeModule, nodeArgument } = getHydrated(identifiers);
+        const nodeX = multiply(nodeModule, cos(nodeArgument));
+        const nodeY = multiply(nodeModule, sin(nodeArgument));
+        return (NodeComparator.isEqualViaSub(nodeXAns, nodeX) &&
+            NodeComparator.isEqualViaSub(nodeYAns, nodeY));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+// const createRandomIdentifiers = (opts: Options) => {};
+const getComplexGeomAffixTrigFromPointQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const isAngleInDegrees = opts.isAngleInDegrees;
+    const [_nodeAngleBase, nodeArgumentM] = (() => {
+        if (isAngleInDegrees) {
+            const nodeAngleBase = frac(PiNode, 180);
+            const vAbsAngleInDegrees = coinFlip()
+                ? randint(10, 82)
+                : randint(108, 172);
+            const vFactor = (coinFlip() ? +1 : -1) * vAbsAngleInDegrees;
+            const nodeAngleM = multiply(vFactor, nodeAngleBase);
+            return [nodeAngleBase, nodeAngleM];
+        }
+        else {
+            const rand = randint(0, 5);
+            switch (rand) {
+                case 0: {
+                    const nodeAngleBase = frac(PiNode, 18);
+                    const vFactor = (coinFlip() ? +1 : -1) * randint(1, 18, [9]);
+                    const nodeAngleM = multiply(vFactor, nodeAngleBase).simplify({
+                        towardsDistribute: false,
+                    });
+                    return [nodeAngleBase, nodeAngleM];
+                }
+                case 1: {
+                    const nodeAngleBase = frac(PiNode, 9);
+                    const vFactor = (coinFlip() ? +1 : -1) * randint(1, 9);
+                    const nodeAngleM = multiply(vFactor, nodeAngleBase).simplify({
+                        towardsDistribute: false,
+                    });
+                    return [nodeAngleBase, nodeAngleM];
+                }
+                case 2: {
+                    const nodeAngleBase = frac(PiNode, 6);
+                    const vFactor = (coinFlip() ? +1 : -1) * randint(1, 6, [3]);
+                    const nodeAngleM = multiply(vFactor, nodeAngleBase).simplify({
+                        towardsDistribute: false,
+                    });
+                    return [nodeAngleBase, nodeAngleM];
+                }
+                case 3: {
+                    const nodeAngleBase = frac(multiply(2, PiNode), 9);
+                    const vFactor = (coinFlip() ? +1 : -1) * randint(1, 5);
+                    const nodeAngleM = multiply(vFactor, nodeAngleBase).simplify({
+                        towardsDistribute: false,
+                    });
+                    return [nodeAngleBase, nodeAngleM];
+                }
+                case 4: {
+                    const nodeAngleBase = frac(PiNode, 3);
+                    const vFactor = (coinFlip() ? +1 : -1) * randint(1, 3);
+                    const nodeAngleM = multiply(vFactor, nodeAngleBase).simplify({
+                        towardsDistribute: false,
+                    });
+                    return [nodeAngleBase, nodeAngleM];
+                }
+                default:
+                    throw new Error("Unsupported rand: " + rand);
+            }
+        }
+    })();
+    const nodeModuleM = (() => {
+        const rand = randint(0, 3);
+        switch (rand) {
+            case 0:
+                //integer
+                return randint(2, 5).toTree();
+            case 1:
+                //float
+                return randfloat(2, 4, 1).toTree();
+            case 2: {
+                //sqrt
+                const valueInt = random([2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 14]);
+                return sqrt(valueInt);
+            }
+            case 3: {
+                //frac
+                return random([frac(1, 2), frac(2, 3), frac(3, 2)]);
+            }
+            case 4: {
+                //frac(sqrt)
+                return random([frac(sqrt(2), 2), frac(sqrt(3), 2), frac(sqrt(5), 2)]);
+            }
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    })();
+    const identifiers = {
+        nodeIdsModule: nodeModuleM.toIdentifiers(),
+        nodeIdsArgument: nodeArgumentM.toIdentifiers(),
+        isAngleInDegrees,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        // correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    isAngleInDegrees: false,
+};
+const options = [
+    {
+        id: "isAngleInDegrees",
+        label: "Angle en degrés ?",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isAngleInDegrees,
+    },
+];
+export const complexGeomAffixTrigFromPoint = {
+    id: "complexGeomAffixTrigFromPoint",
+    label: "Déterminer l'affixe d'un point sous forme trigonométrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomAffixTrigFromPointQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

package/lib/exercises/math/complex/geometric/complexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrig.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    pointIdsA: PointIdentifiers;
+    nodeIdsModule: NodeIdentifiers;
+    nodeIdsArgument: NodeIdentifiers;
+    isCosAsked: boolean;
+};
+export declare const complexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrig: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrig.d.ts.map

package/lib/exercises/math/complex/geometric/complexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrig.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrig.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiC7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,aAAa,EAAE,eAAe,CAAC;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAyQF,eAAO,MAAM,sDAAsD,EAAE,QAAQ,CAAC,WAAW,CAsBtF,CAAC"}