math-exercises 3.0.214 → 3.0.216

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

@@ -0,0 +1,10 @@
+export * from "./addComplex.js";
+export * from "./conjugateComplex.js";
+export * from "./conjugateDivideComplex.js";
+export * from "./conjugateMultiplyComplex.js";
+export * from "./divideComplex.js";
+export * from "./inverseComplex.js";
+export * from "./linearCombinaisonComplex.js";
+export * from "./moduloFromAlgebraicComplex.js";
+export * from "./mutiplyComplex.js";
+export * from "./reAndIm.js";

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    re: number;
+    im: number;
+};
+export declare const inverseComplex: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=inverseComplex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inverseComplex.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/algebraic/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/algebraic/inverseComplex.js

@@ -0,0 +1,95 @@
+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()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const complex = new Complex(identifiers.re, identifiers.im);
+    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),
+        instruction: getInstruction(identifiers),
+        keys: ["i"],
+        answerFormat: "tex",
+        identifiers,
+        startStatement: "\\frac{1}{z}",
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getInverseComplexQuestion = () => {
+    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 }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const complex = new Complex(re, im);
+    const opposite = complex.opposite().toTree().toTex();
+    tryToAddWrongProp(propositions, opposite);
+    const conj = complex.conjugate().toTree().toTex();
+    tryToAddWrongProp(propositions, conj);
+    propWhile(propositions, n, () => {
+        const wrongAnswer = ComplexConstructor.random();
+        tryToAddWrongProp(propositions, wrongAnswer.toTree().toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { re, im }) => {
+    const z = new Complex(re, im);
+    const inv = z.inverseNode();
+    const texs = inv.toAllValidTexs({ allowFractionToDecimal: true });
+    return texs.includes(ans);
+};
+export const inverseComplex = {
+    id: "inverseComplex",
+    connector: "=",
+    label: "Inverse d'un nombre complexe",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getInverseComplexQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    z1: number[];
+    z2: number[];
+};
+export declare const linearCombinaisonComplex: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=linearCombinaisonComplex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"linearCombinaisonComplex.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/algebraic/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/algebraic/linearCombinaisonComplex.js

@@ -0,0 +1,105 @@
+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 { 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 = add(multiply(a, "z_1"), multiply(b, "z_2"));
+    return `Soit $z_1=${z1Complex.toTree().toTex()}$ et $z_2=${z2Complex
+        .toTree()
+        .toTex()}$. 
+      
+Calculer $${statement.toTex()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, z1, z2 } = identifiers;
+    const z1Complex = new Complex(z1[0], z1[1]);
+    const z2Complex = new Complex(z2[0], z2[1]);
+    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),
+        instruction: getInstruction(identifiers),
+        keys: ["i", "z", "quote"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getLinearCombinaisonComplexQuestion = () => {
+    const z1 = ComplexConstructor.random();
+    const z2 = ComplexConstructor.random();
+    const a = randint(-10, 11, [0]);
+    const b = randint(-10, 11, [0]);
+    const identifiers = { a, b, z1: [z1.re, z1.im], z2: [z2.re, z2.im] };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const wrongAnswer = ComplexConstructor.random();
+        tryToAddWrongProp(propositions, wrongAnswer.toTree().toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b, z1, z2 }) => {
+    const complex1 = new Complex(z1[0], z1[1]);
+    const complex2 = new Complex(z2[0], z2[1]);
+    const answerTree = complex1.times(a).add(complex2.times(b)).toTree();
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const linearCombinaisonComplex = {
+    id: "linearCombinaisonComplex",
+    connector: "=",
+    label: "Combinaison linéaire de deux nombres complexes",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getLinearCombinaisonComplexQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    re: number;
+    im: number;
+};
+export declare const moduloFromAlgebraicComplex: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=moduloFromAlgebraicComplex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moduloFromAlgebraicComplex.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/algebraic/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/algebraic/moduloFromAlgebraicComplex.js

@@ -0,0 +1,93 @@
+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 { 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}$. 
+  
+Déterminer le module $|z|$ de $z$.`;
+};
+const getAnswer = (identifiers) => {
+    const z = new Complex(identifiers.re, identifiers.im);
+    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),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getModuloFromAlgebraicComplexQuestion = () => {
+    const z = ComplexConstructor.random();
+    const identifiers = { re: z.re, im: z.im };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, re, im }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, new SquareRoot(re + im).simplify().toTree().toTex());
+    tryToAddWrongProp(propositions, re ** 2 + im ** 2 + "");
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, `\\sqrt{${randint(0, 100)}}`);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return sqrtVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const moduloFromAlgebraicComplex = {
+    id: "moduloFromAlgebraicComplex",
+    connector: "=",
+    label: "Déterminer le module d'un nombre complexe via sa forme algébrique",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getModuloFromAlgebraicComplexQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/complex/algebraic/mutiplyComplex.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    z1: number[];
+    z2: number[];
+};
+export declare const mutiplyComplex: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=mutiplyComplex.d.ts.map

