math-exercises 3.0.211 → 3.0.213

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

@@ -5,13 +5,22 @@ 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 { SqrtNode } from "../../../tree/nodes/functions/sqrtNode.js";
+import { sqrt, SqrtNode } from "../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../tree/nodes/nodeConstructor.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../tree/nodes/operators/powerNode.js";
 import { random } from "../../../utils/alea/random.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const zTex = identifiers.zTex;
-    return `Soit $z=${zTex}$. 
+    return `Soit le nombre complexe : 
+  
+$$
+z=${zTex}
+$$ 
   
 Déterminer l'argument principal de $z$.`;
 };
@@ -20,6 +29,78 @@ const getAnswer = (identifiers) => {
     const answer = arg.angle.toTex();
     return answer;
 };
+const getHint = () => {
+    return `Soit $z$ un nombre complexe non nul.
+  
+- Si la partie réelle de $z$ est nulle, alors tout argument de $z$ est congru à $0$ modulo $\\pi$.
+- Si la partie imaginaire de $z$ est nulle, alors tout argument de $z$ est congru à $\\frac{\\pi}{2}$ modulo $\\pi$.
+- Dans les autres cas, on peut déterminer un argument $\\theta$ de $z$ en calculant $|z|$, puis en résolvant le système : 
+
+$$
+ \\left\\{\\begin{matrix}
+\\cos(\\theta) = \\frac{x}{|z|} \\\\
+\\sin(\\theta) = \\frac{y}{|z|}
+\\end{matrix}\\right.
+$$
+`;
+};
+const getCorrection = (identifiers) => {
+    const { reIds, imIds } = identifiers;
+    const re = reifyAlgebraic(reIds);
+    const im = reifyAlgebraic(imIds);
+    const answer = getAnswer(identifiers);
+    const module = sqrt(add(square(re), square(im))).simplify();
+    const arg = mainTrigoValues.find((point) => point.angle.evaluate({}) === identifiers.arg);
+    const argCos = arg.cos.toTex();
+    const argSin = arg.sin.toTex();
+    const cosinus = frac(re, module).simplify();
+    const sinus = frac(im, module).simplify();
+    const cosSimp = frac(re, module).toSimplificationTex();
+    const sinSimp = frac(im, module).toSimplificationTex();
+    if (re.evaluate() === 0) {
+        const sign = im.evaluate() > 0 ? "positive" : "négative";
+        return `$z$ est un imaginaire pur dont la partie imaginaire est strictement ${sign}, donc l'argument principal de $z$ est : 
+    
+$$
+${answer}
+$$`;
+    }
+    else if (im.evaluate() === 0) {
+        const sign = re.evaluate() > 0 ? "positive" : "négative";
+        return `$z$ est un réel strictement ${sign}, donc l'argument principal de $z$ est : 
+    
+$$
+${answer}
+$$`;
+    }
+    else {
+        return `On commence par calculer le module de $z$ : 
+    
+${alignTex([
+            ["|z|", "=", sqrt(add(square(re), square(im))).toTex()],
+            ["", "=", sqrt(add(square(re), square(im)).simplify()).toTex()],
+            ["", "=", module.toTex()],
+        ])}
+
+Tout argument $\\theta$ de $z$ vérifie alors : 
+
+$$
+\\cos(\\theta) = ${cosSimp} ${argCos !== cosinus.toTex() ? `= ${argCos}` : ""}
+$$
+
+et 
+
+$$
+\\sin(\\theta) = ${sinSimp} ${argSin !== sinus.toTex() ? `= ${argSin}` : ""}
+$$
+
+On en déduit que l'argument principal de $z$ est : 
+
+$$
+${answer}
+$$`;
+    }
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -27,6 +108,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["pi"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -41,7 +124,12 @@ const getArgumentFromAlgebraicComplexQuestion = () => {
     const im = new MultiplyNode(factor, arg.sin).simplify();
     const z = new ComplexNode(re, im);
     const zTex = z.toTex();
-    const identifiers = { arg: arg.angle.evaluate({}), zTex };
+    const identifiers = {
+        arg: arg.angle.evaluate({}),
+        zTex,
+        reIds: re.toIdentifiers(),
+        imIds: im.toIdentifiers(),
+    };
     return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer }) => {
@@ -70,4 +158,5 @@ export const argumentFromAlgebraicComplex = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"conjugateDivideComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/conjugateDivideComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;CACd,CAAC;AA6EF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}
+{"version":3,"file":"conjugateDivideComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/conjugateDivideComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;CACd,CAAC;AAyIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

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

@@ -1,7 +1,10 @@
 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 { shuffle } from "../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const z1 = new Complex(identifiers.z1[0], identifiers.z1[1]);
     const z2 = new Complex(identifiers.z2[0], identifiers.z2[1]);
@@ -17,19 +20,75 @@ const getAnswer = (identifiers) => {
     const answerTex = conjz1.divideNode(conjz2).toTex();
     return answerTex;
 };
+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 z1 = new Complex(identifiers.z1[0], identifiers.z1[1]);
+    const z2 = new Complex(identifiers.z2[0], identifiers.z2[1]);
+    const z1Tree = z1.toTree();
+    const z2Tree = z2.toTree();
+    const conj = z2.conjugate().toTree();
+    const num = z1.multiply(z2.conjugate()).toTree();
+    const denum = z2.multiply(z2.conjugate()).toTree();
+    //   const zTree = z.toTree();
+    //   const conj = z.conjugate().toTree();
+    return `On a 
+
+$$
+z = ${z1Tree.toTex()}
+$$
+
+$$
+z' = ${z2Tree.toTex()}
+$$
+
+et on veut calculer le conjugué de $\\frac{z}{z'}$.
+
+On commence par calculer $\\frac{z}{z'}$. Pour cela, on multiplie le numérateur et le dénominateur par le conjugué de $z'$, c'est à dire par :
+
+$$
+${conj.toTex()}
+$$
+
+Cela donne : 
+
+
+${alignTex([
+        ["", ` \\frac{${z1Tree.toTex()}}{${z2Tree.toTex()}} `],
+        [
+            "=",
+            `\\frac{(${z1Tree.toTex()})(${conj.toTex()})}{(${z2Tree.toTex()})(${conj.toTex()})}`,
+        ],
+        ["=", frac(num, denum).toTex()],
+        ["=", z1.divideNode(z2).toTex()],
+    ])}
+  
+Il suffit maintenant de prendre le conjugué de ce résultat : on obtient
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: ["i", "z", "overline", "quote"],
+        keys: ["i"],
         answerFormat: "tex",
         startStatement: "\\overline{\\frac{z}{z'}}",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
 const getConjugateDivideComplexQuestion = () => {
-    const z1 = ComplexConstructor.random();
+    let z1;
     let z2;
     let counter = 0;
     do {
@@ -37,11 +96,12 @@ const getConjugateDivideComplexQuestion = () => {
         if (counter > 1000) {
             throw new Error("conjugate divide complex too many iterations");
         }
-        z2 = ComplexConstructor.random();
-    } while (z1.im === 0 && z2.im === 0);
+        z1 = [randint(-10, 11, [0]), randint(-10, 11, [0])];
+        z2 = [randint(-10, 11, [0]), randint(-10, 11, [0])];
+    } while (z1[0] / z2[0] === z1[1] / z2[1]);
     const identifiers = {
-        z1: [z1.re, z1.im],
-        z2: [z2.re, z2.im],
+        z1,
+        z2,
     };
     return getQuestionFromIdentifiers(identifiers);
 };
@@ -73,4 +133,5 @@ export const conjugateDivideComplex = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

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

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

@@ -1,13 +1,17 @@
 import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Complex, ComplexConstructor } from "../../../math/complex/complex.js";
+import { randTupleInt } from "../../../math/utils/random/randTupleInt.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 z1 = new Complex(identifiers.z1[0], identifiers.z1[1]);
     const z2 = new Complex(identifiers.z2[0], identifiers.z2[1]);
-    return `Soit $z=${z1.toTree().toTex()}$ et $z'=${z2
-        .toTree()
-        .toTex()}$. Calculer $\\overline{z\\times z'}$.`;
+    return `Soit $z=${z1.toTree().toTex()}$ et $z'=${z2.toTree().toTex()}$. 
+    
+Calculer $\\overline{z\\times z'}$.`;
 };
 const getAnswer = (identifiers) => {
     const z1 = new Complex(identifiers.z1[0], identifiers.z1[1]);
@@ -17,29 +21,63 @@ const getAnswer = (identifiers) => {
     const answer = conj.toTree().toTex();
     return answer;
 };
+const getHint = () => {
+    return `Pour multiplier deux nombres complexes, on utilise la distributivité double, ainsi que le fait que $i^2 = -1$.
+  
+On rappelle que le conjugué $\\overline{z}$ 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 { z1, z2 } = identifiers;
+    const [a, b] = z1;
+    const [c, d] = z2;
+    const zA = add(a, multiply(b, "i"));
+    const zB = add(c, multiply(d, "i"));
+    return `On distribue comme pour des nombres réels, puis on utilise le fait que $i^2=-1$ :
+  
+${alignTex([
+        ["z\\times z'", "=", multiply(zA, zB).toTex()],
+        [
+            "",
+            "=",
+            add(add(multiply(a, c), multiply(a, multiply(d, "i"))), add(multiply(multiply(b, "i"), c), multiply(multiply(b, "i"), multiply(d, "i")))).toTex(),
+        ],
+        [
+            "",
+            "=",
+            add(add(multiply(a, c).simplify(), multiply(a * d + b * c, "i")), multiply(multiply(b, d).simplify(), -1)).toTex(),
+        ],
+        [
+            "",
+            "=",
+            add(add(multiply(a, c), multiply(a * d + b * c, "i")), multiply(multiply(b, d), -1))
+                .simplify({ noAddOrder: true })
+                .toTex(),
+        ],
+    ])}
+
+Il suffit alors de prendre le conjugué de ce résultat, on obtient : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: ["i", "z", "overline", "quote"],
+        keys: ["i"],
         answerFormat: "tex",
         startStatement: "\\overline{z\\times z'}",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
 const getConjugateMultiplyComplexQuestion = () => {
-    const z1 = ComplexConstructor.random();
-    let z2;
-    let counter = 0;
-    do {
-        counter++;
-        if (counter > 1000) {
-            throw new Error("conjugate multiply complex too many iterations");
-        }
-        z2 = ComplexConstructor.random();
-    } while (z1.im === 0 && z2.im === 0);
-    const identifiers = { z1: [z1.re, z1.im], z2: [z2.re, z2.im] };
+    const [a, b, c, d] = randTupleInt(4, { from: -9, to: 10, elExcludes: [0] });
+    const identifiers = { z1: [a, b], z2: [c, d] };
     return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer, z1, z2 }) => {
@@ -74,4 +112,5 @@ export const conjugateMultiplyComplex = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"divideComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/divideComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;CACd,CAAC;AAoEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAY/C,CAAC"}
+{"version":3,"file":"divideComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/divideComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;CACd,CAAC;AAyHF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAa/C,CAAC"}

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

@@ -1,7 +1,10 @@
 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 { shuffle } from "../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const z1 = new Complex(identifiers.z1[0], identifiers.z1[1]);
     const z2 = new Complex(identifiers.z2[0], identifiers.z2[1]);
@@ -15,19 +18,68 @@ const getAnswer = (identifiers) => {
     const answerTex = z1.divideNode(z2).toTex();
     return answerTex;
 };
+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 z1 = new Complex(identifiers.z1[0], identifiers.z1[1]);
+    const z2 = new Complex(identifiers.z2[0], identifiers.z2[1]);
+    const z1Tree = z1.toTree();
+    const z2Tree = z2.toTree();
+    const conj = z2.conjugate().toTree();
+    const num = z1.multiply(z2.conjugate()).toTree();
+    const denum = z2.multiply(z2.conjugate()).toTree();
+    //   const zTree = z.toTree();
+    //   const conj = z.conjugate().toTree();
+    return `On a 
+
+$$
+z = ${z1Tree.toTex()}
+$$
+
+$$
+z' = ${z2Tree.toTex()}
+$$
+
+et on veut calculer $\\frac{z}{z'}$.
+
+Pour cela, on multiplie le numérateur et le dénominateur par le conjugué de $z'$, c'est à dire par :
+
+$$
+${conj.toTex()}
+$$
+
+Cela donne : 
+
+
+  ${alignTex([
+        ["", ` \\frac{${z1Tree.toTex()}}{${z2Tree.toTex()}} `],
+        [
+            "=",
+            `\\frac{(${z1Tree.toTex()})(${conj.toTex()})}{(${z2Tree.toTex()})(${conj.toTex()})}`,
+        ],
+        ["=", frac(num, denum).toTex()],
+        ["=", getAnswer(identifiers)],
+    ])}`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: ["i", "z", "quote"],
+        keys: ["i"],
         answerFormat: "tex",
         startStatement: "\\frac{z}{z'}",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
 const getDivideComplexQuestion = () => {
-    const z1 = ComplexConstructor.random();
+    let z1;
     let z2;
     let counter = 0;
     do {
@@ -35,11 +87,12 @@ const getDivideComplexQuestion = () => {
         if (counter > 1000) {
             throw new Error("divide complex too many iterations");
         }
-        z2 = ComplexConstructor.random();
-    } while (z1.im === 0 && z2.im === 0);
+        z1 = [randint(-10, 11, [0]), randint(-10, 11, [0])];
+        z2 = [randint(-10, 11, [0]), randint(-10, 11, [0])];
+    } while (z1[0] / z2[0] === z1[1] / z2[1]);
     const identifiers = {
-        z1: [z1.re, z1.im],
-        z2: [z2.re, z2.im],
+        z1,
+        z2,
     };
     return getQuestionFromIdentifiers(identifiers);
 };
@@ -71,4 +124,5 @@ export const divideComplex = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"complexAlgebraicFromExpForm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/exp/complexAlgebraicFromExpForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAiLF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAsB7D,CAAC"}

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"}