math-exercises 3.0.209 → 3.0.211

package/lib/exercises/math/integration/algorithms/pyIntegrationInstructionCompletion.js

@@ -0,0 +1,273 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const createStrPythonForNode = (node) => {
+    return node.toMathString().replaceAll("^", "**");
+};
+const getHydrated = (identifiers) => {
+    const { nodeIdsInterval, nodeIdsDistanceMax } = identifiers;
+    const nodeInterval = NodeConstructor.fromIdentifiers(nodeIdsInterval);
+    const nodeDistanceMax = NodeConstructor.fromIdentifiers(nodeIdsDistanceMax);
+    return {
+        nodeInterval,
+        nodeDistanceMax,
+    };
+};
+const _getStrPythonProgram = (identifiers) => {
+    const { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    const [strIntervalBoundA, strIntervalBoundB] = [
+        nodeInterval.a,
+        nodeInterval.b,
+    ].map(createStrPythonForNode);
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    return `def integral(f,a,b, precision):
+    k = 1
+    while True:
+        sr,sR = rectangles(f,a,b,k)
+        if(sR-sr < precision):                                                    #
+            return sr,sR
+        else:
+            k = k + 1                                                             #
+    
+def rectangles(f,a,b,n):
+    sr, sR = 0,0                                                                  #
+    l = (b-a)/n                                                                   #
+    for i in range(n):                                                            #
+        sr = sr + f(a + l * i) * l                                                #
+        sR = sR + f(a + l * (i+1)) * l                                            #
+    return sr,sR
+    
+sr,sR = integral(f,${strIntervalBoundA}, ${strIntervalBoundB},${strDistanceMax})  #
+print(sr, "<=", I, "<=", sR)`;
+};
+const getStrPythonProgramComplete = (identifiers) => {
+    const identifiersTweaked = {
+        ...identifiers,
+        keyIncomplete: "",
+    };
+    return getStrPythonProgramIncomplete(identifiersTweaked);
+};
+const getStrPythonProgramIncomplete = (identifiers) => {
+    const { keyIncomplete } = identifiers;
+    const { strIntegralCondition, strIntegralElse, strRectanglesInitialization, strRectanglesL, strRectanglesLoop, strRectanglesSMin, strRectanglesSMax, strCallIntegral, } = Object.fromEntries(Object.entries(getDictStrCompletion(identifiers)).map(([key, str]) => key === keyIncomplete ? [key, "..."] : [key, str]));
+    return `def integral(f,a,b, precision):
+    k = 1
+    while True:
+        sr,sR = rectangles(f,a,b,k)
+        ${strIntegralCondition}
+            return sr,sR
+        else:
+            ${strIntegralElse}
+    
+def rectangles(f,a,b,n):
+    ${strRectanglesInitialization}
+    ${strRectanglesL}
+    ${strRectanglesLoop}
+        ${strRectanglesSMin}
+        ${strRectanglesSMax}
+    return sr,sR
+    
+${strCallIntegral}
+print(sr, "<=", I, "<=", sR)`;
+};
+const getDictStrCompletion = (identifiers) => {
+    const { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    const [strIntervalBoundA, strIntervalBoundB] = [
+        nodeInterval.a,
+        nodeInterval.b,
+    ].map(createStrPythonForNode);
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    return {
+        strIntegralCondition: `if(sR-sr < precision):`,
+        strIntegralElse: `k = k + 1`,
+        strRectanglesInitialization: `sr, sR = 0,0`,
+        strRectanglesL: `l = (b-a)/n`,
+        strRectanglesLoop: `for i in range(n):`,
+        strRectanglesSMin: `sr = sr + f(a + l * i) * l`,
+        strRectanglesSMax: `sR = sR + f(a + l * (i+1)) * l`,
+        strCallIntegral: `sr,sR = integral(f,${strIntervalBoundA}, ${strIntervalBoundB},${strDistanceMax})`,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    return `On considère une fonction $f$ positive et strictement croissante, 
+dont on veut calculer $I$, l'intégrale de $f$ sur l'intervalle $${nodeInterval.toTex()}$ 
+en utilisant la méthode des rectangles, avec une précision de $${nodeDistanceMax.toTex()}$. 
+
+Dans le programme suivant, 
+on suppose que l'on dispose d'une fonction ${codifyChunk("f")} 
+telle que ${codifyChunk("f(x)")} retourne $f(x)$.
+
+Par quoi faut-il remplacer les pointillés dans le programme suivant pour qu'il affiche l'encadrement par les deux sommes de $n$ rectangles, 
+$n$ étant le nombre de rectangles à partir duquel l'écart entre les deux sommes 
+est strictement inférieur à $${nodeDistanceMax.toTex()}$ ?
+
+${codify(getStrPythonProgramIncomplete(identifiers))}
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { keyIncomplete } = identifiers;
+    const dictStrCompletion = getDictStrCompletion(identifiers);
+    return codifyChunk(dictStrCompletion[keyIncomplete]);
+};
+const getHint = (identifiers) => {
+    const { keyIncomplete } = identifiers;
+    switch (keyIncomplete) {
+        case "strIntegralCondition":
+            return `Écris en Python "Si la différence de la somme des rectangles au-dessus de la courbe de $f$ avec la somme des rectangles au-dessous de la courbe de $f$ est inférieure à $precision$ alors".`;
+        case "strIntegralElse":
+            return `Si la condition n'est pas remplie, on augmente le nombre de rectangles de $1$.`;
+        case "strRectanglesInitialization":
+            return `Les sommes doivent être initialisées.`;
+        case "strRectanglesL":
+            return `Quelle est la largeur d'un rectangle ?`;
+        case "strRectanglesLoop":
+            return `Pour calculer les sommes, on part de la borne inférieure d'intégration et on se décale petit à petit.`;
+        case "strRectanglesSMin":
+            return `Pour calculer la somme des aires des rectangles au-dessous de la courbe, à chaque itération, on ajoute l'aire du rectangle "à gauche".`;
+        case "strRectanglesSMax":
+            return `Pour calculer la somme des aires des rectangles au-dessus de la courbe, à chaque itération, on ajoute l'aire du rectangle "à droite".`;
+        default:
+            throw new Error("Unsupported keyIncomplete: " + keyIncomplete);
+    }
+};
+const getCorrection = (identifiers) => {
+    return `Voici le programme complet :
+
+${codify(getStrPythonProgramComplete(identifiers))}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const { keyIncomplete } = identifiers;
+    switch (keyIncomplete) {
+        case "strIntegralCondition":
+            {
+                [
+                    "if(sr-sR < precision):",
+                    "if(sR-sr > precision):",
+                    "if(sr-sR > precision):",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strIntegralElse":
+            {
+                ["k + 1", "n = n + 1", "n + 1"].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strRectanglesInitialization":
+            {
+                [
+                    "sr, sR = 1,1",
+                    "sr,sR = f(a), f(a + (b-a)/n)",
+                    "sr,sR = a, a + (b-a)/n",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strRectanglesL":
+            {
+                ["l = b-a", "l = (b-a)*n", "l = b-a/n"].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strRectanglesLoop":
+            {
+                [
+                    "for i in range(l):",
+                    "for i in range(n+1):",
+                    "for i in range(n-1):",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strRectanglesSMin":
+            {
+                [
+                    "sr = sr + f(a + i) * l",
+                    "sr = sr + f(a + l * i)",
+                    "sr = sr + f(a + l) * i",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strRectanglesSMax":
+            {
+                [
+                    "sR = f(a + l * (i+1)) * l",
+                    "sR = sR + f(a + l * (i+1))",
+                    "sR = sR + f(a + (l+1) * i) * (l+1)",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        default:
+            throw new Error("Unsupported keyIncomplete: " + keyIncomplete);
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = () => {
+    const nodeDistanceMax = power(10, randint(-3, 0));
+    const keyIncomplete = random([
+        "strIntegralCondition",
+        "strIntegralElse",
+        "strRectanglesInitialization",
+        "strRectanglesL",
+        "strRectanglesLoop",
+        "strRectanglesSMin",
+        "strRectanglesSMax",
+        // "strCallIntegral",
+    ]);
+    const nodeInterval = (() => {
+        const a = randint(-5, 5);
+        const b = a + randint(1, 5);
+        return new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF);
+    })();
+    const identifiers = {
+        nodeIdsInterval: nodeInterval.toIdentifiers(),
+        nodeIdsDistanceMax: nodeDistanceMax.toIdentifiers(),
+        keyIncomplete,
+    };
+    return identifiers;
+};
+const getPyIntegrationInstructionCompletionQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+export const pyIntegrationInstructionCompletion = {
+    id: "pyIntegrationInstructionCompletion",
+    label: "Compléter un algorithme pour obtenir un encadrement d'une intégrale",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyIntegrationInstructionCompletionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/integration/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./fromGraph/index.js";
 export * from "./fromExpr/index.js";
 export * from "./integralOfPiecewiseFunctionByUsingComputedIntegrals.js";
+export * from "./algorithms/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/integration/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/integration/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,0DAA0D,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/integration/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,0DAA0D,CAAC;AAEzE,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/integration/index.js

@@ -1,3 +1,4 @@
 export * from "./fromGraph/index.js";
 export * from "./fromExpr/index.js";
 export * from "./integralOfPiecewiseFunctionByUsingComputedIntegrals.js";
+export * from "./algorithms/index.js";

package/lib/exercises/math/limits/algorithms/index.d.ts

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

package/lib/exercises/math/limits/algorithms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/limits/algorithms/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC"}

package/lib/exercises/math/limits/algorithms/index.js

@@ -0,0 +1 @@
+export * from "./pyLimitProgramExecution.js";

package/lib/exercises/math/limits/algorithms/pyLimitProgramExecution.d.ts

@@ -0,0 +1,17 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    abscissaType: string;
+    imageType: string;
+    nodeIdsF: NodeIdentifiers;
+    nodeIdsAbscissa: NodeIdentifiers;
+    nodeIdsImage: NodeIdentifiers;
+    nodeIdsPrecision?: NodeIdentifiers;
+};
+type Options = {
+    abscissaType: string;
+    imageType: string;
+};
+export declare const pyLimitProgramExecution: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=pyLimitProgramExecution.d.ts.map

package/lib/exercises/math/limits/algorithms/pyLimitProgramExecution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pyLimitProgramExecution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/limits/algorithms/pyLimitProgramExecution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4B7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,eAAe,CAAC;IAC1B,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,EAAE,eAAe,CAAC;IAC9B,gBAAgB,CAAC,EAAE,eAAe,CAAC;CACpC,CAAC;AA8VF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+BF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBlE,CAAC"}

package/lib/exercises/math/limits/algorithms/pyLimitProgramExecution.js

@@ -0,0 +1,353 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.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 { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const createStrPythonForNode = (node) => {
+    return node.toMathString().replaceAll("^", "**");
+};
+const getHydrated = (identifiers) => {
+    const { nodeIdsF, nodeIdsAbscissa, nodeIdsPrecision, nodeIdsImage } = identifiers;
+    const [nodeF, nodeAbsissa, nodeImage] = [
+        nodeIdsF,
+        nodeIdsAbscissa,
+        nodeIdsImage,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodePrecision = nodeIdsPrecision &&
+        NodeConstructor.fromIdentifiers(nodeIdsPrecision);
+    return {
+        nodeF,
+        nodeAbsissa,
+        nodeImage,
+        nodePrecision,
+    };
+};
+const getStrPythonProgram = (identifiers) => {
+    const { abscissaType, imageType } = identifiers;
+    const { nodeF, nodeAbsissa, nodeImage, nodePrecision } = getHydrated(identifiers);
+    const [strAbscissa, strImage] = [nodeAbsissa, nodeImage].map((node) => createStrPythonForNode(node));
+    const strPrecision = nodePrecision && createStrPythonForNode(nodePrecision);
+    return `def f(x):
+    return ${createStrPythonForNode(nodeF)}
+    
+${(() => {
+        switch (abscissaType) {
+            case "$-\\infty$":
+                switch (imageType) {
+                    case "$-\\infty$":
+                    case "$+\\infty$":
+                        return `x = 0
+while abs(f(x)) < 10000 :
+  x = x - 10`;
+                    case "$x \\in \\mathbb{R}$":
+                        return `x = 0
+while abs(f(x) - ${strImage}) > ${strPrecision} :
+  x = x - 10`;
+                    default:
+                        throw new Error("Unsupported imageType: " + imageType);
+                }
+            case "$+\\infty$": {
+                switch (imageType) {
+                    case "$-\\infty$":
+                    case "$+\\infty$":
+                        return `x = 0
+while abs(f(x)) < 10000 :
+  x = x + 10`;
+                    case "$x \\in \\mathbb{R}$":
+                        return `x = 0
+while abs(f(x) - ${strImage}) > ${strPrecision} :
+  x = x + 10`;
+                    default:
+                        throw new Error("Unsupported imageType: " + imageType);
+                }
+            }
+            case "$x \\in \\mathbb{R}$": {
+                switch (imageType) {
+                    case "$-\\infty$":
+                    case "$+\\infty$":
+                        return `x = ${strAbscissa} + 1
+while abs(f(x)) < 10000 :
+  x = x - 0.01`;
+                    default:
+                        throw new Error("Unsupported imageType: " + imageType);
+                }
+            }
+            default:
+                throw new Error("Unsupported abscissaType: " + abscissaType);
+        }
+    })()}`;
+};
+const getXValueForPythonProgram = (identifiers) => {
+    const { abscissaType, imageType } = identifiers;
+    const { nodeF, nodeAbsissa, nodeImage, nodePrecision } = getHydrated(identifiers);
+    switch (abscissaType) {
+        case "$-\\infty$":
+            switch (imageType) {
+                case "$-\\infty$":
+                case "$+\\infty$": {
+                    let x = 0;
+                    while (Math.abs(nodeF.evaluate({ x })) < 10000) {
+                        x = x - 10;
+                    }
+                    return x;
+                }
+                case "$x \\in \\mathbb{R}$": {
+                    let x = 0;
+                    while (Math.abs(nodeF.evaluate({ x }) - nodeImage.evaluate()) >
+                        nodePrecision.evaluate()) {
+                        x = x - 10;
+                    }
+                    return x;
+                }
+                default:
+                    throw new Error("Unsupported imageType: " + imageType);
+            }
+        case "$+\\infty$":
+            switch (imageType) {
+                case "$-\\infty$":
+                case "$+\\infty$": {
+                    let x = 0;
+                    while (Math.abs(nodeF.evaluate({ x })) < 10000) {
+                        x = x - 10;
+                    }
+                    return x;
+                }
+                case "$x \\in \\mathbb{R}$": {
+                    let x = 0;
+                    while (Math.abs(nodeF.evaluate({ x }) - nodeImage.evaluate()) >
+                        nodePrecision.evaluate()) {
+                        x = x - 10;
+                    }
+                    return x;
+                }
+                default:
+                    throw new Error("Unsupported imageType: " + imageType);
+            }
+        case "$x \\in \\mathbb{R}$": {
+            switch (imageType) {
+                case "$-\\infty$":
+                case "$+\\infty$": {
+                    let x = nodeAbsissa.evaluate() + 1;
+                    while (Math.abs(nodeF.evaluate({ x })) < 10000) {
+                        x = x - 0.01;
+                    }
+                    return x;
+                }
+                default:
+                    throw new Error("Unsupported imageType: " + imageType);
+            }
+        }
+        default:
+            throw new Error("Unsupported abscissaType: " + abscissaType);
+    }
+};
+const getInstruction = (identifiers) => {
+    return `On considère le script suivant en langage Python. Quelle valeur contient la variable $x$ après son exécution ?
+
+${codify(getStrPythonProgram(identifiers))}
+
+`;
+};
+const getAnswer = (identifiers) => {
+    return codifyChunk(createStrPythonForNode(getXValueForPythonProgram(identifiers).toTree()));
+};
+const getHint = (_identifiers) => {
+    return "Trouve la valeur qui semble la plus probable dans la liste des valeurs proposées.";
+};
+const getCorrection = (identifiers) => {
+    return `La valeur de $x$ quand on exécute le script est $${getAnswer(identifiers)}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, getAnswer(identifiers), "raw");
+    const { nodeAbsissa } = getHydrated(identifiers);
+    const x = getXValueForPythonProgram(identifiers);
+    if (nodeAbsissa.toTex() === "+\\infty") {
+        [
+            (-8000).toTree(),
+            (-4290).toTree(),
+            (-19800).toTree(),
+            randint(-50, 50, [0]).toTree(),
+        ].forEach((node) => {
+            tryToAddWrongProp(propositions, codifyChunk(createStrPythonForNode(node)), "raw");
+        });
+    }
+    else if (nodeAbsissa.toTex() === "-\\infty") {
+        [
+            (+8000).toTree(),
+            (+4290).toTree(),
+            (+19800).toTree(),
+            randint(-50, 50, [0]).toTree(),
+        ].forEach((node) => {
+            tryToAddWrongProp(propositions, codifyChunk(createStrPythonForNode(node)), "raw");
+        });
+    }
+    else {
+        [(8000).toTree(), (-8000).toTree(), (-x).toTree()].forEach((node) => {
+            tryToAddWrongProp(propositions, codifyChunk(createStrPythonForNode(node)), "raw");
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getPyLimitProgramExecutionQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const pool = getCartesiansProducts([
+        arrayedOpts.abscissaType,
+        arrayedOpts.imageType,
+    ]).filter(([abscissaType, imageType]) => {
+        return !(abscissaType === "$x \\in \\mathbb{R}$" &&
+            imageType === "$x \\in \\mathbb{R}$");
+    });
+    const [abscissaType, imageType] = random(pool);
+    const [nodeF, nodeAbsissa, nodeImage, nodePrecision] = (() => {
+        const nodeVarX = new VariableNode("x");
+        switch (abscissaType) {
+            case "$-\\infty$":
+            case "$+\\infty$": {
+                const nodeAbsissa = abscissaType === "$-\\infty$" ? PlusInfinityNode : MinusInfinityNode;
+                const [nodeF, nodeImage, nodePrecision] = (() => {
+                    switch (imageType) {
+                        case "$-\\infty$": {
+                            const nodePrecision = random([0.1, 0.01, 0.001]).toTree();
+                            const nodeF = (() => {
+                                const [a, b, c, d] = [...Array(4).keys()].reduce((acc, _i) => {
+                                    acc = [...acc, randint(1, 10, acc)];
+                                    return acc;
+                                }, []);
+                                const nodeNum = add(multiply(-a, square(nodeVarX)), b);
+                                const nodeDen = add(multiply(c, nodeVarX), d);
+                                return frac(nodeNum, nodeDen);
+                            })();
+                            const nodeImage = MinusInfinityNode;
+                            return [nodeF, nodeImage, nodePrecision];
+                        }
+                        case "$x \\in \\mathbb{R}$": {
+                            const nodeImage = randint(-50, 51).toTree();
+                            const a = randint(-9, 10, [0]);
+                            const nodeF = add(nodeImage, frac(a, nodeVarX));
+                            return [nodeF, nodeImage, undefined];
+                        }
+                        case "$+\\infty$": {
+                            const nodePrecision = random([0.1, 0.01, 0.001]).toTree();
+                            const nodeF = (() => {
+                                const [a, b, c, d] = [...Array(4).keys()].reduce((acc, _i) => {
+                                    acc = [...acc, randint(1, 10, acc)];
+                                    return acc;
+                                }, []);
+                                const nodeNum = add(multiply(+a, square(nodeVarX)), b);
+                                const nodeDen = add(multiply(c, nodeVarX), d);
+                                return frac(nodeNum, nodeDen);
+                            })();
+                            const nodeImage = MinusInfinityNode;
+                            return [nodeF, nodeImage, nodePrecision];
+                        }
+                        default:
+                            throw new Error("Unsupported imageType: " + imageType);
+                    }
+                })();
+                return [nodeF, nodeAbsissa, nodeImage, nodePrecision];
+            }
+            case "$x \\in \\mathbb{R}$": {
+                const nodeAbsissa = randint(-50, 51).toTree();
+                const [nodeF, nodeImage] = (() => {
+                    switch (imageType) {
+                        case "$-\\infty$": {
+                            const a = randint(-9, 0);
+                            const nodeF = frac(a, square(substract(nodeVarX, nodeAbsissa)));
+                            const nodeImage = MinusInfinityNode;
+                            return [nodeF, nodeImage];
+                        }
+                        case "$+\\infty$": {
+                            const a = randint(1, 10);
+                            const nodeF = frac(a, square(substract(nodeVarX, nodeAbsissa)));
+                            const nodeImage = PlusInfinityNode;
+                            return [nodeF, nodeImage];
+                        }
+                        default:
+                            throw new Error("Unsupported imageType: " + imageType);
+                    }
+                })();
+                return [nodeF, nodeAbsissa, nodeImage, undefined];
+            }
+            default:
+                throw new Error("Unsupported abscissaType: " + abscissaType);
+        }
+    })();
+    const identifiers = {
+        abscissaType,
+        imageType,
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsAbscissa: nodeAbsissa.toIdentifiers(),
+        nodeIdsImage: nodeImage.toIdentifiers(),
+        nodeIdsPrecision: nodePrecision?.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    abscissaType: ["$-\\infty$", "$x \\in \\mathbb{R}$", "$+\\infty$"],
+    imageType: ["$-\\infty$", "$+\\infty$"],
+};
+const options = [
+    {
+        id: "abscissaType",
+        label: "Type d'abscisse",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["$-\\infty$", "$x \\in \\mathbb{R}$", "$+\\infty$"],
+        defaultValue: arrayedOptsDefault.abscissaType,
+    },
+    {
+        id: "imageType",
+        label: "Type d'image",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["$-\\infty$", "$x \\in \\mathbb{R}$", "$+\\infty$"],
+        defaultValue: arrayedOptsDefault.imageType,
+    },
+];
+export const pyLimitProgramExecution = {
+    id: "pyLimitProgramExecution",
+    label: "Exécuter un script Python de manifestation d'une limite de fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyLimitProgramExecutionQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    getInstruction,
+    getHint,
+    getCorrection,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/limits/index.d.ts

@@ -7,4 +7,5 @@ export * from "./frac1XTimesALogXPlusBLimit.js";
 export * from "./kLogXPlusTrinomLimit.js";
 export * from "./logOfPolynomialLimit.js";
 export * from "./sequences/index.js";
+export * from "./algorithms/index.js";
 //# sourceMappingURL=index.d.ts.map