math-exercises 3.0.214 → 3.0.216

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

@@ -0,0 +1,224 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.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 { cos } from "../../../../tree/nodes/functions/cosNode.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 { 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 { random } from "../../../../utils/alea/random.js";
+const pointO = new Point("O", 0, 0);
+const lFrame = 5;
+const _coordsFrame = (() => {
+    const lFrameMore = lFrame + 0.1;
+    return [-lFrameMore, lFrameMore, -lFrameMore, lFrameMore];
+})();
+//TODO: frac does not simplify "i"
+// const nodeI = new ComplexNode((0).toTree(), (1).toTree());
+const nodeI = new VariableNode("i");
+const createPointForModuleAndArgument = (nodeModule, nodeArgument, name) => new Point(name, multiply(nodeModule, cos(nodeArgument)), multiply(nodeModule, sin(nodeArgument)));
+const getHydrated = (identifiers) => {
+    const { nodeIdsModule, nodeIdsArgument, pointIdsA, isCosAsked } = identifiers;
+    const [nodeModule, nodeArgument] = [nodeIdsModule, nodeIdsArgument].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [pointA] = [pointIdsA].map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const nodeArgumentSimplified = nodeArgument.simplify({
+        towardsDistribute: true,
+    });
+    const nodeAffixSimplified = multiply(nodeModule, add(cos(nodeArgumentSimplified), multiply(nodeI, sin(nodeArgumentSimplified))));
+    const nodeAsked = (isCosAsked ? cos : sin)(nodeArgumentSimplified);
+    const nodeProductAsked = multiply(nodeModule, nodeAsked);
+    const nodeProductAskedRounded = round(nodeProductAsked.evaluate(), 2).toTree();
+    return {
+        nodeModule,
+        nodeArgument,
+        nodeArgumentSimplified,
+        pointA,
+        nodeAffixSimplified,
+        nodeAsked,
+        nodeProductAsked,
+        nodeProductAskedRounded,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeAffixSimplified, nodeAsked } = getHydrated(identifiers);
+    return `Le point $A$ d'affixe $${nodeAffixSimplified.toTex()}$ est représenté sur la figure ci-dessous.
+Étant données ces informations, parmi les propositions suivantes, quelle est la valeur de $${nodeAsked.toTex()}$ arrondie à deux décimales ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeAsked } = getHydrated(identifiers);
+    return round(nodeAsked.evaluate(), 2).toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeAsked, nodeAffixSimplified } = getHydrated(identifiers);
+    return `Soit $z$ l'affixe de $A$.
+Soient $x$ l'abscisse et $y$ l'ordonnée du point $A$.
+Sous forme algébrique, on a : 
+
+$$
+z = x + iy
+$$
+
+Sous forme trigonométrique, on a :
+
+$$
+z = ${nodeAffixSimplified.toTex()}
+$$
+
+Utilise ces deux formes pour déterminer mentalement une valeur approchée pour $${nodeAsked.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { isCosAsked } = identifiers;
+    const { nodeAsked, nodeAffixSimplified, nodeModule, nodeProductAskedRounded, } = getHydrated(identifiers);
+    return `Soit $z$ l'affixe de $A$.
+Soient $x$ l'abscisse et $y$ l'ordonnée du point $A$.
+Sous forme algébrique, on a : 
+
+$$
+z = x + iy
+$$
+
+Sous forme trigonométrique, on a :
+
+$$
+z = ${nodeAffixSimplified.toTex()}
+$$
+
+Graphiquement, on lit :
+
+$$
+${isCosAsked ? "x" : "y"} \\approx ${nodeProductAskedRounded.toTex()}
+$$
+
+Donc : 
+    
+$$
+${nodeAsked.toTex()} \\approx ${frac(nodeProductAskedRounded, nodeModule).toTex()} \\approx ${round(nodeAsked.evaluate(), 2).toTree().toTex()}
+$$
+
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { pointA } = getHydrated(identifiers);
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            //points
+            ...[pointA].flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+                // style: 1,
+            })),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([pointO, pointA]),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { isCosAsked } = identifiers;
+    const { nodeAsked, nodeArgumentSimplified, nodeProductAskedRounded } = getHydrated(identifiers);
+    //student: forgets to divide by module
+    {
+        const nodeWrong = nodeProductAskedRounded;
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    function tryToAddWrongPropNotTooClosePlease(nodeRounded) {
+        if (abs(substract(nodeRounded, nodeAsked)).evaluate() < 0.2) {
+            //ignore
+        }
+        tryToAddWrongProp(propositions, nodeRounded.toTex());
+    }
+    //student: cos <-> sin
+    {
+        const nodeAskedWrong = (isCosAsked ? sin : cos)(nodeArgumentSimplified);
+        const nodeWrong = round(nodeAskedWrong.evaluate(), 2).toTree();
+        tryToAddWrongPropNotTooClosePlease(nodeWrong);
+    }
+    //student: evaluates nodeArgument
+    {
+        const nodeWrong = round(nodeArgumentSimplified.evaluate(), 2).toTree();
+        tryToAddWrongPropNotTooClosePlease(nodeWrong);
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        const nodeWrong = getAnswerNode(identifiersWrong);
+        tryToAddWrongPropNotTooClosePlease(nodeWrong);
+    });
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = () => {
+    function createRandomAffixObj(name) {
+        const nodeModule = randint(2, Math.ceil(lFrame)).toTree();
+        const nodeArgument = (() => {
+            let nodeArgument;
+            do {
+                const den = random([5, 7, 9, 11, 13, 17]);
+                const num = (coinFlip() ? +1 : -1) *
+                    randint(Math.floor((den * 1) / 4), Math.ceil((den * 3) / 4));
+                nodeArgument = multiply(multiply(2, PiNode), frac(num, den)).simplify({
+                    towardsDistribute: false,
+                });
+            } while (abs(nodeArgument).simplify().rightChild.evaluate() ===
+                3);
+            return nodeArgument;
+        })();
+        const point = createPointForModuleAndArgument(nodeModule, nodeArgument, name);
+        const affixObj = { nodeModule, nodeArgument, point };
+        return affixObj;
+    }
+    const affixObjAsked = createRandomAffixObj("A");
+    const isCosAsked = coinFlip();
+    const identifiers = {
+        pointIdsA: affixObjAsked.point.toIdentifiers(),
+        nodeIdsModule: affixObjAsked.nodeModule.toIdentifiers(),
+        nodeIdsArgument: affixObjAsked.nodeArgument.toIdentifiers(),
+        isCosAsked,
+    };
+    return identifiers;
+};
+const getComplexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrigQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    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 complexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrig = {
+    id: "complexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrig",
+    label: "Déterminer une valeur approchée de $\\cos(\\arg(z))$ ou $\\sin(\\arg(z))$ à partir d'une figure",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomApproxOfCosArgOrSinArgFromPointAndAffixTrigQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    typeSituation: string;
+    nodeIdsAffixExp: NodeIdentifiers[];
+    indexesOfPoints: number[];
+    letters: string[];
+};
+export declare const complexGeomArgumentOfFracCBABFromFigure: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexGeomArgumentOfFracCBABFromFigure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomArgumentOfFracCBABFromFigure.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomArgumentOfFracCBABFromFigure.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAsBrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA+H7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAgdF,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAAC,WAAW,CAkBzE,CAAC"}

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

@@ -0,0 +1,448 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueExtraDark, colorWithOpacity, greenMain, 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 { exactAngleCandidate, valueAngleBetweenPoints, } from "../../../../math/utils/geometry/angleBetweenPoints.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, isExpNode } from "../../../../tree/nodes/functions/expNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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, isAddNode } 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 { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.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 createPointFromNodeAffixExp = (nodeAffixExp, name, precision = 5) => {
+    if (isAddNode(nodeAffixExp)) {
+        const [point1, point2] = [
+            nodeAffixExp.leftChild,
+            nodeAffixExp.rightChild,
+        ].map((nodeAffixExp, i) => createPointFromNodeAffixExp(nodeAffixExp, `P${i}`, precision));
+        const x = point1.x.evaluate() + point2.x.evaluate();
+        const y = point1.y.evaluate() + point2.y.evaluate();
+        return createPoint(x, y, name, precision);
+    }
+    else if (isMultiplyNode(nodeAffixExp)) {
+        const { nodeModule, nodeArgument } = createAffixObjFromNodeAffixExp(nodeAffixExp);
+        const x = multiply(nodeModule, cos(nodeArgument)).evaluate();
+        const y = multiply(nodeModule, sin(nodeArgument)).evaluate();
+        return createPoint(x, y, name, precision);
+    }
+    else {
+        throw new Error("Unsupported nodeAffixExp: " + nodeAffixExp);
+    }
+};
+const createAffixObjFromNodeAffixExp = (nodeAffixExp) => {
+    if (isMultiplyNode(nodeAffixExp)) {
+        const [nodeModule, nodeExp] = [
+            nodeAffixExp.leftChild,
+            nodeAffixExp.rightChild,
+        ];
+        if (isExpNode(nodeExp) && isMultiplyNode(nodeExp.child)) {
+            const nodeArgument = nodeExp.child.rightChild;
+            return {
+                nodeModule,
+                nodeArgument,
+            };
+        }
+        else {
+            throw new Error("Unsupported nodeAffixExp: " + nodeAffixExp.toTex());
+        }
+    }
+    else {
+        throw new Error("Unsupported nodeAffixExp: " + nodeAffixExp.toTex());
+    }
+};
+const getHydrated = (identifiers) => {
+    const { typeSituation, nodeIdsAffixExp, indexesOfPoints, letters } = identifiers;
+    const arrNodeAffixExp = nodeIdsAffixExp.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrPoint = zip(arrNodeAffixExp, letters).map(([nodeAffixExp, letter]) => createPointFromNodeAffixExp(nodeAffixExp, letter));
+    const arrPointTarget = indexesOfPoints.map((i) => arrPoint[i]);
+    const arrLetterTarget = indexesOfPoints.map((i) => letters[i]);
+    const nodeFracWithLetters = (() => {
+        const [letterLow1, letterLowCenter, letterLow2] = arrLetterTarget.map((str) => str.toLocaleLowerCase());
+        return frac(substract(letterLow2, letterLowCenter), substract(letterLow1, letterLowCenter));
+    })();
+    //does not work: simplify does not handle complex expressions
+    /*
+    const [nodeAffixExp1, nodeAffixExp2, nodeAffixExp3] = indexesOfPoints.map(
+      (i) => arrNodeAffixExp[i],
+    );
+  
+    const nodeNumRaw = substract(nodeAffixExp3, nodeAffixExp1);
+    const nodeNumSimplified = NodeSimplifier.simplifyByVibrating(
+      NodeSimplifier.simplifyByInfiltrating(nodeNumRaw, {
+        towardsDistribute: true,
+      }),
+    );
+  
+    const nodeDenRaw = substract(nodeAffixExp2, nodeAffixExp1);
+    const nodeDenSimplified = NodeSimplifier.simplifyByVibrating(
+      NodeSimplifier.simplifyByInfiltrating(nodeDenRaw, {
+        towardsDistribute: true,
+      }),
+    );
+  
+    const nodeFracRaw = frac(nodeNumSimplified, nodeDenSimplified);
+    const nodeFracSimplified = NodeSimplifier.simplifyByVibrating(
+      NodeSimplifier.simplifyByInfiltrating(nodeFracRaw, {
+        towardsDistribute: true,
+      }),
+    );
+  
+    const nodeExpCandidate = frac(
+      nodeBySubstitutingVar(nodeFracSimplified, (1).toTree(), nodeI),
+      nodeBySubstitutingVar(nodeFracSimplified, (0).toTree(), nodeI),
+    ).simplify({ towardsDistribute: false });
+    const nodeArgument = (() => {
+      if (isExpNode(nodeExpCandidate)) {
+        return nodeExpCandidate.child;
+      } else if (isNumberNode(nodeExpCandidate)) {
+        return (0).toTree();
+      } else {
+        throw new Error("Could not compute nodeArgument");
+      }
+    })();
+    */
+    const nodeArgument = (() => {
+        switch (typeSituation) {
+            case "triangle équilatéral":
+            case "carré": {
+                const [point1, pointCenter, point2] = arrPointTarget;
+                const nodeExactAngleCandidate = exactAngleCandidate(valueAngleBetweenPoints(point1, pointCenter, point2));
+                return nodeExactAngleCandidate.simplify();
+            }
+            default:
+                throw new Error("Unsupported typeSituation: " + typeSituation);
+        }
+    })();
+    return {
+        arrNodeAffixExp,
+        arrPoint,
+        nodeFracWithLetters,
+        arrLetterTarget,
+        arrPointTarget,
+        nodeArgument,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { typeSituation } = identifiers;
+    const { arrPoint, nodeFracWithLetters } = getHydrated(identifiers);
+    switch (typeSituation) {
+        case "triangle équilatéral": {
+            const [nameCenter, ...arrNameSummit] = arrPoint.map((point) => point.name);
+            const strNameTriangle = arrNameSummit.join("");
+            return `Un triangle équilatéral $${strNameTriangle}$ de centre $${nameCenter}$ est représenté ci-dessous.
+${[nameCenter, ...arrNameSummit].map((namePoint) => {
+                const nameAffix = namePoint.toLocaleLowerCase();
+                return `On note $${nameAffix}$ l'affixe de $${namePoint}$.`;
+            }).join(`
+    
+`)}
+Donner la valeur exacte de $\\arg(${nodeFracWithLetters.toTex()})$.'`;
+        }
+        case "carré": {
+            const [nameCenter, ...arrNameSummit] = arrPoint.map((point) => point.name);
+            const strNameSquare = arrNameSummit.join("");
+            return `Un carré $${strNameSquare}$ de centre $${nameCenter}$ est représenté ci-dessous.
+${[nameCenter, ...arrNameSummit].map((namePoint) => {
+                const nameAffix = namePoint.toLocaleLowerCase();
+                return `On note $${nameAffix}$ l'affixe de $${namePoint}$.`;
+            }).join(`
+    
+`)}
+Donner la valeur exacte de $\\arg(${nodeFracWithLetters.toTex()})$.'`;
+        }
+        default:
+            throw new Error("Unsupported typeSituation: " + typeSituation);
+    }
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeArgument } = getHydrated(identifiers);
+    return nodeArgument;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { typeSituation } = identifiers;
+    const { arrPointTarget } = getHydrated(identifiers);
+    const [point1, pointCenter, point2] = arrPointTarget;
+    return `Le vecteur $\\overrightarrow{${pointCenter.name}${point1.name}}$ a pour affixe $${point1.name.toLocaleLowerCase()} - ${pointCenter.name.toLocaleLowerCase()}$.
+Le vecteur $\\overrightarrow{${pointCenter.name}${point2.name}}$ a pour affixe $${point2.name.toLocaleLowerCase()} - ${pointCenter.name.toLocaleLowerCase()}$.
+Quand on divise un nombre complexe $z$ par un nombre complexe $z'$, on soustrait $\\arg(z')$ à $\\arg(z)$.
+Les angles dans un ${typeSituation} sont bien connus.`;
+};
+const getCorrection = (identifiers) => {
+    const { typeSituation } = identifiers;
+    const { nodeFracWithLetters, arrPointTarget, nodeArgument } = getHydrated(identifiers);
+    const [point1, pointCenter, point2] = arrPointTarget;
+    return `Le vecteur $\\overrightarrow{${pointCenter.name}${point1.name}}$ a pour affixe $${point1.name.toLocaleLowerCase()} - ${pointCenter.name.toLocaleLowerCase()}$.
+Le vecteur $\\overrightarrow{${pointCenter.name}${point2.name}}$ a pour affixe $${point2.name.toLocaleLowerCase()} - ${pointCenter.name.toLocaleLowerCase()}$.
+
+$$
+${nodeFracWithLetters.toTex()} = (\\overrightarrow{${pointCenter.name}${point1.name}},\\overrightarrow{${pointCenter.name}${point2.name}})
+$$
+
+Les angles dans un ${typeSituation} sont bien connus.
+
+On a donc : 
+
+$$
+\\text{arg}(${nodeFracWithLetters.toTex()}) = ${nodeArgument.toTex()}
+$$
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { arrPoint, nodeArgument, arrPointTarget } = getHydrated(identifiers);
+    const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const [_pointCenter, ...arrPointSummit] = arrPoint;
+    const [point1, pointCenter, point2] = arrPointTarget;
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            //points
+            ...arrPoint.flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+            })),
+            //segments
+            ...zip(arrPointSummit, [
+                ...arrPointSummit.slice(1),
+                arrPointSummit[0],
+            ]).flatMap(([pointStart, pointEnd], i) => [
+                `segPol${i} = Segment(${pointStart.toMathString()}, ${pointEnd.toMathString()})`,
+                `SetColor(segPol${i}, "${blueExtraDark}")`,
+                `SetLineThickness(segPol${i}, 3)`,
+            ]),
+            //vectors
+            ...[
+                `vecCP1 = Vector(${pointCenter.toMathString()}, ${point1.toMathString()})`,
+                `vecCP2 = Vector(${pointCenter.toMathString()}, ${point2.toMathString()})`,
+                `SetLineThickness(vecCP1, 4)`,
+                `SetLineThickness(vecCP2, 4)`,
+                `SetColor(vecCP1, "${orange}")`,
+                `SetColor(vecCP2, "${orange}")`,
+            ],
+            //argument
+            ...(() => {
+                const isClockwise = nodeArgument.evaluate() > 0;
+                return [
+                    `rayCP1 = Ray(${pointCenter.toMathString()}, ${point1.toMathString()})`,
+                    `rayCP2 = Ray(${pointCenter.toMathString()}, ${point2.toMathString()})`,
+                    `SetLineThickness(rayCP1, 1)`,
+                    `SetLineThickness(rayCP2, 1)`,
+                    `SetColor(rayCP1, ${strLineColor})`,
+                    `SetColor(rayCP2, ${strLineColor})`,
+                    `angArg = ${isClockwise ? "Angle(rayCP1, rayCP2)" : "Angle(rayCP2, rayCP1)"}`,
+                    `SetDecoration(angArg, ${isClockwise ? 6 : 7})`,
+                    `SetColor(angArg, "${greenMain}")`,
+                    `SetCaption(angArg, "$\\large \\\\ \\\\ \\ \\ ${nodeArgument.toTex()}$")`,
+                    `ShowLabel(angArg, true)`,
+                ];
+            })(),
+        ],
+        fontSize: 16,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(arrPoint),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { arrPoint } = getHydrated(identifiers);
+    // const strLineColor = `"${colorWithOpacity("#000000", 26)}"`;
+    const [_pointCenter, ...arrPointSummit] = arrPoint;
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            //points
+            ...arrPoint.flatMap((point) => point.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: true,
+            })),
+            //segments
+            ...zip(arrPointSummit, [
+                ...arrPointSummit.slice(1),
+                arrPointSummit[0],
+            ]).flatMap(([pointStart, pointEnd], i) => [
+                `segPol${i} = Segment(${pointStart.toMathString()}, ${pointEnd.toMathString()})`,
+                `SetColor(segPol${i}, "${blueExtraDark}")`,
+                `SetLineThickness(segPol${i}, 3)`,
+            ]),
+        ],
+        fontSize: 16,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(arrPoint),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeArgument, arrNodeAffixExp } = getHydrated(identifiers);
+    if (coinFlip()) {
+        //student: arg -> exp(i arg)
+        {
+            const nodeExpIArg = exp(multiply(nodeI, nodeArgument));
+            tryToAddWrongProp(propositions, nodeExpIArg.toTex());
+        }
+    }
+    if (coinFlip()) {
+        //student: arg -> -arg
+        {
+            tryToAddWrongProp(propositions, opposite(nodeArgument).simplify().toTex());
+        }
+    }
+    propWhile(propositions, n, () => {
+        const indexesOfPointsWrong = randomMany([...Array(arrNodeAffixExp.length).keys()], 3);
+        const identifiersWrong = {
+            ...identifiers,
+            indexesOfPoints: indexesOfPointsWrong,
+        };
+        const { nodeArgument: nodeArgumentWrong } = getHydrated(identifiersWrong);
+        if (coinFlip()) {
+            const nodeExpIArg = exp(multiply(nodeI, nodeArgumentWrong));
+            tryToAddWrongProp(propositions, nodeExpIArg.toTex());
+        }
+        else {
+            tryToAddWrongProp(propositions, nodeArgumentWrong.toTex());
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["epower", "i", "pi"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const [nodeAns, nodeAnswer] = [ans, answer].map((str) => parseAlgebraic(str));
+        //-Pi == Pi
+        if (NodeComparator.isEqualViaSub(nodeAnswer, PiNode) &&
+            NodeComparator.isEqualViaSub(nodeAns, opposite(PiNode))) {
+            return true;
+        }
+        return (NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaSub(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    function createArrNodeAffixExpForRegularPolygon(nbSides) {
+        const nodeAffixExpCenter = multiply((0).toTree(), exp(multiply(nodeI, (0).toTree())));
+        const arrNodeAffixExpSummit = (() => {
+            const nodeModule = randfloat(2, 3, 1).toTree();
+            const nodeArgumentOffset = randfloat(0, 2, 1).toTree();
+            const nodeAngleBase = frac(multiply(2, PiNode), nbSides);
+            return [...Array(nbSides).keys()].map((i) => {
+                const nodeArgumentLocal = add(multiply(i, nodeAngleBase).simplify({
+                    towardsDistribute: false,
+                }), nodeArgumentOffset).simplify({ towardsDistribute: false });
+                const nodeAffixExpSummit = add(nodeAffixExpCenter, multiply(nodeModule, exp(multiply(nodeI, nodeArgumentLocal))));
+                return nodeAffixExpSummit;
+            });
+        })();
+        return [nodeAffixExpCenter, ...arrNodeAffixExpSummit];
+    }
+    const typeSituation = random(["triangle équilatéral", "carré"]);
+    const arrNodeAffixExp = (() => {
+        switch (typeSituation) {
+            case "triangle équilatéral": {
+                return createArrNodeAffixExpForRegularPolygon(3);
+            }
+            case "carré": {
+                return createArrNodeAffixExpForRegularPolygon(4);
+            }
+            default:
+                throw new Error("Unsupported typeSituation: " + typeSituation);
+        }
+    })();
+    const indexesOfPoints = randomMany([...Array(arrNodeAffixExp.length).keys()], 3);
+    const arrLetter = shuffle("ABCDFGH".split(""));
+    const identifiers = {
+        typeSituation,
+        nodeIdsAffixExp: arrNodeAffixExp.map((node) => node.toIdentifiers()),
+        indexesOfPoints,
+        letters: arrLetter,
+    };
+    return identifiers;
+};
+const getComplexGeomArgumentOfFracCBABFromFigureQuestion = () => {
+    // const identifiers = createQCPassedIdentifiers();
+    const identifiers = createRandomIdentifiers();
+    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 complexGeomArgumentOfFracCBABFromFigure = {
+    id: "complexGeomArgumentOfFracCBABFromFigure",
+    label: "Déterminer l'argument d'un nombre complexe de la forme $\\frac{c-b}{a-b}$ à partir d'une figure",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomArgumentOfFracCBABFromFigureQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};