math-exercises 3.0.214 → 3.0.216

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomFindPointFromAffixExp.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomFindPointFromAffixExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAQtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4E7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AAkPF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAkBlE,CAAC"}

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

@@ -0,0 +1,223 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { colorWithOpacity } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.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 } 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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.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, pointIds } = identifiers;
+    const [nodeModule, nodeArgument] = [nodeIdsModule, nodeIdsArgument].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const nodeAffixSimplified = multiply(nodeModule, exp(multiply(nodeI, nodeArgument.simplify({ towardsDistribute: true }))));
+    return {
+        nodeModule,
+        nodeArgument,
+        arrPoint,
+        nodeAffixSimplified,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeAffixSimplified } = getHydrated(identifiers);
+    return `Quel point est le point image du nombre $${nodeAffixSimplified.toTex()}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { arrPoint } = getHydrated(identifiers);
+    const [pointAnswer, _] = arrPoint;
+    return pointAnswer.name;
+};
+const getHint = () => {
+    return `Le nombre $\\pi$ vaut environ $${(3.14).frenchify()}$.
+Le demi-plan supérieur contient les points images de nombres dont l'argument principal est compris entre $0$ et $\\pi$.
+Le demi-plan inférieur contient les points images de nombres dont l'argument principal est compris entre $-\\pi$ et $0$.
+
+Détermine une valeur approchée de l'argument du nombre donné pour trouver le point demandé.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeModule, nodeArgument, nodeAffixSimplified, arrPoint } = getHydrated(identifiers);
+    const [pointAnswer, _] = arrPoint;
+    const nodeModuleWithPi = isMultiplyNode(nodeModule) ? nodeModule : undefined;
+    const nodeArgumentWithoutPi = isMultiplyNode(nodeArgument)
+        ? undefined
+        : nodeArgument;
+    return `${nodeModuleWithPi !== undefined
+        ? `On peut réécrire sous forme approchée le module donné :
+
+$$
+${nodeModuleWithPi.toTex()} \\approx ${round(nodeModuleWithPi.evaluate(), 2).frenchify()} 
+$$
+
+`
+        : ``}
+${nodeArgumentWithoutPi !== undefined
+        ? `On peut réécrire sous forme approchée l'argument donné :
+
+$$
+${nodeArgumentWithoutPi.toTex()} \\approx ${round(frac(nodeArgumentWithoutPi, PiNode).evaluate(), 2).frenchify()} \\pi
+$$
+
+`
+        : `On cherche un point à la distance $${nodeModule.toTex()}$ de l'origine.`}
+
+On peut ainsi détérminer plus aisément que le point image de $${nodeAffixSimplified.toTex()}$ est le point $${pointAnswer.name}$.
+  
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { arrPoint } = getHydrated(identifiers);
+    const nodeAngleBase = frac(PiNode, 6);
+    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 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)`,
+            ]),
+            //points
+            ...arrPoint.flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+                // style: 1,
+            })),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: [-4.1, 4.1, -4.1, 4.1],
+    });
+};
+const getPropositions = (_n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { arrPoint } = getHydrated(identifiers);
+    const [pointAnswer, _] = arrPoint;
+    arrPoint
+        .toSorted((point1, point2) => point1.name.localeCompare(point2.name))
+        .forEach((point) => {
+        if (point.name === pointAnswer.name) {
+            addValidProp(propositions, point.name);
+        }
+        else {
+            tryToAddWrongProp(propositions, point.name);
+        }
+    });
+    return propositions;
+};
+const getComplexGeomFindPointFromAffixExpQuestion = () => {
+    function createRandomAffixObj(name) {
+        const nodeModule = coinFlip()
+            ? randfloat(1, 4, 1).toTree()
+            : multiply(randfloat(0.5, 1.2, 1), PiNode);
+        const nodeArgument = coinFlip()
+            ? randfloat(-5, 5, 1, [0]).toTree()
+            : multiply(randfloat(-1.5, 1.5, 1, [0]), PiNode);
+        const point = new Point(name, multiply(nodeModule, cos(nodeArgument)), multiply(nodeModule, sin(nodeArgument)));
+        const affixObj = { nodeModule, nodeArgument, point };
+        return affixObj;
+    }
+    const arrAffixObj = (() => {
+        let arrLetter = ["A", "B", "C", "D"];
+        const arrAffixObj = [];
+        while (arrAffixObj.length < 4) {
+            const [name, ...arrLetterRest] = arrLetter;
+            const affixObjCandidate = createRandomAffixObj(name);
+            const isFarEnough = arrAffixObj.every(({ point: pointExisting }) => affixObjCandidate.point.distanceTo(pointExisting) > 0.5);
+            if (isFarEnough) {
+                arrAffixObj.push(affixObjCandidate);
+                arrLetter = arrLetterRest;
+            }
+        }
+        const arrAffixObjShuffled = shuffle(arrAffixObj);
+        return arrAffixObjShuffled;
+    })();
+    const [affixObjAsked, _] = arrAffixObj;
+    const identifiers = {
+        nodeIdsModule: affixObjAsked.nodeModule.toIdentifiers(),
+        nodeIdsArgument: affixObjAsked.nodeArgument.toIdentifiers(),
+        pointIds: arrAffixObj.map(({ point }) => point.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const complexGeomFindPointFromAffixExp = {
+    id: "complexGeomFindPointFromAffixExp",
+    label: "Déterminer le point image d'un nombre complexe donné sous forme exponentielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomFindPointFromAffixExpQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    nbSides: number;
+    pointIds: PointIdentifiers[];
+    indexTarget: number;
+    exponent: number;
+};
+export declare const complexGeomFindPointFromPowerOfUnitRootFromFigure: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexGeomFindPointFromPowerOfUnitRootFromFigure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomFindPointFromPowerOfUnitRootFromFigure.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomFindPointFromPowerOfUnitRootFromFigure.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAoGtC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAyYF,eAAO,MAAM,iDAAiD,EAAE,QAAQ,CAAC,WAAW,CAoBjF,CAAC"}

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

@@ -0,0 +1,348 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { colorWithOpacity } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { lcm } from "../../../../math/utils/arithmetic/lcm.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 { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.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 { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const pointO = new Point("O", 0, 0);
+//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 createPointForModuleAndArgument = (nodeModule, nodeArgument, name) => new Point(name, multiply(nodeModule, cos(nodeArgument)), multiply(nodeModule, sin(nodeArgument)));
+const getHydrated = (identifiers) => {
+    const { nbSides, pointIds, indexTarget, exponent } = identifiers;
+    const nodeAngleBase = frac(multiply(2, PiNode), nbSides);
+    const arrDictPointAndAffix = pointIds.map((pointIds, i) => {
+        const point = PointConstructor.fromIdentifiers(pointIds);
+        const nodeArgument = multiply(i, nodeAngleBase).simplify({
+            towardsDistribute: false,
+        });
+        const nodeAffix = exp(multiply(nodeI, nodeArgument));
+        return {
+            point,
+            nodeArgument,
+            nodeAffix,
+        };
+    });
+    const strNamePolygon = arrDictPointAndAffix.reduce((acc, { point }) => acc + point.name, "");
+    const nodeAffixTarget = arrDictPointAndAffix[indexTarget].nodeAffix;
+    const nodeAffixInstruction = power(nodeAffixTarget, exponent);
+    const nodeArgumentTarget = arrDictPointAndAffix[indexTarget].nodeArgument;
+    const nodeAffixAnswer = exp(multiply(nodeI, multiply(exponent, nodeArgumentTarget)));
+    const indexAnswer = (indexTarget * exponent) % nbSides;
+    return {
+        strNamePolygon,
+        nodeAngleBase,
+        arrDictPointAndAffix,
+        nodeArgumentTarget,
+        nodeAffixTarget,
+        nodeAffixInstruction,
+        indexAnswer,
+        nodeAffixAnswer,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nbSides } = identifiers;
+    const { nodeAffixInstruction, strNamePolygon } = getHydrated(identifiers);
+    return `Les points du polygone $${strNamePolygon}$ sont les points images des racines $${nbSides}$èmes de l'unité.
+Quel est le point d'affixe $${nodeAffixInstruction.toTex()}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { arrDictPointAndAffix, indexAnswer } = getHydrated(identifiers);
+    const { point } = arrDictPointAndAffix[indexAnswer];
+    return point.name;
+};
+const getHint = (identifiers) => {
+    const { exponent } = identifiers;
+    const { nodeAffixTarget } = getHydrated(identifiers);
+    return `Soit $\\alpha$ un nombre réel et $n$ un nombre entier.
+Le calcul des puissances d'une exponentielle complexe est simple :
+ 
+$$
+(e^{i \\alpha})^n = e^{i (n \\alpha)}
+$$
+
+L'argument de $(e^{i \\alpha})^n$ est $n$ fois $\\alpha$.
+Tu peux donc répérer la rotation qu'il faut effectuer pour partir du point $A$ et arriver au point d'affixe $${nodeAffixTarget.toTex()}$
+et la faire $${exponent}$ fois en partant du point $A$.`;
+};
+const getCorrection = (identifiers) => {
+    const { exponent, indexTarget, nbSides } = identifiers;
+    const { nodeAffixInstruction, nodeAffixTarget, nodeArgumentTarget, nodeAffixAnswer, arrDictPointAndAffix, indexAnswer, } = getHydrated(identifiers);
+    const { point: pointTarget } = arrDictPointAndAffix[indexTarget];
+    const { point: pointAnswer } = arrDictPointAndAffix[indexAnswer];
+    return `Le calcul des puissances d'une exponentielle complexe est simple :
+ 
+$$
+${nodeAffixInstruction.toTex()} = ${nodeAffixAnswer.toTex()}
+$$
+
+Le point d'affixe $${nodeAffixTarget.toTex()}$ est le point $${pointTarget.name}$.
+On effectue une rotation d'angle $${nodeArgumentTarget.toTex()}$ pour partir du point $A$ arriver au point $${pointTarget.name}$.
+
+On effectue $${exponent}$ fois cette rotation en partant du point $A$. 
+On tombe sur le point $${pointAnswer.toTex()}$.
+
+En effet : 
+
+$$
+{${indexTarget} \\times ${exponent}} \\equiv ${indexAnswer} \\pmod{${nbSides}}
+$$
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nbSides, exponent, indexTarget } = identifiers;
+    const { arrDictPointAndAffix, nodeArgumentTarget } = getHydrated(identifiers);
+    const arrPoint = arrDictPointAndAffix.map(({ point }) => point);
+    const [arrArrPointForArcs, arrArrPointForArrows] = (() => {
+        const arrIndexes = [...Array(exponent + 1).keys()].map((i) => (i * indexTarget) % nbSides);
+        const arrPointForIndexes = arrIndexes.map((index) => arrDictPointAndAffix[index].point);
+        const arrArrArrPointForArcs = zip(arrPointForIndexes.slice(0, -1), arrPointForIndexes.slice(1)).map(([pointRawStart, pointRawEnd], i) => {
+            const factor = 0.5 + (i * 0.5) / exponent;
+            const [pointArcStart, pointArcEnd] = [pointRawStart, pointRawEnd].map((pointRaw) => new Point("NoName", multiply(factor, pointRaw.x), multiply(factor, pointRaw.y)));
+            const pointArrowStart = rotatePoint(pointArcStart, multiply(0.97, nodeArgumentTarget).evaluate(), pointO, "NoName", 5);
+            const arrPointForArcs = [pointArcStart, pointArcEnd];
+            const arrPointForArrows = [pointArrowStart, pointArcEnd];
+            return [arrPointForArcs, arrPointForArrows];
+        });
+        const arrArrPointForArcs = arrArrArrPointForArcs.map(([arrPointForArcs, _]) => arrPointForArcs);
+        const arrArrPointForArrows = arrArrArrPointForArcs.map(([_, arrPointForArrows]) => arrPointForArrows);
+        return [arrArrPointForArcs, arrArrPointForArrows];
+    })();
+    const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const arrStrCaption = "①②③④⑤⑥⑦⑧⑨".split("");
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            //points
+            ...[pointO, ...arrPoint].flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+            })),
+            //segments (rays)
+            ...arrPoint.flatMap((point, i) => [
+                `segRay${i} = Segment(${pointO.toMathString()}, ${point.toMathString()})`,
+                `SetColor(segRay${i}, ${strLineColor})`,
+                `SetLineThickness(segRay${i}, 1)`,
+                `SetLineStyle(segRay${i}, 1)`,
+            ]),
+            //arcs
+            ...arrArrPointForArcs.flatMap(([pointArcStart, pointArcEnd], i) => [
+                `arc${i} = CircleArc(${pointO.toMathString()}, ${pointArcStart.toMathString()}, ${pointArcEnd.toMathString()})`,
+                // `SetColor(arc${i}, ${strLineColor})`,
+                `SetLineThickness(arc${i}, 3)`,
+                `SetLineStyle(arc${i}, 0)`,
+                // `SetDecoration(arc${i}, 2)`,
+                `SetCaption(arc${i}, "${arrStrCaption[i]}")`,
+                `ShowLabel(arc${i}, true)`,
+            ]),
+            //arrows
+            ...arrArrPointForArrows.flatMap(([pointArrowStart, pointArrowEnd], i) => [
+                `vecArrow${i} = Vector(${pointArrowStart.toMathString()}, ${pointArrowEnd.toMathString()})`,
+                // `SetLineThickness(vecArrow${i}, 1)`,
+            ]),
+        ],
+        fontSize: 16,
+        xAxis: {
+            hideNumbers: true,
+        },
+        yAxis: {
+            hideNumbers: true,
+        },
+    });
+    const radius = 1;
+    const lForFrame = radius + 0.1;
+    return ggb.getOptions({
+        coords: [-lForFrame, lForFrame, -lForFrame, lForFrame],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { arrDictPointAndAffix } = getHydrated(identifiers);
+    const arrPoint = arrDictPointAndAffix.map(({ point }) => point);
+    const pointO = new Point("O", 0, 0);
+    const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            //points
+            ...[pointO, ...arrPoint].flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+            })),
+            //segments (rays)
+            ...arrPoint.flatMap((point, i) => [
+                `segRay${i} = Segment(${pointO.toMathString()}, ${point.toMathString()})`,
+                `SetColor(segRay${i}, ${strLineColor})`,
+                `SetLineThickness(segRay${i}, 1)`,
+                `SetLineStyle(segRay${i}, 1)`,
+            ]),
+        ],
+        fontSize: 16,
+        xAxis: {
+            hideNumbers: true,
+        },
+        yAxis: {
+            hideNumbers: true,
+        },
+    });
+    const radius = 1;
+    const lForFrame = radius + 0.1;
+    return ggb.getOptions({
+        coords: [-lForFrame, lForFrame, -lForFrame, lForFrame],
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nbSides, indexTarget, exponent } = identifiers;
+    const { indexAnswer, arrDictPointAndAffix } = getHydrated(identifiers);
+    //student: almost there: offset
+    if (probaFlip(0.3)) {
+        const vAbsOffset = probaLawFlip([
+            [1, 0.5],
+            [2, 0.3],
+            [3, 0.2],
+        ]);
+        const indexWrong = (() => {
+            const indexRaw = (indexAnswer + (coinFlip() ? +1 : -1) * vAbsOffset) % nbSides;
+            if (indexRaw >= 0) {
+                return indexRaw;
+            }
+            else {
+                return nbSides + indexRaw;
+            }
+        })();
+        const { point: pointWrong } = arrDictPointAndAffix[indexWrong];
+        tryToAddWrongProp(propositions, pointWrong.name);
+    }
+    //student: a \\times exponent -> a + exponent
+    {
+        const indexWrong = (indexTarget + exponent) % nbSides;
+        const { point: pointWrong } = arrDictPointAndAffix[indexWrong];
+        tryToAddWrongProp(propositions, pointWrong.name);
+    }
+    //student: (exp(i argumentTarget))^n -> (exp(i baseAngle))^n
+    {
+        const indexWrong = (1 * exponent) % nbSides;
+        const { point: pointWrong } = arrDictPointAndAffix[indexWrong];
+        tryToAddWrongProp(propositions, pointWrong.name);
+    }
+    //filler
+    propWhile(propositions, n, () => {
+        if (nbSides < n) {
+            tryToAddWrongProp(propositions, "O");
+        }
+        const { point: pointWrong } = random(arrDictPointAndAffix);
+        tryToAddWrongProp(propositions, pointWrong.name);
+    });
+    return shuffleProps(propositions, n).toSorted((proposition1, proposition2) => proposition1.statement.localeCompare(proposition2.statement));
+};
+const getKeys = (identifiers) => {
+    const { arrDictPointAndAffix } = getHydrated(identifiers);
+    return arrDictPointAndAffix.map(({ point }) => point.name);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+// const createRandomIdentifiers = (opts: Options) => {};
+const getComplexGeomFindPointFromPowerOfUnitRootFromFigureQuestion = () => {
+    const nbSides = randint(3, 9);
+    const nodeAngleBase = frac(multiply(2, PiNode), nbSides);
+    const arrLetter = "ABCDEFGHIJKL".split("");
+    const arrPoint = [...Array(nbSides).keys()].map((i) => {
+        const letter = arrLetter[i];
+        const nodeModule = (1).toTree();
+        const nodeArgument = multiply(i, nodeAngleBase);
+        const point = createPointForModuleAndArgument(nodeModule, nodeArgument, letter);
+        const pointEvaluated = new Point(point.name, point.x.evaluate(), point.y.evaluate());
+        return pointEvaluated;
+    });
+    const indexTarget = randint(1, nbSides);
+    const exponent = probaFlip(0.2)
+        ? lcm(indexTarget, nbSides) / indexTarget
+        : randint(2, 4);
+    const identifiers = {
+        nbSides,
+        pointIds: arrPoint.map((point) => point.toIdentifiers()),
+        indexTarget,
+        exponent,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+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;
+};
+export const complexGeomFindPointFromPowerOfUnitRootFromFigure = {
+    id: "complexGeomFindPointFromPowerOfUnitRootFromFigure",
+    label: "Déterminer le point dont l'affixe est une puissance d'une racine nième de l'unité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomFindPointFromPowerOfUnitRootFromFigureQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    re: number;
+    im: number;
+};
+export declare const complexGeomPlaceAffixPoint: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexGeomPlaceAffixPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomPlaceAffixPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomPlaceAffixPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4EF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}