math-exercises 3.0.212 → 3.0.214

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

@@ -0,0 +1,164 @@
+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 { 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 = frac(z1Module, z2Module).simplify();
+    const arg = substract(z1Arg, z2Arg).simplify();
+    propWhile(propositions, n, () => {
+        const z1ModuleFake = randint(2, 10);
+        const z2ModuleFake = randint(2, 10, [z1ModuleFake]);
+        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 = frac(z1ModuleFake, z2ModuleFake).simplify();
+        const argFake = substract(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 = frac(z1Module, z2Module).simplify();
+    const arg = substract(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 :
+  
+$$
+\\frac{${z1Module.toTex()}${getExpTex(z1Arg)}}{${z2Module.toTex()}${getExpTex(z2Arg)}}
+$$`;
+};
+const getHint = () => {
+    return `Pour tous nombres réels $\\theta$ et $\\theta'$, on a : 
+  
+$$
+\\frac{e^{i\\theta}}{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 = frac(z1Module, z2Module).simplify();
+    return `On utilise la relation fonctionnelle : pour tous nombres réels $\\theta$ et $\\theta'$, on a 
+  
+$$
+\\frac{e^{i\\theta}}{e^{i\\theta'}} = e^{i\\left(\\theta-\\theta'\\right)}
+$$
+
+Ici, on a donc : 
+
+${alignTex([
+        [
+            "",
+            `\\frac{${z1Module.toTex()}${getExpTex(z1Arg)}}{${z2Module.toTex()}${getExpTex(z2Arg)}}`,
+        ],
+        ["=", multiply(module, exp(multiply("i", substract(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 = frac(z1Module, z2Module).simplify();
+        const angle = substract(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 getComplexExpFormQuotientSimplifyQuestion = () => {
+    const z1Module = randint(2, 10);
+    const z2Module = randint(2, 10, [z1Module]);
+    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 complexExpFormQuotientSimplify = {
+    id: "complexExpFormQuotientSimplify",
+    connector: "=",
+    label: "Simplifier un quotient de formes exponentielles de nombres complexes",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexExpFormQuotientSimplifyQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexExpFromAlgebraicForm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/exp/complexExpFromAlgebraicForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AA2KF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAsB7D,CAAC"}

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

@@ -0,0 +1,175 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.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 { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { logn } from "../../../../tree/nodes/functions/logNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.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 { square } from "../../../../tree/nodes/operators/powerNode.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 }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const theta = random(mainTrigoValues.filter((a) => a.angle.evaluate({}) !== 0));
+        const rawTheta = abs(theta.angle).simplify();
+        const module = random([
+            randint(2, 6).toTree(),
+            RationalConstructor.randomIrreductible().toTree(),
+            random([sqrt(2), sqrt(3)]),
+        ]);
+        tryToAddWrongProp(propositions, `${module.toTex()}e^{${theta.angle.evaluate() < 0 ? "-" : ""}${multiply("i", rawTheta).toTex({
+            forceNoTimesSign: true,
+        })}}`);
+    });
+    return shuffleProps(propositions, n);
+};
+const getParams = (identifiers) => {
+    const { reIds, imIds } = identifiers;
+    const re = reifyAlgebraic(reIds);
+    const im = reifyAlgebraic(imIds);
+    const module = sqrt(add(square(re), square(im))).simplify();
+    const cos = frac(re, module).simplify();
+    const sin = frac(im, module).simplify();
+    const theta = mainTrigoValues.find((point) => Math.abs(point.cos.evaluate({}) - cos.evaluate()) < 0.01 &&
+        Math.abs(point.sin.evaluate({}) - sin.evaluate()) < 0.01);
+    return [module, theta];
+};
+const getAnswer = (identifiers) => {
+    const [module, theta] = getParams(identifiers);
+    const rawTheta = abs(theta.angle).simplify();
+    return `${module.toTex()}e^{${theta.angle.evaluate() < 0 ? "-" : ""}${multiply("i", rawTheta).toTex({
+        forceNoTimesSign: true,
+    })}}`;
+};
+const getInstruction = (identifiers) => {
+    const { reIds, imIds } = identifiers;
+    const re = reifyAlgebraic(reIds);
+    const im = reifyAlgebraic(imIds);
+    return `Soit le nombre complexe :
+
+$$
+z = ${new ComplexNode(re, im).toTex()}
+$$
+
+Écrire $z$ sous forme exponentielle.`;
+};
+const getHint = () => {
+    return `Tout nombre complexe $z$ non nul peut s'écrire sous forme exponentielle : 
+  
+$$
+z = re^{i\\theta}
+$$
+
+où $r$ est le module de $z$, et $\\theta$ est un argument de $z$.`;
+};
+const getCorrection = (identifiers) => {
+    const { reIds, imIds } = identifiers;
+    const re = reifyAlgebraic(reIds);
+    const im = reifyAlgebraic(imIds);
+    const [module, ang] = getParams(identifiers);
+    const cos = frac(re, module).simplify();
+    const sin = frac(im, module).simplify();
+    const argCos = ang.cos.toTex();
+    const argSin = ang.sin.toTex();
+    const cosSimp = frac(re, module).toSimplificationTex();
+    const sinSimp = frac(im, module).toSimplificationTex();
+    return `On calcule le module de $z$ :
+  
+${alignTex([
+        ["|z|", "=", sqrt(add(square(re), square(im))).toTex()],
+        ["", "=", module.toTex()],
+    ])}
+
+Tout argument $\\theta$ de $z$ vérifie alors : 
+
+$$
+\\cos(\\theta) = ${cosSimp} ${argCos !== cos.toTex() ? `= ${argCos}` : ""}
+$$
+
+et 
+
+$$
+\\sin(\\theta) = ${sinSimp} ${argSin !== sin.toTex() ? `= ${argSin}` : ""}
+$$
+
+Un argument de $z$ est donc par exemple $${ang.angle.toTex()}$.
+
+La forme exponentielle de $z$ est donc : 
+
+$$
+z = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getKeys = () => {
+    return ["epower", "i", "pi"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const [module, angle] = getParams(identifiers);
+        const parsed = parseAlgebraic(ans);
+        const expForm = multiply(module, exp(multiply("i", angle.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 getComplexExpFromAlgebraicFormQuestion = () => {
+    const arg = random(mainTrigoValues.filter((a) => a.angle.evaluate({}) !== 0));
+    const factor = random([
+        randint(2, 6).toTree(),
+        RationalConstructor.randomIrreductible().toTree(),
+        random([sqrt(2), sqrt(3)]),
+    ]);
+    const re = multiply(factor, arg.cos).simplify();
+    const im = multiply(factor, arg.sin).simplify();
+    const identifiers = {
+        imIds: im.toIdentifiers(),
+        reIds: re.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 complexExpFromAlgebraicForm = {
+    id: "complexExpFromAlgebraicForm",
+    connector: "=",
+    label: "Donner la forme exponentielle d'un complexe écrit sous forme algébrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComplexExpFromAlgebraicFormQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,5 @@
+export * from "./complexAlgebraicFromExpForm.js";
+export * from "./complexExpFromAlgebraicForm.js";
+export * from "./complexExpFormProductSimplify.js";
+export * from "./complexExpFormQuotientSimplify.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/exp/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,oCAAoC,CAAC;AACnD,cAAc,qCAAqC,CAAC"}

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

@@ -0,0 +1,5 @@
+export * from "./complexAlgebraicFromExpForm.js";
+export * from "./complexExpFromAlgebraicForm.js";
+export * from "./complexExpFormProductSimplify.js";
+export * from "./complexExpFormQuotientSimplify.js";
+// export * from "./complexExpFormPowerSimplify.js";

package/lib/exercises/math/complex/index.d.ts

@@ -9,4 +9,5 @@ export * from "./moduloFromAlgebraicComplex.js";
 export * from "./mutiplyComplex.js";
 export * from "./reAndIm.js";
 export * from "./argumentFromAlgebraicComplex.js";
+export * from "./exp/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/complex/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAEhC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAEhC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,mCAAmC,CAAC;AAClD,cAAc,gBAAgB,CAAC"}

package/lib/exercises/math/complex/index.js

@@ -10,3 +10,4 @@ export * from "./moduloFromAlgebraicComplex.js";
 export * from "./mutiplyComplex.js";
 export * from "./reAndIm.js";
 export * from "./argumentFromAlgebraicComplex.js";
+export * from "./exp/index.js";

package/lib/exercises/math/complex/inverseComplex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inverseComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/inverseComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwDF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}
+{"version":3,"file":"inverseComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/inverseComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAoFF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/exercises/math/complex/inverseComplex.js

@@ -1,7 +1,13 @@
 import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Complex, ComplexConstructor } from "../../../math/complex/complex.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.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 { shuffle } from "../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const complex = new Complex(identifiers.re, identifiers.im);
     return `Déterminer l'inverse de $z=${complex.toTree().toTex()}$.`;
@@ -11,6 +17,29 @@ const getAnswer = (identifiers) => {
     const answer = complex.inverseNode().toTex();
     return answer;
 };
+const getHint = () => {
+    return `Pour calculer un quotient dans $\\mathbb{C}$, on multiplie le numérateur et le dénominateur par le conjugué du dénominateur.
+
+On rappelle que le conjugué d'un nombre complexe $z$ est le nombre complexe de même partie réelle et de partie imaginaire opposée.
+  `;
+};
+const getCorrection = (identifiers) => {
+    const { im, re } = identifiers;
+    const z = new Complex(re, im);
+    const zTree = z.toTree();
+    const conj = z.conjugate().toTree();
+    return `On cherche à calculer $\\frac{1}{${zTree.toTex()}}$. 
+  
+Pour cela, on multiplie le numérateur et le dénominateur de ce quotient par le conjugué du dénominateur : 
+    
+${alignTex([
+        ["", ` \\frac{1}{${zTree.toTex()}} `],
+        ["=", `\\frac{${conj.toTex()}}{(${zTree.toTex()})(${conj.toTex()})}`],
+        ["=", frac(conj, substract(re ** 2, square(multiply(im, "i")))).toTex()],
+        ["=", frac(conj, re ** 2 + im ** 2).toTex()],
+        ["=", getAnswer(identifiers)],
+    ])}`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -19,12 +48,15 @@ const getQuestionFromIdentifiers = (identifiers) => {
         answerFormat: "tex",
         identifiers,
         startStatement: "\\frac{1}{z}",
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
 const getInverseComplexQuestion = () => {
-    const complex = ComplexConstructor.randomNotReal();
-    const identifiers = { re: complex.re, im: complex.im };
+    const re = randint(-10, 11, [0]);
+    const im = randint(-10, 11, [0]);
+    const identifiers = { re, im };
     return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer, re, im }) => {
@@ -59,4 +91,5 @@ export const inverseComplex = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/complex/linearCombinaisonComplex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linearCombinaisonComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/linearCombinaisonComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;CACd,CAAC;AAmEF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"linearCombinaisonComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/linearCombinaisonComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;CACd,CAAC;AAmGF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}

package/lib/exercises/math/complex/linearCombinaisonComplex.js

@@ -2,16 +2,15 @@ import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercises/
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Complex, ComplexConstructor } from "../../../math/complex/complex.js";
 import { randint } from "../../../math/utils/random/randint.js";
-import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
-import { AddNode } from "../../../tree/nodes/operators/addNode.js";
-import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
-import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const { a, b, z1, z2 } = identifiers;
     const z1Complex = new Complex(z1[0], z1[1]);
     const z2Complex = new Complex(z2[0], z2[1]);
-    const statement = new AddNode(new MultiplyNode(new NumberNode(a), new VariableNode("z_1")), new MultiplyNode(new NumberNode(b), new VariableNode("z_2")));
+    const statement = add(multiply(a, "z_1"), multiply(b, "z_2"));
     return `Soit $z_1=${z1Complex.toTree().toTex()}$ et $z_2=${z2Complex
         .toTree()
         .toTex()}$. 
@@ -25,6 +24,35 @@ const getAnswer = (identifiers) => {
     const answer = z1Complex.times(a).add(z2Complex.times(b)).toTree().toTex();
     return answer;
 };
+const getHint = () => {
+    return `L'addition et la multiplication des nombres réels se prolongent aux nombres complexes : les règles de calcul sont les mêmes.
+  `;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, z1, z2 } = identifiers;
+    const z1Complex = new Complex(z1[0], z1[1]).toTree().toRawTree();
+    const z2Complex = new Complex(z2[0], z2[1]).toTree().toRawTree();
+    const z1Aff = multiply(a, z1Complex);
+    const z2Aff = multiply(b, z2Complex);
+    return `On applique les mêmes règles de calcul que pour les nombres réels : 
+    
+${alignTex([
+        ["", add(z1Aff, z2Aff).toTex()],
+        [
+            "=",
+            add(z1Aff.simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+                noAddOrder: true,
+            }), z2Aff.simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+                noAddOrder: true,
+            })).toTex(),
+        ],
+        ["=", getAnswer(identifiers)],
+    ])}`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -32,6 +60,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["i", "z", "quote"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -71,4 +101,5 @@ export const linearCombinaisonComplex = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/complex/moduloFromAlgebraicComplex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"moduloFromAlgebraicComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/moduloFromAlgebraicComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA2DF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}
+{"version":3,"file":"moduloFromAlgebraicComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/moduloFromAlgebraicComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAoFF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/math/complex/moduloFromAlgebraicComplex.js

@@ -1,10 +1,14 @@
 import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { sqrtVEA } from "../../../exercises/vea/sqrtVEA.js";
 import { Complex, ComplexConstructor } from "../../../math/complex/complex.js";
 import { SquareRoot } from "../../../math/numbers/reals/real.js";
 import { randint } from "../../../math/utils/random/randint.js";
-import { SqrtNode } from "../../../tree/nodes/functions/sqrtNode.js";
-import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
+import { sqrt } from "../../../tree/nodes/functions/sqrtNode.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { square } from "../../../tree/nodes/operators/powerNode.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const zTex = new Complex(identifiers.re, identifiers.im).toTree().toTex();
     return `Soit $z=${zTex}$. 
@@ -16,6 +20,28 @@ const getAnswer = (identifiers) => {
     const answer = z.toModuleTree().toTex();
     return answer;
 };
+const getHint = () => {
+    return `Si $z$ est un nombre complexe de forme algébrique 
+  
+$$
+z = x+iy
+$$
+
+avec $x$ et $y$ réels, alors le module de $z$ est le nombre : 
+
+$$
+|z| = \\sqrt{x^2 + y^2}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { im, re } = identifiers;
+    return `Le module $|z|$ de $z$ vaut : 
+  
+${alignTex([
+        ["|z|", "=", sqrt(add(square(re), square(im))).toTex()],
+        ["", "=", sqrt(re ** 2 + im ** 2).toSimplificationTex()],
+    ])}`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -23,6 +49,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -41,13 +69,13 @@ const getPropositions = (n, { answer, re, im }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { re, im }) => {
-    const z = new Complex(re, im);
-    const answer = new SqrtNode(new NumberNode(z.moduleSquared()), {
-        allowSimplifySqrt: true,
-    });
-    const texs = answer.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return sqrtVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const moduloFromAlgebraicComplex = {
     id: "moduloFromAlgebraicComplex",
@@ -61,4 +89,5 @@ export const moduloFromAlgebraicComplex = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/derivation/problems/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./problemMaximizeBoxVolumeFindX.js";
 export * from "./problemProjectileHeightFindAbscissa.js";
-export * from "./problemMaximizeProfitFindProduction.js";
 export * from "./problemMovementOnLineFindSpeedAtPoint.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/problems/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,4CAA4C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,0CAA0C,CAAC;AAEzD,cAAc,4CAA4C,CAAC"}

package/lib/exercises/math/derivation/problems/index.js

@@ -1,4 +1,4 @@
 export * from "./problemMaximizeBoxVolumeFindX.js";
 export * from "./problemProjectileHeightFindAbscissa.js";
-export * from "./problemMaximizeProfitFindProduction.js";
+// export * from "./problemMaximizeProfitFindProduction.js";
 export * from "./problemMovementOnLineFindSpeedAtPoint.js";

package/lib/exercises/math/trigonometry/formulas/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./trigoAdditionFormulaUsage.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/trigonometry/formulas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/formulas/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/trigonometry/formulas/index.js

@@ -0,0 +1 @@
+export * from "./trigoAdditionFormulaUsage.js";