math-exercises 3.0.208 → 3.0.211

package/lib/exercises/math/functions/logarithm/logSimplifiying.js

@@ -2,9 +2,11 @@ import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercis
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Rational } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { logn, LogNode } from "../../../../tree/nodes/functions/logNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -21,7 +23,7 @@ const getStatementNode = (identifiers) => {
     }
 };
 const getInstruction = (identifiers) => {
-    return `Écrire le nombre suivant sous la forme $\\ln\\left(a\\right)$ : 
+    return `Écrire le nombre suivant sous la forme $\\ln\\left(a\\right)$, avec $a\\in \\mathbb{R}$ : 
   
 $$
 ${getStatementNode(identifiers).toTex()}
@@ -36,15 +38,50 @@ const getAnswer = (identifiers) => {
         return new LogNode(new Rational(a, b).simplify().toTree()).toTex();
     }
 };
+const getHint = () => {
+    return `Pour tous nombres réels $a$ et $b$ strictement positifs, on a : 
+  
+- $\\ln(a) + \\ln(b) = \\ln(a\\times b)$
+- $\\ln(a) - \\ln(b) = \\ln(\\frac{a}{b})$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, pm } = identifiers;
+    if (pm === 1) {
+        return `On sait que pour tous nombres réels $a$ et $b$ strictement positifs, on a :
+    
+$$
+\\ln(a) + \\ln(b) = \\ln(a\\times b)
+$$
+
+Ici on a donc : 
+
+$$
+\\ln(${a}) + \\ln(${b}) = ${logn(multiply(a, b)).toSimplificationTex()}
+$$`;
+    }
+    else {
+        return `On sait que pour tous nombres réels $a$ et $b$ strictement positifs, on a :
+    
+$$
+\\ln(a) - \\ln(b) = \\ln(\\frac{a}{b})
+$$
+
+Ici on a donc : 
+
+$$
+\\ln(${a}) - \\ln(${b}) = ${logn(frac(a, b)).toSimplificationTex()}
+$$`;
+    }
+};
 const getKeys = () => {
     return ["lnBrackets"];
 };
 const getExpSimplifiying = () => {
     const pm = coinFlip() ? 1 : -1;
-    const a = randint(1, 10);
+    const a = randint(2, 10);
     let b;
     do {
-        b = randint(1, 10);
+        b = randint(2, 10);
     } while (pm === -1 && a === b);
     const identifiers = { pm, a, b };
     return getQuestionFromIdentifiers(identifiers);
@@ -56,6 +93,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -85,7 +124,7 @@ const isAnswerValid = (ans, { a, b, pm }) => {
 export const logSimplifiying = {
     id: "logSimplifiying",
     connector: "\\iff",
-    label: "Simplifier des expressions avec $\\ln$",
+    label: "Utiliser la propriété algébrique du logarithme népérien $\\ln(a) \\pm \\ln(b) = \\ln(ab)$",
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getExpSimplifiying, nb),
     qcmTimer: 60,
@@ -94,4 +133,5 @@ export const logSimplifiying = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -26,4 +26,5 @@ export * from "./tests/index.js";
 export * from "./pcExosInMath.js";
 export * from "./scratch/index.js";
 export * from "./integration/index.js";
+export * from "./arithmetic/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AAEvC,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/index.js

@@ -27,3 +27,4 @@ export * from "./pcExosInMath.js";
 export * from "./scratch/index.js";
 export * from "./integration/index.js";
 // export * from "./_debug/index.js";
+export * from "./arithmetic/index.js";

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

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

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

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

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

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

package/lib/exercises/math/integration/algorithms/pyIntegrationInstructionCompletion.d.ts

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

package/lib/exercises/math/integration/algorithms/pyIntegrationInstructionCompletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pyIntegrationInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/algorithms/pyIntegrationInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAoB7C,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,eAAe,CAAC;IACjC,kBAAkB,EAAE,eAAe,CAAC;IACpC,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAsUF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAgBpE,CAAC"}

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"}