math-exercises 3.0.212 → 3.0.214

package/lib/exercises/math/complex/exp/complexAlgebraicFromExpForm.js

@@ -0,0 +1,178 @@
+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 { abs } from "../../../../tree/nodes/functions/absNode.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, rIds, thetaIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, getAnswer({
+        rIds: (1).toTree().toIdentifiers(),
+        thetaIds: thetaIds,
+    }));
+    propWhile(propositions, n, () => {
+        const fakeTheta = random(mainTrigoValues).angle;
+        tryToAddWrongProp(propositions, getAnswer({
+            rIds,
+            thetaIds: fakeTheta.toIdentifiers(),
+        }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getRawAnswerNode = (identifiers) => {
+    const { rIds, thetaIds } = identifiers;
+    const r = reifyAlgebraic(rIds);
+    const theta = reifyAlgebraic(thetaIds);
+    const re = multiply(r, cos(theta)).simplify();
+    const im = multiply(r, sin(theta)).simplify();
+    return add(re, multiply(im, "i"));
+};
+const getAnswer = (identifiers) => {
+    return getRawAnswerNode(identifiers)
+        .simplify({
+        noAddOrder: true,
+        forceDistributeFractions: true,
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { rIds, thetaIds } = identifiers;
+    const r = reifyAlgebraic(rIds);
+    const theta = reifyAlgebraic(thetaIds);
+    const rawTheta = abs(theta).simplify();
+    return `Soit le nombre complexe : 
+  
+$$
+z = ${r.toTex()}e^{${theta.evaluate() < 0 ? "-" : ""}${multiply("i", rawTheta).toTex({
+        forceNoTimesSign: true,
+    })}}
+$$
+
+Écrire $z$ sous forme algébrique.`;
+};
+const getHint = () => {
+    return `Pour tout réel $\\theta$, on a :
+  
+$$
+e^{i\\theta} = \\cos(\\theta)+i\\sin(\\theta)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { rIds, thetaIds } = identifiers;
+    const r = reifyAlgebraic(rIds);
+    const theta = reifyAlgebraic(thetaIds);
+    const rawTheta = abs(theta).simplify();
+    const rawRe = cos(theta).simplify().toTex();
+    const rawIm = multiply("i", sin(theta))
+        .simplify({
+        forceDistributeFractions: true,
+    })
+        .toTex();
+    return `Pour tout réel $\\theta$, on a :
+  
+$$
+e^{i\\theta} = \\cos(\\theta)+i\\sin(\\theta)
+$$
+
+Ici, on a donc : 
+
+${alignTex([
+        [
+            `e^{${theta.evaluate() < 0 ? "-" : ""}${multiply("i", rawTheta).toTex({
+                forceNoTimesSign: true,
+            })}}`,
+            "=",
+            cos(theta).toTex() + "+" + multiply("i", sin(theta)).toTex(),
+        ],
+        [
+            "",
+            "=",
+            add(rawRe, rawIm)
+                .simplify({
+                noAddOrder: true,
+            })
+                .toTex(),
+        ],
+    ])}
+
+On multiplie alors par $${r.toTex()}$ : 
+
+$$
+z = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getKeys = () => {
+    return ["i"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+            forceDistributeFractions: true,
+        })
+            .toTex() ===
+            getRawAnswerNode(identifiers)
+                .simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+                forceDistributeFractions: true,
+            })
+                .toTex());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getComplexAlgebraicFromExpFormQuestion = () => {
+    const angle = random(mainTrigoValues).angle;
+    const r = randint(1, 10);
+    const identifiers = {
+        rIds: r.toTree().toIdentifiers(),
+        thetaIds: angle.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 complexAlgebraicFromExpForm = {
+    id: "complexAlgebraicFromExpForm",
+    connector: "=",
+    label: "Donner la forme algébrique d'un complexe écrit sous forme exponentielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexAlgebraicFromExpFormQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/complex/exp/complexExpFormPowerSimplify.d.ts

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

package/lib/exercises/math/complex/exp/complexExpFormPowerSimplify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexExpFormPowerSimplify.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/exp/complexExpFormPowerSimplify.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,eAAe,CAAC;IAC7B,QAAQ,EAAE,eAAe,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AA4JF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAsB7D,CAAC"}

package/lib/exercises/math/complex/exp/complexExpFormPowerSimplify.js

@@ -0,0 +1,152 @@
+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 { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { logn } from "../../../../tree/nodes/functions/logNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { z1ArgIds, z1ModuleIds, pow } = identifiers;
+    const z1Arg = reifyAlgebraic(z1ArgIds);
+    const z1Module = reifyAlgebraic(z1ModuleIds);
+    const module = power(z1Module, pow).simplify();
+    const arg = multiply(z1Arg, pow).simplify();
+    propWhile(propositions, n, () => {
+        const z1ModuleFake = randint(2, 10);
+        const z1ArgFake = random(mainTrigoValues.filter((a) => a.angle.evaluate({}) !== 0));
+        const moduleFake = power(z1ModuleFake, pow).simplify();
+        const argFake = multiply(z1ArgFake.angle, pow).simplify();
+        if (module.toTex() === moduleFake.toTex() &&
+            frac(substract(argFake, arg), PiNode).simplify().evaluate() % 2 === 0)
+            return;
+        tryToAddWrongProp(propositions, `${moduleFake.toTex()}${getExpTex(argFake)}`);
+    });
+    return shuffleProps(propositions, n);
+};
+const getExpTex = (theta) => {
+    const rawTheta = abs(theta).simplify();
+    return `e^{${theta.evaluate() < 0 ? "-" : ""}${multiply("i", rawTheta).toTex({
+        forceNoTimesSign: true,
+    })}}`;
+};
+const getAnswer = (identifiers) => {
+    const { z1ArgIds, z1ModuleIds, pow } = identifiers;
+    const z1Arg = reifyAlgebraic(z1ArgIds);
+    const z1Module = reifyAlgebraic(z1ModuleIds);
+    const module = power(z1Module, pow).simplify();
+    const arg = multiply(z1Arg, pow).simplify();
+    return `${module.toTex()}${getExpTex(arg)}`;
+};
+const getInstruction = (identifiers) => {
+    throw new Error("wtf, 9^3e^3 plante, le parsage des puissances doit être tout pété. Aussi 9^3\\cos^3 donne un truc trop chelou. Après investigation : a^bc est mal parsé, que a soit nb ou e : il faut cut à a^b*c mais c'est parsé en a^{bc}...");
+    const { z1ArgIds, z1ModuleIds, pow } = identifiers;
+    const z1Arg = reifyAlgebraic(z1ArgIds);
+    const z1Module = reifyAlgebraic(z1ModuleIds);
+    return `Écrire sous forme exponentielle :
+  
+$$
+\\left(${z1Module.toTex()}${getExpTex(z1Arg)}\\right)^{${pow}}
+$$`;
+};
+const getHint = () => {
+    return `Pour tous nombres réels $\\theta$ et $\\theta'$ et tout entier relatif $n$, on a : 
+  
+$$
+\\left(e^{i\\theta}\\right)^n  = e^{in\\theta}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { z1ArgIds, z1ModuleIds, pow } = identifiers;
+    const z1Arg = reifyAlgebraic(z1ArgIds);
+    const z1Module = reifyAlgebraic(z1ModuleIds);
+    return `On utilise la relation fonctionnelle : pour tous nombres réels $\\theta$ et $\\theta'$ et tout entier relatif $n$, on a 
+  
+$$
+\\left(e^{i\\theta}\\right)^n  = e^{in\\theta}
+$$
+
+Ici, on a donc : 
+
+${alignTex([
+        ["", `\\left(${z1Module.toTex()}${getExpTex(z1Arg)}\\right)^{${pow}}`],
+        [
+            "=",
+            multiply(power(z1Module, pow), exp(multiply("i", multiply(z1Arg, pow)))).toTex(),
+        ],
+        ["=", getAnswer(identifiers)],
+    ])}`;
+};
+const getKeys = () => {
+    return ["epower", "i", "pi"];
+};
+const isAnswerValid = (ans, { z1ArgIds, z1ModuleIds, pow }) => {
+    try {
+        const z1Arg = reifyAlgebraic(z1ArgIds);
+        const z1Module = reifyAlgebraic(z1ModuleIds);
+        const module = power(z1Module, pow).simplify();
+        const angle = multiply(z1Arg, pow).simplify();
+        const parsed = parseAlgebraic(ans);
+        const expForm = multiply(module, exp(multiply("i", angle))).simplify();
+        console.log(expForm.toTex());
+        console.log(parsed.simplify().toTex());
+        const divided = frac(expForm, parsed).simplify();
+        return (parsed.simplify().toTex() === expForm.toTex() ||
+            frac(logn(divided), multiply(PiNode, "i")).simplify().evaluate() % 2 === 0);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getComplexExpFormPowerSimplifyQuestion = () => {
+    const z1Module = randint(2, 10);
+    const z1Arg = random(mainTrigoValues.filter((a) => a.angle.evaluate({}) !== 0));
+    const pow = doWhile(() => randint(2, 10), (x) => frac(multiply(z1Arg.angle, x), PiNode).simplify().evaluate({}) % 2 === 0);
+    const identifiers = {
+        z1ArgIds: z1Arg.angle.toIdentifiers(),
+        z1ModuleIds: z1Module.toTree().toIdentifiers(),
+        pow,
+    };
+    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 complexExpFormPowerSimplify = {
+    id: "complexExpFormPowerSimplify",
+    connector: "=",
+    label: "Simplifier une puissance de formes exponentielles de nombres complexes",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexExpFormPowerSimplifyQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/complex/exp/complexExpFormProductSimplify.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    z1ModuleIds: NodeIdentifiers;
+    z1ArgIds: NodeIdentifiers;
+    z2ModuleIds: NodeIdentifiers;
+    z2ArgIds: NodeIdentifiers;
+};
+export declare const complexExpFormProductSimplify: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexExpFormProductSimplify.d.ts.map

package/lib/exercises/math/complex/exp/complexExpFormProductSimplify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexExpFormProductSimplify.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/exp/complexExpFormProductSimplify.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,eAAe,CAAC;IAC7B,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,eAAe,CAAC;IAC7B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAiLF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}

package/lib/exercises/math/complex/exp/complexExpFormProductSimplify.js

@@ -0,0 +1,165 @@
+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 { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { logn } from "../../../../tree/nodes/functions/logNode.js";
+import { reifyAlgebraic, } 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 { 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, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { z1ArgIds, z1ModuleIds, z2ArgIds, z2ModuleIds } = identifiers;
+    const z1Arg = reifyAlgebraic(z1ArgIds);
+    const z1Module = reifyAlgebraic(z1ModuleIds);
+    const z2Arg = reifyAlgebraic(z2ArgIds);
+    const z2Module = reifyAlgebraic(z2ModuleIds);
+    const module = multiply(z1Module, z2Module).simplify();
+    const arg = add(z1Arg, z2Arg).simplify();
+    propWhile(propositions, n, () => {
+        const z1ModuleFake = randint(2, 10);
+        const z2ModuleFake = randint(2, 10);
+        const z1ArgFake = random(mainTrigoValues.filter((a) => a.angle.evaluate({}) !== 0));
+        const z2ArgFake = random(mainTrigoValues.filter((a) => a.angle.evaluate({}) !== 0 &&
+            Math.abs(a.angle.evaluate()) !== Math.abs(z1ArgFake.angle.evaluate())));
+        const moduleFake = multiply(z1ModuleFake, z2ModuleFake).simplify();
+        const argFake = add(z1ArgFake.angle, z2ArgFake.angle).simplify();
+        if (module.toTex() === moduleFake.toTex() &&
+            frac(substract(argFake, arg), PiNode).simplify().evaluate() % 2 === 0)
+            return;
+        tryToAddWrongProp(propositions, `${moduleFake.toTex()}${getExpTex(argFake)}`);
+    });
+    return shuffleProps(propositions, n);
+};
+const getExpTex = (theta) => {
+    const rawTheta = abs(theta).simplify();
+    return `e^{${theta.evaluate() < 0 ? "-" : ""}${multiply("i", rawTheta).toTex({
+        forceNoTimesSign: true,
+    })}}`;
+};
+const getAnswer = (identifiers) => {
+    const { z1ArgIds, z1ModuleIds, z2ArgIds, z2ModuleIds } = identifiers;
+    const z1Arg = reifyAlgebraic(z1ArgIds);
+    const z1Module = reifyAlgebraic(z1ModuleIds);
+    const z2Arg = reifyAlgebraic(z2ArgIds);
+    const z2Module = reifyAlgebraic(z2ModuleIds);
+    const module = multiply(z1Module, z2Module).simplify();
+    const arg = add(z1Arg, z2Arg).simplify();
+    return `${module.toTex()}${getExpTex(arg)}`;
+};
+const getInstruction = (identifiers) => {
+    const { z1ArgIds, z1ModuleIds, z2ArgIds, z2ModuleIds } = identifiers;
+    const z1Arg = reifyAlgebraic(z1ArgIds);
+    const z1Module = reifyAlgebraic(z1ModuleIds);
+    const z2Arg = reifyAlgebraic(z2ArgIds);
+    const z2Module = reifyAlgebraic(z2ModuleIds);
+    return `Écrire sous forme exponentielle :
+  
+$$
+\\left(${z1Module.toTex()}${getExpTex(z1Arg)}\\right)\\left(${z2Module.toTex()}${getExpTex(z2Arg)}\\right)
+$$`;
+};
+const getHint = () => {
+    return `Pour tous nombres réels $\\theta$ et $\\theta'$, on a : 
+  
+$$
+e^{i\\theta} \\times e^{i\\theta'} = e^{i\\left(\\theta+\\theta'\\right)}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { z1ArgIds, z1ModuleIds, z2ArgIds, z2ModuleIds } = identifiers;
+    const z1Arg = reifyAlgebraic(z1ArgIds);
+    const z1Module = reifyAlgebraic(z1ModuleIds);
+    const z2Arg = reifyAlgebraic(z2ArgIds);
+    const z2Module = reifyAlgebraic(z2ModuleIds);
+    const module = multiply(z1Module, z2Module).simplify();
+    return `On utilise la relation fonctionnelle : pour tous nombres réels $\\theta$ et $\\theta'$, on a 
+  
+$$
+e^{i\\theta} \\times e^{i\\theta'} = e^{i\\left(\\theta+\\theta'\\right)}
+$$
+
+Ici, on a donc : 
+
+${alignTex([
+        [
+            "",
+            `\\left(${z1Module.toTex()}${getExpTex(z1Arg)}\\right)\\left(${z2Module.toTex()}${getExpTex(z2Arg)}\\right)`,
+        ],
+        ["=", multiply(module, exp(multiply("i", add(z1Arg, z2Arg)))).toTex()],
+        ["=", getAnswer(identifiers)],
+    ])}`;
+};
+const getKeys = () => {
+    return ["epower", "i", "pi"];
+};
+const isAnswerValid = (ans, { z1ArgIds, z1ModuleIds, z2ArgIds, z2ModuleIds }) => {
+    try {
+        const z1Arg = reifyAlgebraic(z1ArgIds);
+        const z1Module = reifyAlgebraic(z1ModuleIds);
+        const z2Arg = reifyAlgebraic(z2ArgIds);
+        const z2Module = reifyAlgebraic(z2ModuleIds);
+        const module = multiply(z1Module, z2Module).simplify();
+        const angle = add(z1Arg, z2Arg).simplify();
+        const parsed = parseAlgebraic(ans);
+        const expForm = multiply(module, exp(multiply("i", angle))).simplify();
+        const divided = frac(expForm, parsed).simplify();
+        return (parsed.simplify().toTex() === expForm.toTex() ||
+            frac(logn(divided), multiply(PiNode, "i")).simplify().evaluate() % 2 === 0);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getComplexExpFormProductSimplifyQuestion = () => {
+    const z1Module = randint(2, 10);
+    const z2Module = randint(2, 10);
+    const z1Arg = random(mainTrigoValues.filter((a) => a.angle.evaluate({}) !== 0));
+    const z2Arg = random(mainTrigoValues.filter((a) => a.angle.evaluate({}) !== 0 &&
+        Math.abs(a.angle.evaluate()) !== Math.abs(z1Arg.angle.evaluate())));
+    const identifiers = {
+        z1ArgIds: z1Arg.angle.toIdentifiers(),
+        z1ModuleIds: z1Module.toTree().toIdentifiers(),
+        z2ArgIds: z2Arg.angle.toIdentifiers(),
+        z2ModuleIds: z2Module.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 complexExpFormProductSimplify = {
+    id: "complexExpFormProductSimplify",
+    connector: "=",
+    label: "Simplifier un produit de formes exponentielles de nombres complexes",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexExpFormProductSimplifyQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/complex/exp/complexExpFormQuotientSimplify.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    z1ModuleIds: NodeIdentifiers;
+    z1ArgIds: NodeIdentifiers;
+    z2ModuleIds: NodeIdentifiers;
+    z2ArgIds: NodeIdentifiers;
+};
+export declare const complexExpFormQuotientSimplify: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=complexExpFormQuotientSimplify.d.ts.map

package/lib/exercises/math/complex/exp/complexExpFormQuotientSimplify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexExpFormQuotientSimplify.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/exp/complexExpFormQuotientSimplify.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,eAAe,CAAC;IAC7B,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,eAAe,CAAC;IAC7B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAiLF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAqBhE,CAAC"}