math-exercises 3.0.214 → 3.0.216

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

@@ -0,0 +1,151 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { mainTrigoValues } from "../../../../math/trigonometry/remarkableValues.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { ComplexNode } from "../../../../tree/nodes/complex/complexNode.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, moduleIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, getAnswer({
+            moduleIds,
+            argIds: random(mainTrigoValues).angle.toIdentifiers(),
+        }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { argIds, moduleIds } = identifiers;
+    const arg = reifyAlgebraic(argIds);
+    const module = reifyAlgebraic(moduleIds);
+    const re = multiply(module, cos(arg)).simplify();
+    const im = multiply(module, sin(arg)).simplify();
+    return new ComplexNode(re, im).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { argIds, moduleIds } = identifiers;
+    const arg = reifyAlgebraic(argIds);
+    const module = reifyAlgebraic(moduleIds);
+    return `Donner la forme algbérique du nombre complexe $z$ tel que :
+
+$$
+|z| = ${module.toTex()}
+$$
+
+et
+
+$$
+\\arg(z) = ${arg.toTex()} \\ (2\\pi)
+$$`;
+};
+const getHint = () => {
+    return `Soit $z$ un nombre complexe de module $r$ et dont un argument est $\\theta$.
+  
+Alors $z$ peut s'écrire sous sa forme trigonométrique : 
+
+$$
+z = r \\left(\\cos\\left(\\theta\\right) + i \\sin\\left(\\theta\\right)\\right)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { argIds, moduleIds } = identifiers;
+    const arg = reifyAlgebraic(argIds);
+    const module = reifyAlgebraic(moduleIds);
+    return `Soit $z$ un nombre complexe de module $r$ et dont un argument est $\\theta$.
+  
+Alors $z$ peut s'écrire sous sa forme trigonométrique : 
+
+$$
+z = r \\left(\\cos\\left(\\theta\\right) + i \\sin\\left(\\theta\\right)\\right)
+$$
+
+Ici, $r = ${module.toTex()}$ et $\\theta = ${arg.toTex()}$. 
+
+On a donc :
+
+${alignTex([
+        ["z", "=", multiply(module, add(cos(arg), multiply("i", sin(arg)))).toTex()],
+        [
+            "",
+            "=",
+            multiply(module, add(cos(arg).simplify(), multiply(sin(arg).simplify(), "i"))).toTex({
+                forceNoSimplification: true,
+            }),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getKeys = () => {
+    return ["i"];
+};
+const isAnswerValid = (ans, { answer: _answer, ...identifiers }) => {
+    try {
+        const { argIds, moduleIds } = identifiers;
+        const parsed = parseAlgebraic(ans);
+        const arg = reifyAlgebraic(argIds);
+        const module = reifyAlgebraic(moduleIds);
+        return (multiply(module, add(cos(arg), multiply("i", sin(arg))))
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex() ===
+            parsed
+                .simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+            })
+                .toTex());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getComplexAlgebraicFromModuloAndArgQuestion = () => {
+    const module = randint(2, 10);
+    const arg = random(mainTrigoValues).angle;
+    const identifiers = {
+        moduleIds: module.toTree().toIdentifiers(),
+        argIds: arg.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const complexAlgebraicFromModuloAndArg = {
+    id: "complexAlgebraicFromModuloAndArg",
+    connector: "=",
+    label: "Écrire la forme algébrique d'un nombre complexe dont le module et un argument sont donnés",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexAlgebraicFromModuloAndArgQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aReIds: NodeIdentifiers;
+    aImIds: NodeIdentifiers;
+    bReIds: NodeIdentifiers;
+    bImIds: NodeIdentifiers;
+};
+export declare const complexDistance: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexDistance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexDistance.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexDistance.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,MAAM,EAAE,eAAe,CAAC;IACxB,MAAM,EAAE,eAAe,CAAC;IACxB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AA4GF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAkBjD,CAAC"}

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

@@ -0,0 +1,125 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { sqrtVEA } from "../../../../exercises/vea/sqrtVEA.js";
+import { SquareRootConstructor } from "../../../../math/numbers/reals/real.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.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 { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, SquareRootConstructor.randomIrreductible().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aReIds, aImIds, bReIds, bImIds } = identifiers;
+    const aRe = reifyAlgebraic(aReIds);
+    const aIm = reifyAlgebraic(aImIds);
+    const bRe = reifyAlgebraic(bReIds);
+    const bIm = reifyAlgebraic(bImIds);
+    const subRe = substract(aRe, bRe).simplify();
+    const subIm = substract(aIm, bIm).simplify();
+    const squareRoot = sqrt(add(square(subRe), square(subIm)))
+        .simplify()
+        .toTex();
+    return squareRoot;
+};
+const getInstruction = (identifiers) => {
+    const { aReIds, aImIds, bReIds, bImIds } = identifiers;
+    const aRe = reifyAlgebraic(aReIds);
+    const aIm = reifyAlgebraic(aImIds);
+    const bRe = reifyAlgebraic(bReIds);
+    const bIm = reifyAlgebraic(bImIds);
+    const affA = add(aRe, multiply(aIm, "i")).toTex();
+    const affB = add(bRe, multiply(bIm, "i")).toTex();
+    return `Dans le plan complexe, on considère le point $A$ d'affixe $${affA}$ et le point $B$ d'affixe $${affB}$.
+  
+Déterminer $AB$.`;
+};
+const getHint = () => {
+    return `Si $a$ est l'affixe d'un point $A$ et $b$ celle d'un point $B$, alors :
+  
+$$
+AB = |a-b| = |b-a|
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aReIds, aImIds, bReIds, bImIds } = identifiers;
+    const aRe = reifyAlgebraic(aReIds);
+    const aIm = reifyAlgebraic(aImIds);
+    const bRe = reifyAlgebraic(bReIds);
+    const bIm = reifyAlgebraic(bImIds);
+    const subRe = substract(aRe, bRe).simplify();
+    const subIm = substract(aIm, bIm).simplify();
+    const affA = add(aRe, multiply(aIm, "i"));
+    const affB = add(bRe, multiply(bIm, "i"));
+    return `On a : 
+
+${alignTex([
+        ["AB", "=", `|${substract(affA, affB).toTex()}|`],
+        ["", "=", `|${add(subRe, multiply(subIm, "i")).toTex()}|`],
+        ["", "=", sqrt(add(square(subRe), square(subIm))).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}  `;
+};
+const getKeys = () => {
+    return ["i"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return sqrtVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getComplexDistanceQuestion = () => {
+    const aRe = randint(-10, 10, [0]);
+    const aIm = randint(-10, 10, [0]);
+    const bRe = randint(-10, 10, [0]);
+    const bIm = randint(-10, 10, [0, aIm]);
+    const identifiers = {
+        aImIds: aIm.toTree().toIdentifiers(),
+        aReIds: aRe.toTree().toIdentifiers(),
+        bImIds: bIm.toTree().toIdentifiers(),
+        bReIds: bRe.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const complexDistance = {
+    id: "complexDistance",
+    connector: "=",
+    label: "Calculer une distance dans le plan complexe",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexDistanceQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsX: NodeIdentifiers;
+    nodeIdsY: NodeIdentifiers;
+};
+export declare const complexGeomAffixAlgFromPoint: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexGeomAffixAlgFromPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomAffixAlgFromPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomAffixAlgFromPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAYrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgC7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AA+UF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAiB9D,CAAC"}

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

@@ -0,0 +1,326 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { ComplexNode } from "../../../../tree/nodes/complex/complexNode.js";
+import { isOppositeNode, opposite, } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { add, isAddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { isMultiplyNode, multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isSubstractNode, 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 { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+class MyReverseOrderedComplexNode extends ComplexNode {
+    toTex() {
+        const nodeI = new VariableNode("i");
+        if (NodeComparator.isEqualViaSub(this.im, (0).toTree()))
+            return this.re.toTex();
+        if (NodeComparator.isEqualViaSub(this.re, (0).toTree())) {
+            return new MultiplyNode(this.im, nodeI).toTex();
+        }
+        return add(multiply(this.im, nodeI), this.re).toTex();
+    }
+}
+const getHydrated = (identifiers) => {
+    const { nodeIdsX, nodeIdsY } = identifiers;
+    const [nodeX, nodeY] = [nodeIdsX, nodeIdsY].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeAffix = new ComplexNode(nodeX, nodeY);
+    const pointM = new Point("M", nodeX, nodeY);
+    return {
+        nodeX,
+        nodeY,
+        nodeAffix,
+        pointM,
+    };
+};
+const getInstruction = (_identifiers) => {
+    return `On considère le point $M$ placé dans le plan complexe ci-dessous.
+  
+Donner l'affixe de $M$, sous forme algébrique.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeAffix } = getHydrated(identifiers);
+    return nodeAffix;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Soit $z$ l'affixe du point $M$. 
+L'écriture sous forme algébrique de $z$ est :
+  
+$$
+\\text{Re}(z) + i \\ \\text{Im}(z)
+$$
+
+La partie réelle se lit sur l'axe des abscisses et la partie imaginaire sur l'axe des imaginaires purs.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeX, nodeY, nodeAffix } = getHydrated(identifiers);
+    return `Soit $z$ l'affixe du point $M$.
+  
+L'abscisse du point $M$ est $${nodeX.toTex()}$.
+La partie réelle de $z$ est donc $${nodeX.toTex()}$.
+
+L'ordonnée du point $M$ est $${nodeY.toTex()}$.
+La partie imaginaire de $z$ est donc $${nodeY.toTex()}$.
+
+L'affixe de $M$ est donc $${nodeAffix.toTex()}$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { pointM } = getHydrated(identifiers);
+    const ggb = new GeogebraConstructor({
+        isGridSimple: true,
+        commands: [
+            //pointM
+            ...[
+                `M = ${pointM.toMathString()}`,
+                `SetFixed(M, true, false)`,
+                `ShowLabel(M, true)`,
+            ],
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: [-4.1, 4.1, -4.1, 4.1],
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { nodeX, nodeY, nodeAffix } = getHydrated(identifiers);
+    const [isReverseOrder, nodeAffixValid] = (() => {
+        if (NodeComparator.isEqualViaSub(nodeX, (0).toTree()) ||
+            NodeComparator.isEqualViaSub(nodeY, (0).toTree())) {
+            return [false, nodeAffix];
+        }
+        else {
+            const isReverseOrder = coinFlip();
+            const nodeAffix = isReverseOrder
+                ? new MyReverseOrderedComplexNode(nodeX, nodeY)
+                : new ComplexNode(nodeX, nodeY);
+            return [isReverseOrder, nodeAffix];
+        }
+    })();
+    addValidProp(propositions, nodeAffixValid.toTex());
+    //student: x<->y
+    if (isReverseOrder) {
+        const nodeAffixWrong = !isReverseOrder
+            ? new MyReverseOrderedComplexNode(nodeY, nodeX)
+            : new ComplexNode(nodeY, nodeX);
+        tryToAddWrongProp(propositions, nodeAffixWrong.toTex());
+    }
+    //student: forgets i
+    {
+        const nodeAffixWrong = add(nodeX, nodeY);
+        tryToAddWrongProp(propositions, nodeAffixWrong.toTex());
+    }
+    //student: reads wrong: offset
+    {
+        const isFarX = Math.abs(nodeX.evaluate()) > 3;
+        const isFarY = Math.abs(nodeY.evaluate()) > 3;
+        if (isFarX && isFarY) {
+            const [vOffsetX, vOffsetY] = probaLawFlip([
+                [[coinFlip() ? +1 : -1, 0], 0.4],
+                [[0, coinFlip() ? +1 : -1], 0.4],
+                [[coinFlip() ? +1 : -1, coinFlip() ? +1 : -1], 0.2],
+            ]);
+            const nodeXWrong = add(nodeX, vOffsetX).simplify({
+                towardsDistribute: true,
+            });
+            const nodeYWrong = add(nodeY, vOffsetY).simplify({
+                towardsDistribute: true,
+            });
+            const nodeAffixWrong = coinFlip()
+                ? new MyReverseOrderedComplexNode(nodeXWrong, nodeYWrong)
+                : new ComplexNode(nodeXWrong, nodeYWrong);
+            tryToAddWrongProp(propositions, nodeAffixWrong.toTex());
+        }
+        else {
+            if (isFarX) {
+                const vOffsetX = coinFlip() ? +1 : -1;
+                const nodeXWrong = add(nodeX, vOffsetX).simplify({
+                    towardsDistribute: true,
+                });
+                const nodeAffixWrong = coinFlip()
+                    ? new MyReverseOrderedComplexNode(nodeXWrong, nodeY)
+                    : new ComplexNode(nodeXWrong, nodeY);
+                tryToAddWrongProp(propositions, nodeAffixWrong.toTex());
+            }
+            else {
+                const vOffsetY = coinFlip() ? +1 : -1;
+                const nodeYWrong = add(nodeY, vOffsetY).simplify({
+                    towardsDistribute: true,
+                });
+                const nodeAffixWrong = coinFlip()
+                    ? new MyReverseOrderedComplexNode(nodeX, nodeYWrong)
+                    : new ComplexNode(nodeX, nodeYWrong);
+                tryToAddWrongProp(propositions, nodeAffixWrong.toTex());
+            }
+        }
+    }
+    //filler
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["i"];
+};
+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({ towardsDistribute: true });
+            //pour chopper le terme en i...
+            const nodeYAns = nodeBySubstitutingVar(substract(nodeAns, nodeXAns), (1).toTree(), nodeI).simplify({ towardsDistribute: true });
+            return [nodeXAns, nodeYAns];
+        })();
+        // console.log(
+        //   "[nodeXAns, nodeYAns]",
+        //   [nodeXAns, nodeYAns].map((node) => node.toTex()),
+        // );
+        const { nodeX, nodeY } = getHydrated(identifiers);
+        // console.log(
+        //   "[nodeX, nodeY]",
+        //   [nodeX, nodeY].map((node) => node.toTex()),
+        // );
+        // const nodeI = new VariableNode("i");
+        // const nodeAffixAnswer = add(nodeX, multiply(nodeY, nodeI)).simplify({
+        //   towardsDistribute: true,
+        // });
+        const isRealNumberNode = (node) => {
+            if (isNumberNode(node)) {
+                return true;
+            }
+            else if (isOppositeNode(node)) {
+                if (isNumberNode(node.child)) {
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+            else {
+                return false;
+            }
+        };
+        const isImaginaryNumberNode = (node) => {
+            if (!isMultiplyNode(node)) {
+                if (NodeComparator.isEqualViaSub(node, nodeI)) {
+                    return true;
+                }
+                else if (NodeComparator.isEqualViaSub(node, opposite(nodeI))) {
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+            else {
+                if (isRealNumberNode(node.leftChild) &&
+                    NodeComparator.isEqualViaSub(nodeI, node.rightChild)) {
+                    return true;
+                }
+                else if (NodeComparator.isEqualViaSub(nodeI, node.leftChild) &&
+                    isRealNumberNode(node.rightChild)) {
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+        };
+        //filter out invalid inputs
+        if (NodeComparator.isEqualViaSub(nodeX, (0).toTree())) {
+            if (!isRealNumberNode(nodeYAns)) {
+                return false;
+            }
+        }
+        else if (NodeComparator.isEqualViaSub(nodeY, (0).toTree())) {
+            if (!isRealNumberNode(nodeXAns)) {
+                return false;
+            }
+        }
+        else {
+            if (!(isAddNode(nodeAns) || isSubstractNode(nodeAns))) {
+                return false;
+            }
+            if (isRealNumberNode(nodeAns.leftChild) &&
+                isImaginaryNumberNode(nodeAns.rightChild)) {
+                //pass
+            }
+            else if (isImaginaryNumberNode(nodeAns.leftChild) &&
+                isRealNumberNode(nodeAns.rightChild)) {
+                //pass
+            }
+            else {
+                return false;
+            }
+        }
+        return (NodeComparator.isEqualViaSub(nodeXAns, nodeX) &&
+            NodeComparator.isEqualViaSub(nodeYAns, nodeY));
+    }
+    catch (err) {
+        console.log("err", err);
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const [isZeroAllowedX, isZeroAllowedY] = random([
+        [true, false],
+        [false, true],
+        [false, false],
+    ]);
+    const valueX = randint(-4, 4, isZeroAllowedX ? [] : [0]);
+    const valueY = randint(-4, 4, isZeroAllowedY ? [] : [0]);
+    const identifiers = {
+        nodeIdsX: valueX.toTree().toIdentifiers(),
+        nodeIdsY: valueY.toTree().toIdentifiers(),
+    };
+    return identifiers;
+};
+const getComplexGeomAffixAlgFromPointQuestion = () => {
+    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),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const complexGeomAffixAlgFromPoint = {
+    id: "complexGeomAffixAlgFromPoint",
+    label: "Déterminer l'affixe d'un point sous forme algébrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexGeomAffixAlgFromPointQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nbSides: number;
+    vFactor: number;
+    nodeIdsModule: NodeIdentifiers;
+};
+export declare const complexGeomAffixExpFromCenteredRegularPolygon: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexGeomAffixExpFromCenteredRegularPolygon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexGeomAffixExpFromCenteredRegularPolygon.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/geometric/complexGeomAffixExpFromCenteredRegularPolygon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAqF7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,eAAe,CAAC;CAChC,CAAC;AAqhBF,eAAO,MAAM,6CAA6C,EAAE,QAAQ,CAAC,WAAW,CAmB7E,CAAC"}