math-exercises 3.0.93 → 3.0.95

package/lib/exercises/math/functions/inverse/compareInverseValues.js

@@ -0,0 +1,136 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    const symbols = ["<", "=", ">"];
+    addValidProp(propositions, answer);
+    const remaining = symbols.filter((s) => s !== answer);
+    for (const sym of remaining) {
+        tryToAddWrongProp(propositions, sym);
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = ({ a, b }) => {
+    const aNode = reifyAlgebraic(a);
+    const bNode = reifyAlgebraic(b);
+    const aVal = aNode.simplify().evaluate();
+    const bVal = bNode.simplify().evaluate();
+    return aVal === bVal ? "=" : aVal < bVal ? ">" : "<";
+};
+const getInstruction = ({ a, b, isMinusInside, }) => {
+    const aNode = reifyAlgebraic(a);
+    const bNode = reifyAlgebraic(b);
+    return `Compléter par le bon symbole : 
+  
+$$
+${frac(1, aNode).toTex({
+        allowMinusAnywhereInFraction: isMinusInside,
+    })}\\ \\ldots \\ ${frac(1, bNode).toTex({
+        allowMinusAnywhereInFraction: isMinusInside,
+    })}
+$$`;
+};
+const getHint = ({ a, b }) => {
+    return `Si $a$ et $b$ sont deux nombres non nuls et de même signe, alors la fonction inverse ne conserve pas l'ordre : 
+  
+- $\\frac{1}{a} < \\frac{1}{b}$ si et seulement si $a>b$ ; 
+- $\\frac{1}{a} > \\frac{1}{b}$ si et seulement si $a<b$ ; 
+- $\\frac{1}{a} = \\frac{1}{b}$ si et seulement si $a=b$ ; `;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, isMinusInside } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const bNode = reifyAlgebraic(b);
+    const aVal = aNode.simplify().evaluate();
+    const bVal = bNode.simplify().evaluate();
+    const signe = aVal < bVal ? "<" : aVal > bVal ? ">" : "=";
+    const answer = getAnswer(identifiers);
+    // return aVal === bVal ? "=" : aVal < bVal ? ">" : "<";
+    return `Puisque $${aNode.toTex()} ${signe} ${bNode.toTex()}$, et puisque ce sont deux nombres de même signe, leurs inverses sont dans l'ordre contraire : 
+
+$$
+${frac(1, aNode).toTex({
+        allowMinusAnywhereInFraction: isMinusInside,
+    })} ${answer} ${frac(1, bNode).toTex({
+        allowMinusAnywhereInFraction: isMinusInside,
+    })}
+$$
+`;
+};
+const getKeys = () => [];
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+function randBetween(isInteger, min, max, roundTo, excludes) {
+    if (isInteger) {
+        return randint(min, max, excludes);
+    }
+    else {
+        return randfloat(min, max, roundTo, excludes);
+    }
+}
+const getCompareInverseValuesQuestion = () => {
+    const min = 2;
+    const max = 50;
+    const roundTo = 2;
+    const isInteger = coinFlip();
+    let x;
+    let y;
+    if (coinFlip()) {
+        // tous deux positifs
+        x = randBetween(isInteger, min, max, roundTo);
+        y = randBetween(isInteger, min, max, roundTo, [x]);
+    }
+    else {
+        // tous deux négatifs
+        x = -randBetween(isInteger, min, max, roundTo);
+        y = -randBetween(isInteger, min, max, roundTo, [Math.abs(x)]);
+    }
+    const isMinusOutside = coinFlip();
+    const identifiers = {
+        a: x.toTree().toIdentifiers(),
+        b: y.toTree().toIdentifiers(),
+        isMinusInside: coinFlip(),
+    };
+    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 compareInverseValues = {
+    id: "compareInverseValues",
+    label: "Comparer des inverses",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareInverseValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/inverse/index.d.ts

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

package/lib/exercises/math/functions/inverse/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/inverse/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC"}

package/lib/exercises/math/functions/inverse/index.js

@@ -0,0 +1,2 @@
+export * from "./isPointOnReciprocalFunction.js";
+export * from "./compareInverseValues.js";

package/lib/exercises/math/functions/inverse/isPointOnReciprocalFunction.d.ts

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

package/lib/exercises/math/functions/inverse/isPointOnReciprocalFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPointOnReciprocalFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/inverse/isPointOnReciprocalFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAqGF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAqB7D,CAAC"}

package/lib/exercises/math/functions/inverse/isPointOnReciprocalFunction.js

@@ -0,0 +1,117 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { x, y } = identifiers;
+    const reciprocalNode = frac(1, "x");
+    const xNode = reifyAlgebraic(x);
+    const yNode = reifyAlgebraic(y);
+    const reciprocalValue = reciprocalNode
+        .toDetailedEvaluation({ x: xNode })
+        .simplify();
+    const answer = reciprocalValue.equals(yNode) ? "Oui" : "Non";
+    return answer;
+};
+const getInstruction = (identifiers) => {
+    const reciprocalNode = frac(1, "x");
+    const { x, y } = identifiers;
+    const xNode = reifyAlgebraic(x);
+    const yNode = reifyAlgebraic(y);
+    const point = new Point("A", xNode, yNode);
+    return `Le point $${point.toTexWithCoords()}$ appartient-il à la courbe de la fonction inverse ?`;
+};
+const getHint = (identifiers) => {
+    const reciprocalNode = frac(1, "x");
+    return `Un point $A(x;y)$ appartient à la courbe de la fonction inverse si et seulement si $y = ${reciprocalNode.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { x, y } = identifiers;
+    const fracNode = frac(1, "x");
+    const xNode = reifyAlgebraic(x);
+    const yNode = reifyAlgebraic(y);
+    const reciprocalValue = fracNode
+        .toDetailedEvaluation({ x: xNode })
+        .simplify();
+    if (getAnswer(identifiers) == "Oui") {
+        return `L'inverse de $${xNode.toTex()}$ est bien $${yNode.toTex()}$, donc le point appartient à la courbe de la fonction inverse.`;
+    }
+    else {
+        return `L'inverse de $${xNode.toTex()}$ est $${reciprocalValue.toTex()} \\neq ${yNode.toTex()}$. 
+    
+Le point n'appartient donc pas à la courbe de la fonction inverse.`;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans == answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIsPointOnReciprocalFunctionQuestion = (ops) => {
+    const xNumber = randint(-9, 10, [0]);
+    const xFrac = RationalConstructor.randomIrreductible().toTree();
+    const xDecimal = random([
+        round(randint(-9, 10, [0]) * 0.1, 3),
+        round(randint(-3, 4, [0]) * 0.25, 3),
+    ]);
+    const xChoices = [xNumber.toTree(), xFrac, xDecimal.toTree()];
+    const chosenX = random(xChoices);
+    const yNumber = coinFlip()
+        ? frac(1, chosenX).simplify()
+        : randint(1, 10).toTree();
+    const identifiers = {
+        x: chosenX.toIdentifiers(),
+        y: yNumber.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 isPointOnReciprocalFunction = {
+    id: "isPointOnReciprocalFunction",
+    label: "Déterminer si un point appartient à la courbe de la fonction inverse",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsPointOnReciprocalFunctionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/sign/equationFromSignTable.d.ts

@@ -6,6 +6,9 @@ type Identifiers = {
     type: number;
     ineqSymbol?: string;
 };
-export declare const equationFromSignTable: Exercise<Identifiers>;
+type Options = {
+    questionType: string;
+};
+export declare const equationFromSignTable: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=equationFromSignTable.d.ts.map

package/lib/exercises/math/functions/sign/equationFromSignTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationFromSignTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/equationFromSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,EAAE,EAAE,eAAe,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAkPF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}
+{"version":3,"file":"equationFromSignTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/equationFromSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,EAAE,EAAE,eAAe,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAuQF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBhE,CAAC"}

package/lib/exercises/math/functions/sign/equationFromSignTable.js

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionType, GeneratorOptionTarget, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { InequationSymbol, InequationSymbolConstructor, } from "../../../../math/inequations/inequation.js";
 import { randint } from "../../../../math/utils/random/randint.js";
@@ -150,14 +150,18 @@ $$
 ${getAnswer(identifiers)}
 $$`;
 };
-const getReadSignTableQuestion = (ops) => {
+const getReadSignTableQuestion = (opts) => {
     const a = randint(-10, 0);
     const b = randint(0, 10);
     const xs = [MinusInfinityNode, a.toTree(), b.toTree(), PlusInfinityNode];
     const signs = coinFlip()
         ? ["+", "0", "-", "0", "+"]
         : ["-", "0", "+", "0", "-"];
-    const type = randint(0, 2);
+    const type = !opts?.questionType || opts.questionType === "Les deux"
+        ? randint(0, 2)
+        : opts.questionType === "Inéquations"
+            ? 1
+            : 0;
     const ineqSymbol = InequationSymbolConstructor.randomSymbol();
     const identifiers = {
         type,
@@ -165,7 +169,7 @@ const getReadSignTableQuestion = (ops) => {
         xs: xs.map((e) => e.toIdentifiers()),
         signs,
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
 const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
@@ -192,15 +196,25 @@ const getKeys = (identifiers) => {
     else
         return ["S", "equal", "lbracket", "semicolon", "rbracket", "cup", "infty"];
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const options = [
+    {
+        id: "questionType",
+        type: GeneratorOptionType.select,
+        label: "Types de questions",
+        target: GeneratorOptionTarget.generation,
+        defaultValue: "Les deux",
+        values: ["Équation $f(x) = 0$", "Inéquations", "Les deux"],
+    },
+];
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     return {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
         answerFormat: "raw",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
-        keys: getKeys(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        keys: getKeys(identifiers, opts),
     };
 };
 export const equationFromSignTable = {
@@ -219,4 +233,5 @@ export const equationFromSignTable = {
     getQuestionFromIdentifiers,
     isAnswerValid,
     hasHintAndCorrection: true,
+    options,
 };

package/lib/exercises/math/functions/sqrt/getImageOfSquareRootFunction.d.ts

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

package/lib/exercises/math/functions/sqrt/getImageOfSquareRootFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getImageOfSquareRootFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sqrt/getImageOfSquareRootFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAmIF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}

package/lib/exercises/math/functions/sqrt/getImageOfSquareRootFunction.js

@@ -0,0 +1,128 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { isPowerNode, square } from "../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const randomNumber = randint(0, 100);
+        const randomNumberNode = randomNumber.toTree();
+        const randomNumberSquare = square(randomNumberNode);
+        const randomFraction = RationalConstructor.randomIrreductible().toTree();
+        const choices = [randomNumberNode, randomNumberSquare, randomFraction];
+        const randomChoice = random(choices);
+        tryToAddWrongProp(propositions, randomChoice.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a } = identifiers;
+    const sqrtNode = sqrt(reifyAlgebraic(a));
+    const x = sqrtNode.simplify().toTex();
+    return x;
+};
+const getInstruction = (identifiers) => {
+    const { a } = identifiers;
+    return `Déterminer l'image de $${reifyAlgebraic(a).toTex()}$ par la fonction racine carrée.`;
+};
+const getHint = (identifiers) => {
+    const { a } = identifiers;
+    return `Quel est le nombre qui, multiplié par lui-même, donne $${reifyAlgebraic(a).toTex()}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    const { a } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const tex = aNode.toTex();
+    const answer = getAnswer(identifiers);
+    switch (true) {
+        case isNumberNode(aNode):
+            return `On remarque que $${tex} = ${answer}^2$. 
+      
+Ici on a donc $\\sqrt{${tex}} = ${answer}$.`;
+        case isPowerNode(aNode):
+            return `On sait que $\\sqrt{x^2} = |x|$. 
+      
+Ici on a donc $\\sqrt{${tex}} = ${answer}$.`;
+        case isFractionNode(aNode):
+            return `On sait que $\\sqrt{\\frac{a}{b}} = \\frac{\\sqrt{a}}{\\sqrt{b}}$. 
+      
+Ici on a donc $\\sqrt{${tex}} = ${answer}$.`;
+        default:
+            throw new Error(`getCorrection: nœud inattendu rencontré (${aNode.constructor.name})`);
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        if (!isNumberNode(ansNode) && !isFractionNode(ansNode))
+            return false;
+        return ansNode.simplify().equals(answerNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGetImageOfSquareRootFunctionQuestion = (ops) => {
+    const xTreeValue = randint(1, 11) ** 2;
+    const xTree = xTreeValue.toTree();
+    const randomIntTree = randint(1, 100).toTree();
+    let denom = randint(2, 10);
+    let numer = randint(1, 10);
+    while (gcd(numer, denom) !== 1) {
+        denom = randint(2, 10);
+        numer = randint(1, 10);
+    }
+    const fractionTree = frac(numer ** 2, denom ** 2);
+    const candidates = [randomIntTree, fractionTree];
+    const chosenInputTree = candidates[randint(0, candidates.length)];
+    const squaredTree = square(chosenInputTree);
+    const choices = [
+        xTree.toIdentifiers(),
+        squaredTree.toIdentifiers(),
+        fractionTree.toIdentifiers(),
+    ];
+    const a = random(choices);
+    return getQuestionFromIdentifiers({ a });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const getImageOfSquareRootFunction = {
+    id: "getImageOfSquareRootFunction",
+    label: "Calculer une image par la fonction racine carrée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGetImageOfSquareRootFunctionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/sqrt/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./compareSqrtValues.js";
 export * from "./sqrtInequality.js";
 export * from "./squareRootCalculation.js";
+export * from "./getImageOfSquareRootFunction.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/sqrt/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sqrt/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sqrt/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mCAAmC,CAAC"}

package/lib/exercises/math/functions/sqrt/index.js

@@ -1,3 +1,4 @@
 export * from "./compareSqrtValues.js";
 export * from "./sqrtInequality.js";
 export * from "./squareRootCalculation.js";
+export * from "./getImageOfSquareRootFunction.js";

package/lib/exercises/math/functions/square/compareSquaredValues.d.ts

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

package/lib/exercises/math/functions/square/compareSquaredValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareSquaredValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/square/compareSquaredValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAkJF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC"}