math-exercises 3.0.214 → 3.0.216

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

@@ -0,0 +1,125 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Complex, ComplexConstructor } from "../../../../math/complex/complex.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.z1Re, identifiers.z1Im);
+    const z2 = new Complex(identifiers.z2Re, identifiers.z2Im);
+    return `Soit $z=${z1.toTree().toTex()}$ et $z'=${z2.toTree().toTex()}$.
+      
+Calculer $z + z'$.`;
+};
+const getAnswer = (identifiers) => {
+    const z1 = new Complex(identifiers.z1Re, identifiers.z1Im);
+    const z2 = new Complex(identifiers.z2Re, identifiers.z2Im);
+    const answer = z1.add(z2).toTree().toTex();
+    return answer;
+};
+const getHint = () => {
+    return `Soient deux nombres complexes $z = a+ib$ et $z' = a'+ib'$. Alors :
+  
+$$
+z+z' = (a+a') + i(b+b')
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { z1Re, z1Im, z2Re, z2Im } = identifiers;
+    const z1 = add(z1Re, multiply(z1Im, "i")).simplify({
+        forbidFactorize: true,
+        noAddOrder: true,
+    });
+    const z2 = add(z2Re, multiply(z2Im, "i")).simplify({
+        forbidFactorize: true,
+        noAddOrder: true,
+    });
+    return `Soient deux nombres complexes $z = a+ib$ et $z' = a'+ib'$. Alors :
+  
+$$
+z+z' = (a+a') + i(b+b')
+$$
+
+Ici, on a donc :
+  
+${alignTex([
+        ["z+ z'", "=", add(z1, z2).toTex()],
+        ["", "=", add(add(z1Re, z2Re), multiply("i", add(z1Im, z2Im))).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["i"],
+        answerFormat: "tex",
+        startStatement: "z+z'",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getAddComplexQuestion = () => {
+    const z1 = ComplexConstructor.random();
+    let z2;
+    let counter = 0;
+    do {
+        counter++;
+        if (counter > 1000) {
+            throw new Error("add complex too many iterations");
+        }
+        z2 = ComplexConstructor.random();
+    } while (z1.im === 0 && z2.im === 0);
+    const identifiers = {
+        z1Re: z1.re,
+        z1Im: z1.im,
+        z2Re: z2.re,
+        z2Im: z2.im,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, z1Re, z1Im, z2Re, z2Im }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const z1 = new Complex(z1Re, z1Im);
+    const z2 = new Complex(z2Re, z2Im);
+    tryToAddWrongProp(propositions, z1.add(z2.opposite()).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 addComplex = {
+    id: "addComplex",
+    connector: "=",
+    label: "Additionner deux nombres complexes",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getAddComplexQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"conjugateComplex.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/algebraic/conjugateComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAqGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

package/lib/exercises/math/complex/algebraic/conjugateComplex.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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { re, im } = identifiers;
+    const complex = new Complex(re, im);
+    return `Déterminer le conjugué $\\overline{z}$ de :
+  
+$$
+z=${complex.toTree().toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { re, im } = identifiers;
+    const complex = new Complex(re, im);
+    const answer = complex.conjugate().toTree().toTex();
+    return answer;
+};
+const getHint = () => {
+    return `Soit $z = a+ib$ un nombre complexe.
+  
+Le conjugué $\\overline{z}$ de $z$ est le nombre : 
+
+$$
+\\overline{z} = a-ib
+$$`;
+};
+const getCorrection = (identifiers) => {
+    return `Soit $z = a+ib$ un nombre complexe.
+  
+Le conjugué $\\overline{z}$ de $z$ est le nombre : 
+
+$$
+\\overline{z} = a-ib
+$$
+
+Ici, on a donc : 
+
+$$
+\\overline{z} = ${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["i"],
+        answerFormat: "tex",
+        startStatement: "\\overline z",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getConjugateComplexQuestion = () => {
+    const complex = ComplexConstructor.random();
+    const identifiers = { re: complex.re, im: complex.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 conjOpposite = complex.conjugate().opposite().toTree().toTex();
+    tryToAddWrongProp(propositions, conjOpposite);
+    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 conjugateComplex = {
+    id: "conjugateComplex",
+    connector: "=",
+    getPropositions,
+    label: "Conjugué d'un nombre complexe",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getConjugateComplexQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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

@@ -0,0 +1,137 @@
+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]);
+    return `Soit $z=${z1.toTree().toTex()}$ et $z'=${z2.toTree().toTex()}$. 
+
+Calculer le conjugué de $\\frac{z}{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 conjz1 = z1.conjugate();
+    const conjz2 = z2.conjugate();
+    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"],
+        answerFormat: "tex",
+        startStatement: "\\overline{\\frac{z}{z'}}",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getConjugateDivideComplexQuestion = () => {
+    let z1;
+    let z2;
+    let counter = 0;
+    do {
+        counter++;
+        if (counter > 1000) {
+            throw new Error("conjugate divide complex too many iterations");
+        }
+        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,
+        z2,
+    };
+    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, { z1, z2 }) => {
+    const complex1 = new Complex(z1[0], z1[1]).conjugate();
+    const complex2 = new Complex(z2[0], z2[1]).conjugate();
+    const divide = complex1.divideNode(complex2);
+    const texs = divide.toAllValidTexs({ allowFractionToDecimal: true });
+    return texs.includes(ans);
+};
+export const conjugateDivideComplex = {
+    id: "conjugateDivideComplex",
+    connector: "=",
+    label: "Conjugué d'une fraction de nombres complexes",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getConjugateDivideComplexQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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

@@ -0,0 +1,116 @@
+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'}$.`;
+};
+const getAnswer = (identifiers) => {
+    const z1 = new Complex(identifiers.z1[0], identifiers.z1[1]);
+    const z2 = new Complex(identifiers.z2[0], identifiers.z2[1]);
+    const prod = z1.multiply(z2);
+    const conj = prod.conjugate();
+    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"],
+        answerFormat: "tex",
+        startStatement: "\\overline{z\\times z'}",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getConjugateMultiplyComplexQuestion = () => {
+    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 complex1 = new Complex(z1[0], z1[1]);
+    const complex2 = new Complex(z2[0], z2[1]);
+    const prod = complex1.multiply(complex2);
+    tryToAddWrongProp(propositions, prod.toTree().toTex());
+    propWhile(propositions, n, () => {
+        const wrongAnswer = ComplexConstructor.random();
+        tryToAddWrongProp(propositions, wrongAnswer.toTree().toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { z1, z2 }) => {
+    const complex1 = new Complex(z1[0], z1[1]);
+    const complex2 = new Complex(z2[0], z2[1]);
+    const answer = complex1.multiply(complex2).conjugate().toTree();
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const conjugateMultiplyComplex = {
+    id: "conjugateMultiplyComplex",
+    connector: "=",
+    label: "Conjugué d'un produit de nombres complexes",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getConjugateMultiplyComplexQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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

@@ -0,0 +1,128 @@
+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]);
+    return `Soit $z=${z1.toTree().toTex()}$ et $z'=${z2.toTree().toTex()}$. 
+      
+Calculer $\\frac{z}{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 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"],
+        answerFormat: "tex",
+        startStatement: "\\frac{z}{z'}",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getDivideComplexQuestion = () => {
+    let z1;
+    let z2;
+    let counter = 0;
+    do {
+        counter++;
+        if (counter > 1000) {
+            throw new Error("divide complex too many iterations");
+        }
+        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,
+        z2,
+    };
+    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, { z1, z2 }) => {
+    const complex1 = new Complex(z1[0], z1[1]);
+    const complex2 = new Complex(z2[0], z2[1]);
+    const divide = complex1.divideNode(complex2);
+    const texs = divide.toAllValidTexs({ allowFractionToDecimal: true });
+    return texs.includes(ans);
+};
+export const divideComplex = {
+    id: "divideComplex",
+    connector: "=",
+    label: "Diviser deux nombres complexes",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getDivideComplexQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,11 @@
+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";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/algebraic/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,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"}