math-exercises 3.0.156 → 3.0.158

package/lib/exercises/math/functions/exponential/algebraic/rewriteExpUsingExpA.js

@@ -0,0 +1,337 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } 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 { ExpNode } from "../../../../../tree/nodes/functions/expNode.js";
+import { sqrt } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.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 { random } from "../../../../../utils/alea/random.js";
+const myExpFunc = (opts) => {
+    return (nodeChild) => new ExpNode(nodeChild, { useExpNotation: opts.isUseExpNotation });
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const myExp = myExpFunc(opts);
+    const { nodeIdsA, nodeIdsAOpB } = identifiers;
+    const [nodeA, nodeAOpB] = [nodeIdsA, nodeIdsAOpB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Exprimer $${myExp(nodeAOpB).toTex()}$
+
+en fonction de $${myExp(nodeA).toTex()}$.`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const myExp = myExpFunc(opts);
+    const { nodeIdsA, nodeIdsB, rand } = identifiers;
+    const [nodeA, nodeB] = [nodeIdsA, nodeIdsB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    switch (rand) {
+        case 0:
+            return multiply(myExp(nodeA), myExp(nodeB));
+        case 1:
+            return frac(myExp(nodeA), myExp(nodeB));
+        case 2:
+            return power(myExp(nodeA), nodeB);
+        case 3:
+            return frac(1, myExp(nodeA));
+        case 4:
+            return sqrt(myExp(nodeA));
+        default:
+            throw new Error("Unsupported rand: " + rand);
+    }
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getHint = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const myExp = myExpFunc(opts);
+    const { rand } = identifiers;
+    switch (rand) {
+        case 0:
+            return `Utilise la propriété : 
+
+Si $a$ et $b$ sont deux nombres réels, alors :
+  
+$$
+${myExp(add("a".toTree(), "b".toTree())).toTex()} = ${myExp("a".toTree()).toTex()} \\times ${myExp("b".toTree()).toTex()}
+$$
+
+`;
+        case 1:
+            return `Utilise la propriété : 
+
+Si $a$ et $b$ sont deux nombres réels, alors :
+  
+$$
+${myExp(substract("a".toTree(), "b".toTree())).toTex()} = ${myExp("a".toTree()).toTex()} \\times ${myExp("b".toTree()).toTex()}
+$$
+
+`;
+        case 2:
+            return `Utilise la propriété : 
+
+Si $a$ et $b$ sont deux nombres réels, alors :
+  
+$$
+${myExp(multiply("a".toTree(), "b".toTree())).toTex()} = {(${myExp("a".toTree()).toTex()})}^{b}
+$$
+
+`;
+        case 3:
+            return `Utilise la propriété : 
+
+Si $a$ est un nombre réel, alors :
+  
+$$
+${myExp("-a".toTree()).toTex()} = {${myExp("a".toTree()).toTex()}}^{-1} = \\frac{1}{${myExp("a".toTree()).toTex()}}
+$$
+
+`;
+        case 4:
+            return `Utilise la propriété : 
+
+Si $a$ et $b$ sont deux nombres réels, alors :
+  
+$$
+${myExp(multiply(frac(1, 2), "a".toTree())).toTex()} = \\sqrt{${myExp("a".toTree()).toTex()}}
+$$
+
+`;
+        default:
+            throw new Error("Unsupported rand: " + rand);
+    }
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const myExp = myExpFunc(opts);
+    const { nodeIdsAOpB, rand } = identifiers;
+    const nodeAOpB = NodeConstructor.fromIdentifiers(nodeIdsAOpB);
+    return `${(() => {
+        switch (rand) {
+            case 0:
+                return `Pour $a$ et $b$ réels, on a :
+
+$$
+${myExp(add("a".toTree(), "b".toTree())).toTex()} = ${myExp("a".toTree()).toTex()} \\times ${myExp("b".toTree()).toTex()}
+$$
+      
+`;
+            case 1:
+                return `Pour $a$ et $b$ réels, on a :
+
+$$
+${myExp(substract("a".toTree(), "b".toTree())).toTex()} = ${myExp("a".toTree()).toTex()} \\times ${myExp("b".toTree()).toTex()}
+$$
+      
+`;
+            case 2:
+                return `Pour $a$ et $b$ réels, on a :
+  
+$$
+${myExp(multiply("a".toTree(), "b".toTree())).toTex()} = {(${myExp("a".toTree()).toTex()})}^{b}
+$$
+
+`;
+            case 3:
+                return `Pour $a$ et $b$ réels, on a :
+  
+$$
+${myExp("-a".toTree()).toTex()} = {${myExp("a".toTree()).toTex()}}^{-1} = \\frac{1}{${myExp("a".toTree()).toTex()}}
+$$
+
+`;
+            case 4:
+                return `Pour $a$ et $b$ réels, on a :
+  
+$$
+${myExp(multiply(frac(1, 2), "a".toTree())).toTex()} = \\sqrt{${myExp("a".toTree()).toTex()}}
+$$
+
+`;
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    })()}
+  
+Ainsi : 
+
+$$
+${myExp(nodeAOpB).toTex()} = ${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const myExp = myExpFunc(opts);
+    const { nodeIdsA, nodeIdsB } = identifiers;
+    const [nodeA, nodeB] = [nodeIdsA, nodeIdsB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const propositions = [];
+    addValidProp(propositions, answer);
+    [0, 1, 2].forEach((rand) => {
+        const identifiersWrong = Object.assign({}, identifiers, { rand });
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong, opts));
+    });
+    //exp(a)+exp(b)
+    {
+        const nodeWrong = add(myExp(nodeA), myExp(nodeB));
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //exp(a)-exp(b)
+    {
+        const nodeWrong = substract(myExp(nodeA), myExp(nodeB));
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //exp(a)^exp(b)
+    {
+        const nodeWrong = power(myExp(nodeA), myExp(nodeB));
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const nodeA = NodeConstructor.fromIdentifiers(identifiers.nodeIdsA);
+    const isUsingPi = nodeA.toTex().includes("\\pi");
+    return [
+        ...(opts.isUseExpNotation ? ["exp"] : ["e"]),
+        ...(isUsingPi ? ["pi"] : []),
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const myExp = myExpFunc(opts);
+    const { nodeIdsA, nodeIdsAOpB } = identifiers;
+    const [nodeA, nodeAOpB] = [nodeIdsA, nodeIdsAOpB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeAns = parseAlgebraic(ans);
+    //nodeAns must not include exp(aOpB)
+    {
+        const texExpAOpB = myExp(nodeAOpB).toTex();
+        if (ans.includes(texExpAOpB)) {
+            return false;
+        }
+    }
+    //nodeAns must include exp(a)
+    {
+        const texExpA = myExp(nodeA).toTex();
+        if (!ans.includes(texExpA)) {
+            return false;
+        }
+    }
+    const nodeAnswer = parseAlgebraic(answer);
+    return substract(nodeAns, nodeAnswer).evaluate() === 0;
+};
+const getRewriteExpUsingExpAQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const numberPool = [...Array(20).keys()].map((i) => i + 3);
+    const nodeA = random([
+        () => random(numberPool).toTree(),
+        () => randfloat(2, 5, 2, [2]).toTree(),
+        () => PiNode,
+    ])();
+    const rand = randint(0, 5);
+    let nodeB;
+    let nodeAOpB;
+    switch (rand) {
+        case 0: //exp(a+b)
+            {
+                nodeB = random(numberPool, [nodeA.evaluate()]).toTree();
+                nodeAOpB = add(nodeA, nodeB).simplify({
+                    fractionsToDecimal: true,
+                });
+            }
+            break;
+        case 1: //exp(a-b)
+            {
+                nodeB = random(numberPool, [
+                    nodeA.evaluate(),
+                    nodeA.evaluate() / 2,
+                    nodeA.evaluate() - 1,
+                ]).toTree();
+                nodeAOpB = substract(nodeA, nodeB).simplify({
+                    fractionsToDecimal: true,
+                });
+            }
+            break;
+        case 2: //exp(ba)
+            {
+                nodeB = random([2, 5, 10]).toTree();
+                nodeAOpB = multiply(nodeA, nodeB).simplify({
+                    fractionsToDecimal: true,
+                });
+            }
+            break;
+        case 3: //exp(-a)
+            {
+                nodeB = (-1).toTree();
+                nodeAOpB = multiply(nodeA, nodeB).simplify({
+                    fractionsToDecimal: true,
+                });
+            }
+            break;
+        case 4: //exp((1/2)a)
+            {
+                nodeB = frac(1, 2);
+                nodeAOpB = multiply(nodeA, nodeB).simplify({
+                    fractionsToDecimal: true,
+                });
+            }
+            break;
+        default:
+            throw new Error("Unsupported rand: " + rand);
+    }
+    const identifiers = {
+        nodeIdsA: nodeA.toIdentifiers(),
+        nodeIdsB: nodeB.toIdentifiers(),
+        nodeIdsAOpB: nodeAOpB.toIdentifiers(),
+        rand,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const optsDefault = {
+    isUseExpNotation: true,
+};
+const options = [
+    {
+        id: "isUseExpNotation",
+        label: "Écrire l'exponentielle $\\exp(\\text{...})$",
+        defaultValue: optsDefault.isUseExpNotation,
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+    },
+];
+export const rewriteExpUsingExpA = {
+    id: "rewriteExpUsingExpA",
+    label: "Réécrire une expression exponentielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRewriteExpUsingExpAQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/exponential/definition/approxExpAPlusH.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsA: NodeIdentifiers;
+    nodeIdsH: NodeIdentifiers;
+    nodeIdsAOpH: NodeIdentifiers;
+    expARounded: number;
+};
+export declare const approxExpAPlusH: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=approxExpAPlusH.d.ts.map

package/lib/exercises/math/functions/exponential/definition/approxExpAPlusH.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approxExpAPlusH.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/definition/approxExpAPlusH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,eAAe,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAqQF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAkBjD,CAAC"}

package/lib/exercises/math/functions/exponential/definition/approxExpAPlusH.js

@@ -0,0 +1,234 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../../math/utils/functions/functionComposition.js";
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../../math/utils/round.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.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 { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const precision = 2;
+const getInstruction = (identifiers) => {
+    const { nodeIdsA, nodeIdsH, nodeIdsAOpH, expARounded } = identifiers;
+    const [nodeA, nodeH, nodeAOpH] = [nodeIdsA, nodeIdsH, nodeIdsAOpH].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [texA, _] = [nodeA, nodeH].map((node) => node.toTex());
+    const nodeAOpHSubstituted = [
+        ["a", nodeA],
+        ["h", nodeH],
+    ].reduce((acc, [varName, nodeInjected]) => {
+        return nodeBySubstitutingVar(acc, nodeInjected, new VariableNode(varName));
+    }, nodeAOpH);
+    const texAOpHSubstituted = nodeAOpHSubstituted.toTex();
+    return `Sachant que :
+  
+$$
+\\exp(${texA})\\approx${expARounded.frenchify()}
+$$
+
+donner une valeur approchée de $\\exp(${texAOpHSubstituted})$ 
+
+avec $${precision}$ décimale${precision > 1 ? "s" : ""}.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsH, nodeIdsAOpH, expARounded } = identifiers;
+    const [nodeH, nodeAOpH] = [nodeIdsH, nodeIdsAOpH].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const texAOpH = nodeAOpH.toTex();
+    switch (texAOpH) {
+        case "a+h":
+            {
+                const nodeY0 = expARounded;
+                const nodeS = expARounded;
+                const nodeRaw = add(nodeY0, multiply(nodeS, nodeH));
+                return round(nodeRaw.evaluate(), precision).toTree();
+            }
+            break;
+        case "a-h":
+            {
+                const nodeY0 = expARounded;
+                const nodeS = expARounded;
+                const nodeRaw = substract(nodeY0, multiply(nodeS, nodeH));
+                return round(nodeRaw.evaluate(), precision).toTree();
+            }
+            break;
+        default:
+            throw new Error("Unsupported texAOpH: " + texAOpH);
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Sur un intervalle de longueur $h$ 
+    
+où l'on assimile la courbe d'une fonction f donnée 
+
+à sa tangente à l'abscisse $a$, on a :
+
+$$
+f(a+h) \\approx f(a) +  f'(a) \\times h  
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsA, nodeIdsH, nodeIdsAOpH, expARounded } = identifiers;
+    const [nodeA, nodeH, nodeAOpH] = [nodeIdsA, nodeIdsH, nodeIdsAOpH].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [texA, texH, texAOpH] = [nodeA, nodeH, nodeAOpH].map((node) => node.toTex());
+    switch (texAOpH) {
+        case "a+h":
+            return `On souhaite utiliser la formule : 
+  
+$$
+\\exp(${texA} + ${texH}) \\approx \\exp(${texA}) + \\exp'(${texA}) \\times ${texH}
+$$
+
+Or : 
+
+$$
+\\exp'(${texA}) = \\exp(${texA}) \\approx ${expARounded.frenchify()}
+$$
+
+Ainsi :
+
+$$
+\\exp(${texA} + ${texH}) \\approx ${expARounded.frenchify()} + ${expARounded.frenchify()} \\times ${texH}
+$$
+
+$$
+\\exp(${texA} + ${texH}) \\approx ${getAnswer(identifiers)}
+$$
+
+`;
+        case "a-h":
+            return `On souhaite utiliser la formule : 
+  
+$$
+\\exp(${texA} - ${texH}) \\approx \\exp(${texA}) - \\exp'(${texA}) \\times ${texH}
+$$
+
+Or : 
+
+$$
+\\exp'(${texA}) = \\exp(${texA}) \\approx ${expARounded.frenchify()}
+$$
+
+Ainsi :
+
+$$
+\\exp(${texA} - ${texH}) \\approx ${expARounded.frenchify()} - ${expARounded.frenchify()} \\times ${texH}
+$$
+
+$$
+\\exp(${texA} - ${texH}) \\approx ${getAnswer(identifiers)}
+$$
+
+`;
+        default:
+            throw new Error("Unsupported texAOpH: " + texAOpH);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIdsA, nodeIdsH, nodeIdsAOpH, expARounded } = identifiers;
+    const [nodeA, nodeH, nodeAOpH] = [nodeIdsA, nodeIdsH, nodeIdsAOpH].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const texAOpH = nodeAOpH.toTex();
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //exp(a)+exp(h)
+    {
+        const nodeWrong = round(add(expARounded, exp(nodeH)).evaluate(), precision).toTree();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //exp(a)-exp(h)
+    {
+        const nodeWrong = round(substract(expARounded, exp(nodeH)).evaluate(), precision).toTree();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //exp(a)^exp(h)
+    {
+        const nodeWrong = round(power(expARounded, exp(nodeH)).evaluate(), precision).toTree();
+        const tex = nodeWrong.toTex();
+        if (tex !== "NaN") {
+            tryToAddWrongProp(propositions, tex);
+        }
+    }
+    //terror: student uses exp(a) instead of given approx value
+    //+
+    //terror: student computes exp(a+h)
+    {
+        const arrNode = [
+            getAnswerNode(Object.assign({}, identifiers, {
+                expARounded: round(exp(nodeA).evaluate(), 13),
+            })),
+            (() => {
+                switch (texAOpH) {
+                    case "a+h":
+                        return round(exp(add(nodeA, nodeH)).evaluate(), precision).toTree();
+                    case "a-h":
+                        return round(exp(substract(nodeA, nodeH)).evaluate(), precision).toTree();
+                    default:
+                        throw new Error("Unsupported texAOpH: " + texAOpH);
+                }
+            })(),
+        ];
+        shuffle(arrNode).forEach((node) => {
+            const tex = node.toTex();
+            if (tex !== "NaN") {
+                tryToAddWrongProp(propositions, tex);
+            }
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const nodeAns = parseAlgebraic(ans);
+    const nodeAnswer = parseAlgebraic(answer);
+    return substract(nodeAns, nodeAnswer).evaluate() === 0;
+};
+const getApproxExpAPlusHQuestion = () => {
+    const nodeA = randfloat(0, 6, 2, [0]).toTree();
+    const expARounded = round(exp(nodeA).evaluate(), precision);
+    const nodeH = randfloat(0, 0.2, 3, [0]).toTree();
+    const nodeAOpH = parseAlgebraic(coinFlip() ? "a+h" : "a-h");
+    const identifiers = {
+        nodeIdsA: nodeA.toIdentifiers(),
+        nodeIdsH: nodeH.toIdentifiers(),
+        nodeIdsAOpH: nodeAOpH.toIdentifiers(),
+        expARounded,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+export const approxExpAPlusH = {
+    id: "approxExpAPlusH",
+    label: "Déterminer une valeur approchée de $\\exp(a+h)$ ou de $\\exp(a-h)$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getApproxExpAPlusHQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+};

package/lib/exercises/math/functions/exponential/definition/expAntecedentFromGraph.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    isExpPrime: boolean;
+    coordsFrame: number[];
+};
+export declare const expAntecedentFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=expAntecedentFromGraph.d.ts.map

package/lib/exercises/math/functions/exponential/definition/expAntecedentFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expAntecedentFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/definition/expAntecedentFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA4MF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}