package/lib/exercises/math/complex/algebraic/mutiplyComplex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutiplyComplex.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/algebraic/mutiplyComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;CACd,CAAC;AA2GF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/exercises/math/complex/algebraic/mutiplyComplex.js

@@ -0,0 +1,106 @@
+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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.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 $z\\times z'$.`;
+};
+const getAnswer = (identifiers) => {
+    const z1 = new Complex(identifiers.z1[0], identifiers.z1[1]);
+    const z2 = new Complex(identifiers.z2[0], identifiers.z2[1]);
+    const answer = z1.multiply(z2).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$.`;
+};
+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(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["i"],
+        answerFormat: "tex",
+        startStatement: "z\\times z'",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getMutiplyComplexQuestion = () => {
+    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 }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const prod = new Complex(z1[0], z1[1]).multiply(new Complex(z2[0], z2[1]));
+    tryToAddWrongProp(propositions, prod.conjugate().toTree().toTex());
+    propWhile(propositions, n, () => {
+        const wrongAnswer = ComplexConstructor.random();
+        tryToAddWrongProp(propositions, wrongAnswer.toTree().toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const parsed = parseAlgebraic(ans);
+    if (!parsed)
+        return false;
+    return (parsed
+        .simplify({
+        forbidFactorize: true,
+    })
+        .toTex() ===
+        parseAlgebraic(answer)
+            .simplify({
+            forbidFactorize: true,
+        })
+            .toTex());
+};
+export const mutiplyComplex = {
+    id: "mutiplyComplex",
+    connector: "=",
+    label: "Multiplier deux nombres complexes",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getMutiplyComplexQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/complex/algebraic/reAndIm.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    re: number;
+    im: number;
+    isRe: boolean;
+};
+export declare const reAndIm: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=reAndIm.d.ts.map

package/lib/exercises/math/complex/algebraic/reAndIm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reAndIm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/algebraic/reAndIm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AA2FF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAazC,CAAC"}

package/lib/exercises/math/complex/algebraic/reAndIm.js

@@ -0,0 +1,92 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { Complex, ComplexConstructor } from "../../../../math/complex/complex.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getInstruction = (identifiers) => {
+    const { re, im, isRe } = identifiers;
+    const z1 = new Complex(re, im);
+    return `Soit $z=${z1.toTree().toTex()}$. 
+  
+Quelle est la partie ${isRe ? "réelle" : "imaginaire"} de $z$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { re, im, isRe } = identifiers;
+    const z1 = new Complex(re, im);
+    const answer = (isRe ? z1.re : z1.im) + "";
+    return answer;
+};
+const getHint = () => {
+    return `Si $z$ est un nombre complexe tel que : 
+  
+$$
+z = a+ib
+$$
+
+alors $a$ est la partie réelle de $z$, et $b$ et sa partie imaginaire.`;
+};
+const getCorrection = (identifiers) => {
+    const { re, im } = identifiers;
+    const z1 = new Complex(re, im);
+    return `Si $z$ est un nombre complexe tel que : 
+  
+$$
+z = a+ib
+$$
+
+alors $a$ est la partie réelle de $z$, et $b$ et sa partie imaginaire.
+
+Ici, on a $z = ${z1
+        .toTree()
+        .toTex()}$, donc la partie réelle de $z$ est $${re}$ et sa partie imaginaire est $${im}$. `;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["i", "z"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getReAndImQuestion = () => {
+    const z1 = doWhile(() => ComplexConstructor.random(), (z) => z.re === z.im);
+    const isRe = coinFlip();
+    const identifiers = { re: z1.re, im: z1.im, isRe };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, re, im, isRe }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, im + "i");
+    tryToAddWrongProp(propositions, isRe ? im.toString() : re.toString());
+    tryToAddWrongProp(propositions, (-im).toString());
+    propWhile(propositions, n, () => {
+        const wrongAnswer = randint(-10, 11) + "";
+        tryToAddWrongProp(propositions, wrongAnswer);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+export const reAndIm = {
+    id: "getReAndImQuestion",
+    connector: "=",
+    getPropositions,
+    label: "Identifier partie réelle et partie imaginaire d'un nombre complexe",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getReAndImQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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