math-exercises 3.0.214 → 3.0.216

package/lib/exercises/math/complex/polynomials/solveSecondDegreeInComplex.js

@@ -0,0 +1,190 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { DiscreteSetNode, EmptySet, } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, new EquationSolutionNode(EmptySet).toTex());
+    propWhile(propositions, n, () => {
+        const z1Re = randint(-5, 6, [0]);
+        const z1Im = randint(-5, 6, [0]);
+        const complex = add(z1Re, multiply(z1Im, "i"));
+        const conj = add(z1Re, multiply(-z1Im, "i"));
+        if (answer.includes(complex.toTex()))
+            return;
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([complex, conj])).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getSolutions = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    const delta = substract(square(b), multiply(4, multiply(a, c))).simplify();
+    const squareRoot = sqrt(abs(delta)).simplify();
+    const firstSol = frac(add(opposite(b), multiply("i", squareRoot)), multiply(2, a)).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+        noAddOrder: true,
+    });
+    const secondSol = frac(substract(opposite(b), multiply("i", squareRoot)), multiply(2, a)).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+        noAddOrder: true,
+    });
+    return [firstSol, secondSol];
+};
+const getAnswer = (identifiers) => {
+    return new EquationSolutionNode(new DiscreteSetNode(getSolutions(identifiers))).toTex();
+};
+const getEquation = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    return add(multiply(a, "z^2"), add(multiply(b, "z"), c)).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre dans $\\mathbb{C}$ l'équation suivante : 
+  
+$$
+${getEquation(identifiers).toTex()} = 0
+$$
+
+On donnera la réponse sous la forme $S = \\{...\\}$.`;
+};
+const getHint = () => {
+    return `L'équation $az^2+bz+c=0$ admet toujours au moins une solution dans $\\mathbb{C}$.
+  
+On peut la résoudre comme dans $\\mathbb{R}$, à l'exception prêt du cas où le discriminant $\\Delta$ est négatif : dans ce cas, l'équation admet deux solutions complexes conjuguées :
+
+$$
+z_1 = \\frac{-b+i\\sqrt{-\\Delta}}{2a}
+$$
+
+et 
+
+$$
+z_1 = \\frac{-b-i\\sqrt{-\\Delta}}{2a}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, cIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const c = reifyAlgebraic(cIds);
+    const delta = substract(square(b), multiply(4, multiply(a, c)));
+    const squareRoot = sqrt(abs(delta)).simplify();
+    const firstSol = frac(add(opposite(b), multiply("i", squareRoot)), multiply(2, a));
+    const firstSolSimp = firstSol.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+        noAddOrder: true,
+    });
+    const secondSol = frac(substract(opposite(b), multiply("i", squareRoot)), multiply(2, a)).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+        noAddOrder: true,
+    });
+    return `On calcule le discriminant $\\Delta$ : 
+  
+$$
+\\Delta = ${delta.toSimplificationTex()}
+$$
+
+Puisque $\\Delta<0$, l'équation possède deux solutions complexes conjuguées. On calcule la première solution $z_1$ :
+
+${alignTex([
+        ["z_1", "=", "\\frac{-b+i\\sqrt{-\\Delta}}{2a}"],
+        ["", "=", firstSol.toTex()],
+        ["", "=", firstSolSimp.toTex()],
+    ])}
+
+
+On obtient alors la deuxième solution $z_2 = \\overline{z_1}$ : 
+
+$$
+z_2 = \\overline{${firstSolSimp.toTex()}} = ${secondSol.toTex()}
+$$`;
+};
+const getKeys = () => {
+    return ["S", "equal", "lbrace", "i", "semicolon", "rbrace", "varnothing"];
+};
+const isAnswerValid = (ans, { answer: _answer, aIds, bIds, cIds }) => {
+    try {
+        const setParsed = discreteSetParser(ans);
+        if (!setParsed || setParsed.elements.length > 2)
+            return false;
+        const sols = getSolutions({ aIds, bIds, cIds });
+        return sols.every((sol) => setParsed.elements.some((studentSol) => studentSol.simplify().toTex() === sol.simplify().toTex()));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSolveSecondDegreeInComplexQuestion = () => {
+    //on build a(z-z1)(z-z2) et on en déduit a,b,c
+    const a = randint(-5, 6, [0]);
+    const z1Re = randint(-5, 6, [0]);
+    const b = -2 * a * z1Re;
+    const z1Im = randint(-5, 6, [0]);
+    const moduleSquared = z1Re * z1Re + z1Im * z1Im;
+    const c = a * moduleSquared;
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        bIds: b.toTree().toIdentifiers(),
+        cIds: c.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 solveSecondDegreeInComplex = {
+    id: "solveSecondDegreeInComplex",
+    connector: "\\iff",
+    label: "Résoudre une équation du second degré dans $\\mathbb{C}$ pour un discriminant négatif",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSolveSecondDegreeInComplexQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/complex/polynomials/solveZSquareEqualsA.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+};
+type Options = {
+    allowPositiveA: boolean;
+};
+export declare const solveZSquareEqualsA: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=solveZSquareEqualsA.d.ts.map

package/lib/exercises/math/complex/polynomials/solveZSquareEqualsA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solveZSquareEqualsA.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/polynomials/solveZSquareEqualsA.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA6JF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoB9D,CAAC"}

package/lib/exercises/math/complex/polynomials/solveZSquareEqualsA.js

@@ -0,0 +1,158 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { DiscreteSetNode, EmptySet, } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, aIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const a = reifyAlgebraic(aIds);
+    tryToAddWrongProp(propositions, new EquationSolutionNode(EmptySet).toTex());
+    if (a.evaluate() < 0) {
+        const sols = [opposite(sqrt(a)), sqrt(a)];
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode(sols)).toTex());
+    }
+    propWhile(propositions, n, () => {
+        const a = randint(-10, 10);
+        tryToAddWrongProp(propositions, getAnswer({ aIds: a.toTree().toIdentifiers() }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getSolutions = (identifiers) => {
+    const { aIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const sols = [];
+    if (a.evaluate() === 0)
+        sols.push((0).toTree());
+    if (a.evaluate() > 0)
+        sols.push(opposite(sqrt(a).simplify()), sqrt(a).simplify());
+    else
+        sols.push(multiply(opposite(sqrt(abs(a)).simplify()), "i"), multiply(sqrt(abs(a)).simplify(), "i"));
+    return sols;
+};
+const getAnswer = (identifiers) => {
+    return new EquationSolutionNode(new DiscreteSetNode(getSolutions(identifiers))).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    return `Résoudre dans $\\mathbb{C}$ l'équation : 
+  
+$$
+z^2 = ${a.toTex()}
+$$
+
+Donner les solutions sous la forme $S = \\{...\\}$.`;
+};
+const getHint = () => {
+    return `L'équation $z^2 = a$ admet toujours des solutions dans $\\mathbb{C}$ : 
+  
+- Si $a=0$, alors $z=0$.
+- Si $a>0$, alors les solutions sont réelles.
+- Si $a<0$, alors les solutions sont imaginaires purs.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    if (a.evaluate() === 0) {
+        return `Puisque $${a.toTex()} = 0$, l'équation $z^2 = ${a.toTex()}$ admet une seule solution : 
+
+$$
+z = 0
+$$`;
+    }
+    if (a.evaluate() > 0) {
+        return `Puisque $${a.toTex()} > 0$, l'équation $z^2 = ${a.toTex()}$ admet deux solutions réelles :
+    
+$$
+${getAnswer(identifiers)}
+$$`;
+    }
+    return `Puisque $${a.toTex()} < 0$, l'équation $z^2 = ${a.toTex()}$ admet deux solutions imaginaires pures :
+    
+$$
+z_1 = ${multiply(opposite(sqrt(abs(a))), "i").toTex()}
+$$
+
+et 
+
+$$
+z_2 = ${multiply(sqrt(abs(a)), "i").toTex()}.
+$$
+
+D'où :
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return ["S", "equal", "lbrace", "i", "semicolon", "rbrace", "varnothing"];
+};
+const isAnswerValid = (ans, { answer: _answer, aIds }) => {
+    try {
+        const setParsed = discreteSetParser(ans);
+        if (!setParsed || setParsed.elements.length > 2)
+            return false;
+        const sols = getSolutions({ aIds });
+        return sols.every((sol) => setParsed.elements.some((studentSol) => studentSol.simplify().toTex() === sol.simplify().toTex()));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSolveZSquareEqualsAQuestion = (opts) => {
+    const allowPositiveA = !!opts?.allowPositiveA;
+    const a = allowPositiveA ? randint(-10, 10) : randint(-20, -1);
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const options = [
+    {
+        id: "allowPositiveA",
+        label: "Utiliser également des valeurs positives pour $a$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
+export const solveZSquareEqualsA = {
+    id: "solveZSquareEqualsA",
+    connector: "\\iff",
+    label: "Résoudre dans $\\mathbb{C}$ l'équation $z^2 = a$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSolveZSquareEqualsAQuestion(opts), nb, 15),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    maxAllowedQuestions: 15,
+    options,
+};

package/lib/exercises/math/complex/unitRoots/giveNUnitRoot.d.ts

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

package/lib/exercises/math/complex/unitRoots/giveNUnitRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"giveNUnitRoot.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/unitRoots/giveNUnitRoot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA6GF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAmB/C,CAAC"}

package/lib/exercises/math/complex/unitRoots/giveNUnitRoot.js

@@ -0,0 +1,122 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { isExpNode } from "../../../../tree/nodes/functions/expNode.js";
+import { logn } from "../../../../tree/nodes/functions/logNode.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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, n: nIdentifier }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `e^{i\\frac{\\pi}{${n}}}`);
+    propWhile(propositions, n, () => {
+        const int = randint(3, 10);
+        const k = randint(1, int);
+        const quot = frac(multiply(2 * k, PiNode), int).simplify();
+        const isRoot = frac(nIdentifier * k * 2, int).evaluate() % 2 === 0;
+        if (isRoot)
+            return;
+        tryToAddWrongProp(propositions, `e^{i${quot.toTex()}}`);
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { n } = identifiers;
+    const simp = frac(multiply(2, PiNode), n).simplify();
+    return `e^{i${simp.toTex()}}`;
+};
+const getInstruction = (identifiers) => {
+    const { n } = identifiers;
+    return `Donner une racine $${n}$-ième de l'unité, différente de $-1$ et de $1$.`;
+};
+const getHint = () => {
+    return `Une racine $n$-ième de l'unité est un nombre complexe $z$ tel que :
+  
+$$
+z^n = 1
+$$
+
+Pour tout entier $n>0$, il existe exactement $n$ racines $n$-ième de l'unité.`;
+};
+const getCorrection = (identifiers) => {
+    const { n } = identifiers;
+    const simp = n / 2;
+    const isSimp = n % 2 === 0;
+    return `Pour tout entier $n>0$, il existe exactement $n$ racines $n$-ième de l'unité : ce sont les nombres de la forme
+  
+$$
+e^{i\\frac{2k\\pi}{n}}
+$$
+
+où $k$ est un entier naturel tel que $0\\leq k\\leq n-1$.
+
+Ici, ce sont donc les nombres de la forme 
+
+$$
+e^{i\\frac{2k\\pi}{${n}}} ${isSimp ? `= e^{i\\frac{k\\pi}{${simp}}}` : ""}
+$$
+
+Pour $k=1$, une telle racine est donc :
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
+const getKeys = () => {
+    return ["epower", "i", "pi"];
+};
+const isAnswerValid = (ans, { answer: _answer, n }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return (isExpNode(parsed) &&
+            frac(multiply(frac(logn(parsed), "i"), n), PiNode)
+                .simplify()
+                .evaluate() %
+                2 ===
+                0);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGiveNUnitRootQuestion = () => {
+    const n = randint(3, 20);
+    const identifiers = {
+        n,
+    };
+    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 giveNUnitRoot = {
+    id: "giveNUnitRoot",
+    connector: "=",
+    label: "Donner une racine $n$-ième complexe de l'unité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGiveNUnitRootQuestion(opts), nb, 15),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    maxAllowedQuestions: 15,
+};

package/lib/exercises/math/complex/unitRoots/giveOneSolutionToComplexPowNEqualsOne.d.ts

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

package/lib/exercises/math/complex/unitRoots/giveOneSolutionToComplexPowNEqualsOne.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"giveOneSolutionToComplexPowNEqualsOne.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/unitRoots/giveOneSolutionToComplexPowNEqualsOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AAgIF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAqBvE,CAAC"}

package/lib/exercises/math/complex/unitRoots/giveOneSolutionToComplexPowNEqualsOne.js

@@ -0,0 +1,138 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { isExpNode } from "../../../../tree/nodes/functions/expNode.js";
+import { logn } from "../../../../tree/nodes/functions/logNode.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 { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, a, n: nIdentifier }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `e^{i${frac(multiply(2, PiNode), n).simplify().toTex()}}`);
+    propWhile(propositions, n, () => {
+        const int = randint(3, 10);
+        const k = randint(1, int);
+        const quot = frac(multiply(2 * k, PiNode), int).simplify();
+        const isRoot = frac(nIdentifier * k * 2, int).evaluate() % 2 === 0;
+        if (isRoot)
+            return;
+        tryToAddWrongProp(propositions, add(a, `e^{i${quot.toTex()}}`).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, n } = identifiers;
+    const root = `e^{i${frac(multiply(2, PiNode), n).simplify().toTex()}}`;
+    return add(a, root).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a, n } = identifiers;
+    return `Donner une solution non-réelle de l'équation suivante : 
+  
+$$
+${power(substract("z", a).simplify(), n).toTex()} = 1
+$$`;
+};
+const getHint = (identifiers) => {
+    const { a, n } = identifiers;
+    const equa = `${power(substract("z", a).simplify(), n).toTex()} = 1`;
+    return `$z$ est une solution de l'équation 
+  
+$$
+${equa}
+$$
+
+si et seulement si $${substract("z", a)
+        .simplify()
+        .toTex()}$ est une racine $${n}$-ième de l'unité.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, n } = identifiers;
+    const root = `e^{i${frac(multiply(2, PiNode), n).simplify().toTex()}}`;
+    const equa = `${power(substract("z", a).simplify(), n).toTex()} = 1`;
+    return `$z$ est une solution de l'équation 
+  
+$$
+${equa}
+$$
+
+si et seulement si $${substract("z", a)
+        .simplify()
+        .toTex()}$ est une racine $${n}$-ième de l'unité.
+  
+Les racines $${n}$-ièmes de l'unité sont les nombres de la forme $e^{i\\frac{2k\\pi}{${n}}}$, où $k$ est un entier naturel tel que $0\\leq k\\leq ${n}-1$.
+
+Pour $k=1$, une telle racine est : 
+
+$$
+${root}
+$$
+
+Une solution non-réelle de l'équation est donc : 
+
+${alignTex([
+        [substract("z", a).simplify().toTex(), "=", root],
+        ["z", "=", add(a, root).toTex()],
+    ])}
+`;
+};
+const getKeys = () => {
+    return ["epower", "i", "pi"];
+};
+const isAnswerValid = (ans, { answer: _answer, a, n }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        const rawExp = substract(parsed, a).simplify();
+        return (isExpNode(rawExp) &&
+            frac(multiply(frac(logn(rawExp), "i"), n), PiNode)
+                .simplify()
+                .evaluate() %
+                2 ===
+                0);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGiveOneSolutionToComplexPowNEqualsOneQuestion = () => {
+    const n = randint(3, 20);
+    const a = randint(-10, 10, [0]);
+    const identifiers = { a, n };
+    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 giveOneSolutionToComplexPowNEqualsOne = {
+    id: "giveOneSolutionToComplexPowNEqualsOne",
+    connector: "=",
+    label: "Donner une solution de l'équation complexe $(z-a)^n = 1$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGiveOneSolutionToComplexPowNEqualsOneQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/unitRoots/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4CAA4C,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from "./giveNUnitRoot.js";
+export * from "./giveOneSolutionToComplexPowNEqualsOne.js";

package/lib/exercises/math/conversion/clock/clockReading.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+/************/
+type Identifiers = {
+    hours: number;
+    minutes: number;
+};
+type Options = {
+    amPmType: string;
+};
+export declare const clockReading: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=clockReading.d.ts.map

package/lib/exercises/math/conversion/clock/clockReading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clockReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/conversion/clock/clockReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AA4ErC,cAAc;AAEd,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAyWF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAsBF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBvD,CAAC"}