math-exercises 3.0.214 → 3.0.215

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

@@ -0,0 +1,539 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { blueMain, colorWithOpacity, orange } 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 { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { exp, isExpNode } from "../../../../tree/nodes/functions/expNode.js";
+import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.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 { isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.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, nodeIdsAngleBase } = identifiers;
+    const [nodeModule, nodeArgument, nodeAngleBase] = [
+        nodeIdsModule,
+        nodeIdsArgument,
+        nodeIdsAngleBase,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const vFactor = frac(nodeArgument, nodeAngleBase)
+        .simplify({ towardsDistribute: false })
+        .evaluate();
+    const nodeAffix = multiply(nodeModule, exp(multiply(nodeI, nodeArgument)));
+    const nodeAffixSimplified = multiply(nodeModule, exp(multiply(nodeI, nodeArgument.simplify({ towardsDistribute: true }))));
+    return {
+        nodeAngleBase,
+        nodeModule,
+        nodeArgument,
+        vFactor,
+        nodeAffix,
+        nodeAffixSimplified,
+    };
+};
+const getInstruction = (_identifiers) => {
+    return `Donner l'affixe du point $M$, sous forme exponentielle.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeAffixSimplified } = getHydrated(identifiers);
+    return nodeAffixSimplified;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Soit $z$ l'affixe du point $M$. 
+L'écriture sous forme exponentielle de $z$ est :
+  
+$$
+m \\ e^{i \\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.  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeModule, nodeArgument, nodeAngleBase, nodeAffixSimplified } = getHydrated(identifiers);
+    const nodeArgumentSimplified = nodeArgument.simplify({
+        towardsDistribute: false,
+    });
+    const [texArgument, texArgumentSimplified] = [
+        nodeArgument,
+        nodeArgumentSimplified,
+    ].map((node) => node.toTex());
+    return `Le point $M$ appartient au cercle centré sur l'origine et de rayon $${nodeModule.toTex()}$. 
+Son module est donc $${nodeModule.toTex()}$.
+On lit son argument principal en comptant les graduations d'angle. 
+La graduation pour les angles est $${nodeAngleBase.toTex()}$. 
+L'argument principal est $${texArgument} ${texArgumentSimplified !== texArgument ? `= ${texArgumentSimplified}` : ""}$.
+  
+L'affixe du point $M$ est donc $${nodeAffixSimplified.toTex()}$.`;
+};
+const _getCorrectionGGBOptions = (identifiers) => {
+    const { nodeAngleBase, nodeArgument, nodeModule } = getHydrated(identifiers);
+    const nbRays = frac(multiply(2, PiNode), nodeAngleBase)
+        .simplify({ towardsDistribute: false })
+        .evaluate();
+    const arrNodeAngle = [...Array(nbRays).keys()].map((i) => multiply(i, nodeAngleBase));
+    const pointO = new Point("O", 0, 0);
+    const pointA = new Point("A", 1, 0);
+    const precision = 5;
+    const arrPointForAngle = arrNodeAngle.map((nodeAngle, i) => rotatePoint(pointA, nodeAngle.evaluate(), pointO, `PA${i}`, precision));
+    const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const pointAM = new Point("AM", nodeModule, 0);
+    const pointM = rotatePoint(pointAM, nodeArgument.evaluate(), pointO, "M", precision);
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            //circles
+            ...[...Array(4).keys()]
+                .map((i) => i + 1)
+                .flatMap((v, i) => [
+                `c${i} = Circle((0,0), ${v})`,
+                // `SetColor(c${i}, ${strLineColor})`,
+                `SetLineThickness(c${i}, 1)`,
+            ]),
+            //rays
+            ...arrPointForAngle.flatMap((point, i) => [
+                `ray${i} = Ray(${pointO.toMathString()}, ${point.toMathString()})`,
+                `SetColor(ray${i}, ${strLineColor})`,
+                `SetLineThickness(ray${i}, 1)`,
+            ]),
+            //pointM
+            ...[
+                `M = ${pointM.toMathString()}`,
+                `SetFixed(M, true, false)`,
+                `ShowLabel(M, true)`,
+            ],
+            //angle
+            ...[
+                `rayM = Ray(${pointO.toMathString()}, ${arrPointForAngle[1].toMathString()})`,
+                `SetVisibleInView(rayM, 1, false)`,
+                `ang = Angle(ray0, rayM)`,
+                `SetCaption(ang, "$\\\\ \\\\ \\ \\ ${nodeAngleBase.toTex()}$")`,
+                `ShowLabel(ang, true)`,
+            ],
+            //pointO
+            ...[
+                `O = ${pointO.toMathString()}`,
+                `SetFixed(O, true, false)`,
+                `ShowLabel(O, true)`,
+            ],
+            //vecU
+            ...[
+                `vecU = Vector(${pointO.toMathString()}, ${pointA.toMathString()})`,
+                `SetCaption(vecU, "$\\overrightarrow{u}$")`,
+                `ShowLabel(vecU, true)`,
+                `SetColor(vecU, "${blueMain}")`,
+            ],
+            //argument
+            ...(() => {
+                const isClockwise = nodeArgument.evaluate() > 0;
+                return [
+                    `rayOAM = Ray(${pointO.toMathString()}, ${pointAM.toMathString()})`,
+                    `rayOM = Ray(${pointO.toMathString()}, ${pointM.toMathString()})`,
+                    `SetVisibleInView(rayOAM, 1, false)`,
+                    `SetVisibleInView(rayOM, 1, false)`,
+                    `angArg = ${isClockwise ? "Angle(rayOAM, rayOM)" : "Angle(rayOM, rayOAM)"}`,
+                    `ShowLabel(angArg, false)`,
+                    `SetDecoration(angArg, ${isClockwise ? 6 : 7})`,
+                    `SetColor(angArg, "${orange}")`,
+                ];
+            })(),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: [-4.1, 4.1, -4.1, 4.1],
+    });
+};
+const getGGBOptions = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { nodeAngleBase, nodeArgument, nodeModule } = getHydrated(identifiers);
+    const nbRays = frac(multiply(2, PiNode), nodeAngleBase)
+        .simplify({ towardsDistribute: false })
+        .evaluate();
+    const arrNodeAngle = [...Array(nbRays).keys()].map((i) => multiply(i, nodeAngleBase));
+    const pointO = new Point("O", 0, 0);
+    const pointA = new Point("A", 1, 0);
+    const precision = 5;
+    const arrPointForAngle = arrNodeAngle.map((nodeAngle, i) => rotatePoint(pointA, nodeAngle.evaluate(), pointO, `PA${i}`, precision));
+    const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const pointAM = new Point("AM", nodeModule, 0);
+    const pointM = rotatePoint(pointAM, nodeArgument.evaluate(), pointO, "M", precision);
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            //circles
+            ...[...Array(4).keys()]
+                .map((i) => i + 1)
+                .flatMap((v, i) => [
+                `c${i} = Circle((0,0), ${v})`,
+                // `SetColor(c${i}, ${strLineColor})`,
+                `SetLineThickness(c${i}, 1)`,
+            ]),
+            //rays
+            ...arrPointForAngle.flatMap((point, i) => [
+                `ray${i} = Ray(${pointO.toMathString()}, ${point.toMathString()})`,
+                `SetColor(ray${i}, ${strLineColor})`,
+                `SetLineThickness(ray${i}, 1)`,
+            ]),
+            //pointM
+            ...[
+                `M = ${pointM.toMathString()}`,
+                `SetFixed(M, true, false)`,
+                `ShowLabel(M, true)`,
+            ],
+            //angle
+            ...(opts.isShouldDisplayAngleBase
+                ? [
+                    `rayM = Ray(${pointO.toMathString()}, ${arrPointForAngle[1].toMathString()})`,
+                    `SetVisibleInView(rayM, 1, false)`,
+                    `ang = Angle(ray0, rayM)`,
+                    `SetCaption(ang, "$\\\\ \\\\ \\ \\ ${nodeAngleBase.toTex()}$")`,
+                    `ShowLabel(ang, true)`,
+                ]
+                : []),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: [-4.1, 4.1, -4.1, 4.1],
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeModule: nodeModulePure, nodeArgument, nodeAngleBase, vFactor, } = getHydrated(identifiers);
+    function createNodeAffixSimplified(nodeModule, nodeArgument) {
+        const nodeAffixSimplified = multiply(nodeModule, exp(multiply(nodeI, nodeArgument.simplify({ towardsDistribute: true }))));
+        return nodeAffixSimplified;
+    }
+    const isTerrorWrtModule = probaFlip(0.39);
+    const nodeModule = (() => {
+        if (isTerrorWrtModule) {
+            const vModulePure = nodeModulePure.evaluate();
+            const poolVModuleWrong = [2, 3, 4].filter((v) => v !== vModulePure);
+            const vModuleWrong = random(poolVModuleWrong);
+            return vModuleWrong.toTree();
+        }
+        else {
+            return nodeModulePure;
+        }
+    })();
+    //student: reprocesses read module: module becomes sqrt(2),sqrt(3),sqrt(5)
+    {
+        const [{ nodeModuleWrong }] = [sqrt(2), sqrt(3), sqrt(5)]
+            .map((nodeModuleWrong) => {
+            const nodeDistance = abs(substract(nodeModuleWrong, nodeModule));
+            return {
+                nodeModuleWrong,
+                nodeDistance,
+            };
+        })
+            .toSorted(({ nodeDistance: nodeDistance1 }, { nodeDistance: nodeDistance2 }) => NodeComparator.compareViaSub(nodeDistance1, nodeDistance2));
+        const nodeAffixSimplified = createNodeAffixSimplified(nodeModuleWrong, nodeArgument);
+        tryToAddWrongProp(propositions, nodeAffixSimplified.toTex());
+    }
+    //student: forgets i
+    {
+        const nodeAffixSimplified = multiply(nodeModule, exp(nodeArgument.simplify({ towardsDistribute: true })));
+        tryToAddWrongProp(propositions, nodeAffixSimplified.toTex());
+    }
+    //student: forgets Pi
+    {
+        const nodeAffixSimplified = multiply(nodeModule, exp(multiply(nodeI, frac(nodeArgument, PiNode).simplify({ towardsDistribute: true }))));
+        tryToAddWrongProp(propositions, nodeAffixSimplified.toTex());
+    }
+    //student: reads wrong angle: offset
+    if (Math.abs(vFactor) > 3) {
+        const nodeArgumentWrong = add(nodeArgument, multiply(coinFlip() ? +1 : -1, nodeAngleBase)).simplify({ towardsDistribute: false });
+        const nodeAffixSimplified = createNodeAffixSimplified(nodeModule, nodeArgumentWrong);
+        tryToAddWrongProp(propositions, nodeAffixSimplified.toTex());
+    }
+    //student: wrong sign
+    {
+        const nodeAffixSimplified = multiply(nodeModule, exp(multiply(nodeI, multiply(-1, nodeArgument).simplify({ towardsDistribute: true }))));
+        tryToAddWrongProp(propositions, nodeAffixSimplified.toTex());
+    }
+    //student: mistake wrt base angle
+    {
+        function createNodeAngleBase(texAngleBase) {
+            switch (texAngleBase) {
+                case `$${frac(PiNode, 18).toTex()}$`: {
+                    return frac(PiNode, 18);
+                }
+                case `$${frac(PiNode, 9).toTex()}$`: {
+                    return frac(PiNode, 9);
+                }
+                case `$${frac(PiNode, 6).toTex()}$`: {
+                    const nodeAngleBase = frac(PiNode, 6);
+                    return nodeAngleBase;
+                }
+                case `$${frac(multiply(2, PiNode), 9).toTex()}$`: {
+                    return frac(multiply(2, PiNode), 9);
+                }
+                case `$${frac(PiNode, 3).toTex()}$`: {
+                    return frac(PiNode, 3);
+                }
+                default:
+                    throw new Error("Unsupported opts.texAngleBase: " + texAngleBase);
+            }
+        }
+        arrayedOpts.texAngleBase
+            .map(createNodeAngleBase)
+            .map((nodeAngleBaseWrong) => {
+            const nodeArgumentWrong = multiply(vFactor, nodeAngleBaseWrong);
+            const nodeAffixSimplified = multiply(nodeModule, exp(multiply(nodeI, nodeArgumentWrong.simplify({ towardsDistribute: true }))));
+            tryToAddWrongProp(propositions, nodeAffixSimplified.toTex());
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["epower", "i", "pi"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const [nodeModuleAns, nodeArgumentAns] = (() => {
+            if (isMultiplyNode(nodeAns)) {
+                if (isExpNode(nodeAns.leftChild)) {
+                    if (isNumberNode(nodeAns.rightChild) ||
+                        isOppositeNode(nodeAns.rightChild)) {
+                        const nodeModule = nodeAns.rightChild;
+                        const nodeExp = nodeAns.leftChild;
+                        const nodeArgument = frac(nodeExp.child, nodeI).simplify({
+                            towardsDistribute: false,
+                        });
+                        return [nodeModule, nodeArgument];
+                    }
+                    else {
+                        return [undefined, nodeAns.leftChild];
+                    }
+                }
+                else if (isExpNode(nodeAns.rightChild)) {
+                    if (isNumberNode(nodeAns.leftChild) ||
+                        isOppositeNode(nodeAns.leftChild)) {
+                        const nodeModule = nodeAns.leftChild;
+                        const nodeExp = nodeAns.rightChild;
+                        const nodeArgument = frac(nodeExp.child, nodeI).simplify({
+                            towardsDistribute: false,
+                        });
+                        return [nodeModule, nodeArgument];
+                    }
+                    else {
+                        return [undefined, nodeAns.leftChild];
+                    }
+                }
+                else {
+                    return [undefined, nodeAns.leftChild];
+                }
+            }
+            else if (isExpNode(nodeAns)) {
+                const nodeExp = nodeAns;
+                const nodeArgument = frac(nodeExp.child, nodeI).simplify({
+                    towardsDistribute: false,
+                });
+                const nodeModule = (1).toTree();
+                return [nodeModule, nodeArgument];
+            }
+            else {
+                return [undefined, undefined];
+            }
+        })();
+        if (nodeModuleAns === undefined || nodeArgumentAns === undefined) {
+            return false;
+        }
+        const { nodeModule: nodeModuleAnswer, nodeArgument: nodeArgumentAnswer } = getHydrated(identifiers);
+        const isModuleValid = (nodeModule) => {
+            return (NodeComparator.isEqualViaSub(nodeModule, nodeModuleAnswer) ||
+                NodeComparator.isEqualViaFrac(nodeModule, nodeModuleAnswer));
+        };
+        const isArgumentValid = (nodeArgument) => {
+            const nodeSub = substract(nodeArgument, nodeArgumentAnswer).simplify({
+                towardsDistribute: false,
+            });
+            const nodeFrac = frac(nodeSub, PiNode).simplify({
+                towardsDistribute: false,
+            });
+            const vFrac = nodeFrac.evaluate();
+            return vFrac % 2 === 0;
+        };
+        const isValid = (nodeModule, nodeArgument) => {
+            return isModuleValid(nodeModule) && isArgumentValid(nodeArgument);
+        };
+        return isValid(nodeModuleAns, nodeArgumentAns);
+        //uncomment if you want to allow: m.exp(ia) === (-m).exp(i(a+Pi))
+        // ||isValid(
+        //   multiply(-1, nodeModuleAns).simplify(),
+        //   add(PiNode, nodeArgumentAns),
+        // )
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+// const createRandomIdentifiers = (opts: Options) => {};
+const getComplexGeomAffixExpFromPointQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        ...(optsIn ?? optsDefault),
+        texAngleBase: random(arrayedOpts.texAngleBase),
+    };
+    const [nodeAngleBase, nodeArgumentM] = (() => {
+        switch (opts.texAngleBase) {
+            case `$${frac(PiNode, 18).toTex()}$`: {
+                const nodeAngleBase = frac(PiNode, 18);
+                const vFactor = (coinFlip() ? +1 : -1) * randint(1, 18);
+                const nodeAngleM = multiply(vFactor, nodeAngleBase).simplify({
+                    towardsDistribute: false,
+                });
+                return [nodeAngleBase, nodeAngleM];
+            }
+            case `$${frac(PiNode, 9).toTex()}$`: {
+                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 `$${frac(PiNode, 6).toTex()}$`: {
+                const nodeAngleBase = frac(PiNode, 6);
+                const vFactor = (coinFlip() ? +1 : -1) * randint(1, 6);
+                const nodeAngleM = multiply(vFactor, nodeAngleBase).simplify({
+                    towardsDistribute: false,
+                });
+                return [nodeAngleBase, nodeAngleM];
+            }
+            case `$${frac(multiply(2, PiNode), 9).toTex()}$`: {
+                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 `$${frac(PiNode, 3).toTex()}$`: {
+                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 opts.texAngleBase: " + opts.texAngleBase);
+        }
+    })();
+    const vModuleM = randint(1, 5);
+    const nodeModuleM = vModuleM.toTree();
+    const identifiers = {
+        nodeIdsModule: nodeModuleM.toIdentifiers(),
+        nodeIdsArgument: nodeArgumentM.toIdentifiers(),
+        nodeIdsAngleBase: nodeAngleBase.toIdentifiers(),
+    };
+    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),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    isShouldDisplayAngleBase: false,
+};
+const arrayedOptsDefault = {
+    texAngleBase: [frac(PiNode, 6), frac(PiNode, 3)].map((node) => `$${node.toTex()}$`),
+};
+const options = [
+    {
+        id: "texAngleBase",
+        label: "Graduation d'angle",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            frac(PiNode, 18),
+            frac(PiNode, 9),
+            frac(PiNode, 6),
+            frac(multiply(2, PiNode), 9),
+            frac(PiNode, 3),
+        ].map((node) => `$${node.toTex()}$`),
+        defaultValue: arrayedOptsDefault.texAngleBase,
+    },
+    {
+        id: "isShouldDisplayAngleBase",
+        label: "Afficher l'angle de graduation ?",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isShouldDisplayAngleBase,
+    },
+];
+export const complexGeomAffixExpFromPoint = {
+    id: "complexGeomAffixExpFromPoint",
+    label: "Déterminer l'affixe d'un point sous forme exponentielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomAffixExpFromPointQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsModule: NodeIdentifiers;
+    nodeIdsArgument: NodeIdentifiers;
+    isAngleInDegrees: boolean;
+};
+type Options = {
+    isAngleInDegrees: boolean;
+};
+export declare const complexGeomAffixTrigFromPoint: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=complexGeomAffixTrigFromPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomAffixTrigFromPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomAffixTrigFromPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAerC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiF7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AA8gBF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAgBF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBxE,CAAC"}