math-exercises 3.0.157 → 3.0.159

package/lib/exercises/math/derivation/derivativeNumber/averageRateOfChangeFromImages.js

@@ -0,0 +1,116 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductible().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, bIds, faIds, fbIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fa = reifyAlgebraic(faIds);
+    const fb = reifyAlgebraic(fbIds);
+    return frac(substract(fb, fa), substract(b, a)).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds, faIds, fbIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fa = reifyAlgebraic(faIds);
+    const fb = reifyAlgebraic(fbIds);
+    return `On considère une fonction $f$ définie sur $\\mathbb{R}$, telle que $f(${a.toTex()}) = ${fa.toTex()}$ et $f(${b.toTex()}) = ${fb.toTex()}$. 
+  
+Calculer le taux d'accroissement de $f$ entre $${a.toTex()}$ et $${b.toTex()}$.
+`;
+};
+const getHint = () => {
+    return `Le taux d'accroissement d'une fonction $f$ entre deux nombres réels $a$ et $b$ est égal à : 
+  
+$$
+\\frac{f(b)-f(a)}{b-a}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, faIds, fbIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fa = reifyAlgebraic(faIds);
+    const fb = reifyAlgebraic(fbIds);
+    return `Le taux d'accroissement de $f$ entre $${a.toTex()}$ et $${b.toTex()}$ vaut : 
+  
+${alignTex([
+        ["", `\\frac{f(${b.toTex()})-f(${a.toTex()})}{${substract(b, a).toTex()}}`],
+        ["=", frac(substract(fb, fa), substract(b, a).simplify()).toTex()],
+        [
+            "=",
+            frac(substract(fb, fa).simplify(), substract(b, a).simplify()).toSimplificationTex(),
+        ],
+    ])}`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getAverageRateOfChangeFromImagesQuestion = () => {
+    let a = randint(-10, 10);
+    let b = randint(-10, 10, [a]);
+    if (a > b)
+        [a, b] = [b, a];
+    const fa = randint(-10, 10);
+    const fb = randint(-10, 10);
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        bIds: b.toTree().toIdentifiers(),
+        faIds: fa.toTree().toIdentifiers(),
+        fbIds: fb.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const averageRateOfChangeFromImages = {
+    id: "averageRateOfChangeFromImages",
+    connector: "=",
+    label: "Calculer le taux d'accroissement d'une fonction entre $a$ et $b$, avec $f(a)$ et $f(b)$ données",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAverageRateOfChangeFromImagesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivativeNumber/derivativeNumberCalcul.d.ts

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

package/lib/exercises/math/derivation/derivativeNumber/derivativeNumberCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeNumberCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/derivativeNumberCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/derivation/derivativeNumber/derivativeNumberCalcul.js

@@ -0,0 +1,142 @@
+import { shuffleProps, addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHint = (identifiers) => {
+    const { x } = identifiers;
+    return `Pour calculer $f'(${x})$, il faut d'abord calculer le taux d'accroissement de $f$ entre $${x}$ et $${x}+h$, pour $h>0$. Ce taux est égal à :
+
+$$
+\\frac{f(${x}+h)-f(${x})}{h}
+$$
+
+Calcule donc d'abord $f(${x})$, et $f(${x}+h)$ en fonction de $h$.
+
+Puis, détermine la limite de ce nombre lorsque $h$ se rapproche de $0$. 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs, x } = identifiers;
+    const trinom = new Polynomial(coeffs).toTree();
+    const fx = trinom.toDetailedEvaluation({ x: x.toTree() });
+    const fxSimp = fx.simplify();
+    const fxh = trinom.toDetailedEvaluation({ x: add(x, "h") });
+    const fxhSimp = fxh.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const answer = getAnswer(identifiers);
+    return `Pour calculer $f'(${x})$, il faut d'abord calculer le taux d'accroissement de $f$ entre $${x}$ et $${x}+h$, pour $h>0$. Ce taux est égal à :
+
+$$
+\\frac{f(${x}+h)-f(${x})}{h}
+$$
+
+On calcule donc $f(${x})$ :
+
+${alignTex([
+        [`f(${x})`, "=", fx.toTex()],
+        ["", "=", fxSimp.toTex()],
+    ])}
+
+Puis $f(${x}+h)$ :
+
+${alignTex([
+        [`f(${x}+h)`, "=", fxh.toTex()],
+        ["", "=", fxhSimp.toTex()],
+    ])}
+
+Le taux d'accroissement vaut donc : 
+
+${alignTex([
+        [
+            frac(substract(`f(${x}+h)`, `f(${x})`), `h`).toTex(),
+            "=",
+            frac(substract(fxhSimp, fxSimp).simplify({ forbidFactorize: true }), "h").toTex(),
+        ],
+        [
+            "",
+            "=",
+            frac(substract(fxhSimp, fxSimp), "h")
+                .simplify({ forbidFactorize: true, forceDistributeFractions: true })
+                .toTex(),
+        ],
+    ])}
+
+Lorsque $h$ tend vers $0$, ce nombre se rapproche donc de $${answer}$. 
+La limite du taux d'accroissement en $0$ est donc $${answer}$. 
+
+Le nombre dérivé $f'(${x})$ vaut donc $${answer}$.
+`;
+};
+const getInstruction = (identifiers) => {
+    const trinom = new Polynomial(identifiers.coeffs);
+    const instruction = `Soit $f$ la fonction définie par : 
+  
+$$
+f(x) = ${trinom.toTree().toTex()}
+$$
+
+En revenant à la définition du nombre dérivé, calculer $f'(${identifiers.x})$.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const trinom = new Polynomial(identifiers.coeffs);
+    const answer = trinom.derivate().calculate(identifiers.x) + "";
+    return answer;
+};
+const getDerivativeNumberCalculQuestion = () => {
+    const x = randint(-9, 10);
+    const trinom = PolynomialConstructor.randomWithOrder(2);
+    const identifiers = { x, coeffs: trinom.coefficients };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const wrongAnswer = randint(-20, 20) + "";
+        tryToAddWrongProp(propositions, wrongAnswer);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const derivativeNumberCalcul = {
+    id: "derivativeNumberCalcul",
+    connector: "=",
+    label: "Calculer un nombre dérivé via la définition",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getDerivativeNumberCalculQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,4 @@
+export * from "./derivativeNumberCalcul.js";
+export * from "./averageRateOfChangeFromImages.js";
+export * from "./averageRateOfChangeFromAlgebraic.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC"}

package/lib/exercises/math/derivation/derivativeNumber/index.js

@@ -0,0 +1,4 @@
+export * from "./derivativeNumberCalcul.js";
+export * from "./averageRateOfChangeFromImages.js";
+export * from "./averageRateOfChangeFromAlgebraic.js";
+// export * from "./averageRateOfChangeAlgebraicExpression.js";

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

@@ -1,5 +1,5 @@
 export * from "./derivative/index.js";
-export * from "./derivativeNumberCalcul.js";
+export * from "./derivativeNumber/index.js";
 export * from "./tangent/index.js";
 export * from "./variations/index.js";
 export * from "./convexity/index.js";

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

@@ -1,5 +1,5 @@
 export * from "./derivative/index.js";
-export * from "./derivativeNumberCalcul.js";
+export * from "./derivativeNumber/index.js";
 export * from "./tangent/index.js";
 export * from "./variations/index.js";
 export * from "./convexity/index.js";

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

@@ -1,4 +1,5 @@
 export * from "./thirdDegreeFunctionVariation.js";
 export * from "./thirdDegreeDerivativeVariation.js";
 export * from "./variationArrowAmount.js";
+export * from "./readExtremaAbscissFromDerivativeCurve.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4CAA4C,CAAC"}

package/lib/exercises/math/derivation/variations/index.js

@@ -1,3 +1,4 @@
 export * from "./thirdDegreeFunctionVariation.js";
 export * from "./thirdDegreeDerivativeVariation.js";
 export * from "./variationArrowAmount.js";
+export * from "./readExtremaAbscissFromDerivativeCurve.js";

package/lib/exercises/math/derivation/variations/readExtremaAbscissFromDerivativeCurve.d.ts

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

package/lib/exercises/math/derivation/variations/readExtremaAbscissFromDerivativeCurve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readExtremaAbscissFromDerivativeCurve.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/readExtremaAbscissFromDerivativeCurve.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B,CAAC;AAuKF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAwBvE,CAAC"}

package/lib/exercises/math/derivation/variations/readExtremaAbscissFromDerivativeCurve.js

@@ -0,0 +1,174 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randomColor } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+import { valueParser } from "../../../../tree/parsers/valueParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const nbs = randTupleInt(randint(1, 4), {
+            allDifferent: true,
+            from: -10,
+            to: 10,
+        });
+        nbs.sort((a, b) => a - b);
+        tryToAddWrongProp(propositions, nbs.map((e) => e.frenchify()).join("\\text{ et }"));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { splinePoints } = identifiers;
+    const valids = splinePoints.filter((e) => e[1] === 0).map((e) => e[0]);
+    return valids.map((e) => e.frenchify()).join("\\text{ et }");
+};
+const getInstruction = () => {
+    return `Ci-dessous est donnée la courbe représentative de la fonction dérivée $f'$ d'une fonction $f$. 
+  
+Quelles sont les abscisses des extremum locaux de $f$ ?`;
+};
+const getHint = () => {
+    return `$x$ est un extremum local d'une fonction dérivable $f$ si et seulement si la fonction dérivée s'annule et change de signe en $x$.`;
+};
+const getCorrection = (identifiers) => {
+    const { splinePoints } = identifiers;
+    const valids = splinePoints.filter((e) => e[1] === 0).map((e) => e[0]);
+    return `On lit graphiquement que la fonction $f'$ s'annule en changeant de signe pour $x$ valant ${valids
+        .map((e) => dollarize(e.frenchify()))
+        .join(", ou ")}.
+  
+Ce sont donc les abscisses des extremum locaux de $f$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { splinePoints } = identifiers;
+    const xMin = Math.min(...splinePoints.map((point) => point[0]));
+    const yMin = Math.min(...splinePoints.map((point) => point[1]));
+    const xMax = Math.max(...splinePoints.map((point) => point[0]));
+    const yMax = Math.max(...splinePoints.map((point) => point[1]));
+    const commands = [
+        `S = Spline(${splinePoints
+            .map((point) => `(${point[0]},${point[1]})`)
+            .join(",")})`,
+        "SetFixed(S, true, false)",
+        `SetColor(S, "${randomColor()}")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+const getKeys = () => {
+    return ["et"];
+};
+const isAnswerValid = (ans, { answer: _answer, splinePoints }) => {
+    try {
+        const validPoints = splinePoints.filter((p) => p[1] === 0);
+        const ansElements = ans.split("\\text{ et }");
+        if (validPoints.length !== ansElements.length)
+            return false;
+        const sorted = [];
+        for (const el of ansElements) {
+            const parsed = valueParser(el);
+            if (parsed === false)
+                return false;
+            sorted.push(parsed);
+        }
+        sorted.sort((a, b) => a - b);
+        for (let i = 0; i < sorted.length; i++) {
+            const validPointX = validPoints[i][0];
+            if (Math.abs(sorted[i] - validPointX) > 0.4)
+                return false;
+        }
+        return true;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getReadExtremaAbscissFromDerivativeCurveQuestion = (opts) => {
+    const xSolutions = [];
+    const nb = randint(2, 4);
+    // const nb = 2;
+    for (let i = 0; i < nb; i++) {
+        xSolutions.push(randint(-9, 10, xSolutions));
+    }
+    xSolutions.sort((a, b) => a - b);
+    const yValue = 0;
+    const splinePoints = [];
+    let prevYWasAbove = coinFlip();
+    const y = prevYWasAbove ? randint(-2, 0) : randint(1, 3);
+    prevYWasAbove = y > 0;
+    splinePoints.push([xSolutions[0] - (1 + Math.random() * 3), yValue + y]);
+    for (let i = 0; i < xSolutions.length; i++) {
+        splinePoints.push([xSolutions[i], yValue]);
+        if (i < xSolutions.length - 1) {
+            const mid = (xSolutions[i] + xSolutions[i + 1]) / 2;
+            const distance = xSolutions[i + 1] - xSolutions[i];
+            const x = mid + ((Math.random() * 2) / 5) * (distance / 2);
+            const y = prevYWasAbove ? randint(-2, 0) : randint(1, 3);
+            prevYWasAbove = y > 0;
+            splinePoints.push([x, yValue + y]);
+        }
+    }
+    const y2 = prevYWasAbove ? randint(-2, 0) : randint(1, 3);
+    prevYWasAbove = y2 > 0;
+    splinePoints.push([
+        xSolutions[xSolutions.length - 1] + (1 + Math.random() * 3),
+        yValue + y2,
+    ]);
+    const identifiers = { splinePoints };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+// const options: GeneratorOption[] = [
+//   {
+//     id: "curveTypes",
+//     label: "Types de courbes",
+//     target: GeneratorOptionTarget.generation,
+//     type: GeneratorOptionType.multiselect,
+//     defaultValue: ["Tracés"],
+//     values: [
+//       "Tracés",
+//       "Droites",
+//       "Paraboles",
+//     ],
+//   },
+// ];
+export const readExtremaAbscissFromDerivativeCurve = {
+    id: "readExtremaAbscissFromDerivativeCurve",
+    connector: "=",
+    label: "Lire les abscisses des extremums locaux d'une fonction sur la courbe de sa dérivée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getReadExtremaAbscissFromDerivativeCurveQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/exponential/algebraic/approxExpAPlusB.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsA: NodeIdentifiers;
+    nodeIdsB: NodeIdentifiers;
+    nodeIdsAOpB: NodeIdentifiers;
+    expARounded: number;
+    expBRounded: number;
+    precision: number;
+};
+export declare const approxExpAPlusB: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=approxExpAPlusB.d.ts.map

package/lib/exercises/math/functions/exponential/algebraic/approxExpAPlusB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approxExpAPlusB.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/algebraic/approxExpAPlusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,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;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAmXF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}