math-exercises 3.0.190 → 3.0.191

package/lib/exercises/math/functions/affines/affineVariationsFromTwoImages.js

@@ -0,0 +1,259 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const createRandomNode = (numberType) => {
+    switch (numberType) {
+        case "Décimal":
+            return coinFlip()
+                ? randfloat(-100, 0, randint(1, 7), [0]).toTree()
+                : randfloat(1, 100, randint(1, 7), [1]).toTree();
+        case "Fraction": {
+            if (probaFlip(0.7)) {
+                const num = coinFlip()
+                    ? randint(10_000, 20_000)
+                    : randint(-20_000, -10_000);
+                const den = randint(1, abs(num).evaluate());
+                return frac(num, den);
+            }
+            else {
+                const num = coinFlip()
+                    ? randfloat(1, 200, randint(1, 3), [1])
+                    : randfloat(-200, -1, randint(1, 3));
+                const den = randfloat(1, abs(num).evaluate(), randint(1, 3));
+                return frac(num, den);
+            }
+        }
+        case "Réel":
+            return random([
+                PiNode,
+                frac(PiNode, randint(2, 4)),
+                sqrt(randfloat(1, 100, randint(1, 5), [1])),
+            ]);
+        case "Entier":
+        default:
+            return randint(-100, 100).toTree();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { pointIds } = identifiers;
+    const [point1, point2] = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    return `Soit $f$ une fonction affine telle que : 
+
+${alignTex([point1, point2].map((point) => [
+        `f(${point.x.toTex()})`,
+        "=",
+        point.y.toTex(),
+    ]))}
+
+Quel est le sens de variations de $f$ sur $\\mathbb{R}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { pointIds } = identifiers;
+    const [point1, point2] = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    if (NodeComparator.isEqualViaSub(point1.y, point2.y)) {
+        return "Constante";
+    }
+    else {
+        const [pointXSmall, pointXBig] = [point1, point2].toSorted((point1, point2) => point1.x.evaluate() - point2.x.evaluate());
+        return NodeComparator.compareViaSub(pointXSmall.y, pointXBig.y) === -1
+            ? "Strictement croissante"
+            : "Strictement décroissante";
+    }
+};
+const getHint = () => {
+    return `Soit $f$ une fonction affine et $x_{1}$ et $x_{2}$ deux réels distincts tels que :
+  
+$$
+x_{1}<x_{2}
+$$
+
+La fonction $f$ est 
+
+- strictement croissante si :
+
+$$
+f(x_{1})<f(x_{2})
+$$
+
+- strictement décroissante si :
+
+$$
+f(x_{1})>f(x_{2})
+$$
+
+- constante si :
+
+$$
+f(x_{1})=f(x_{2})
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { pointIds } = identifiers;
+    const [point1, point2] = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    if (NodeComparator.isEqualViaSub(point1.y, point2.y)) {
+        return `On a :
+    
+$$
+f(${point1.x.toTex()}) = f(${point2.x.toTex()}) = ${point1.y.toTex()}
+$$
+
+La fonction $f$ est donc constante sur $\\mathbb{R}$.`;
+    }
+    else {
+        const [pointXSmall, pointXBig] = [point1, point2].toSorted((point1, point2) => point1.x.evaluate() - point2.x.evaluate());
+        const valueComp = NodeComparator.compareViaSub(pointXSmall.y, pointXBig.y);
+        if (valueComp === -1) {
+            return `On a :
+
+$$
+${pointXSmall.x.toTex()} < ${pointXBig.x.toTex()}
+$$
+
+et
+
+$$
+${pointXSmall.y.toTex()} < ${pointXBig.y.toTex()}
+$$
+
+donc 
+
+$$
+f(${pointXSmall.x.toTex()}) < f(${pointXBig.x.toTex()})
+$$
+  
+
+La fonction $f$ est donc ${getAnswer(identifiers).toLocaleLowerCase()} sur $\\mathbb{R}$.`;
+        }
+        else {
+            return `On a :
+
+$$
+${pointXSmall.x.toTex()} < ${pointXBig.x.toTex()}
+$$
+
+et
+
+$$
+${pointXSmall.y.toTex()} > ${pointXBig.y.toTex()}
+$$
+
+donc 
+
+$$
+f(${pointXSmall.x.toTex()}) > f(${pointXBig.x.toTex()})
+$$
+  
+
+La fonction $f$ est donc ${getAnswer(identifiers).toLocaleLowerCase()} sur $\\mathbb{R}$.`;
+        }
+    }
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Strictement croissante", "raw");
+    tryToAddWrongProp(propositions, "Strictement décroissante", "raw");
+    tryToAddWrongProp(propositions, "Constante", "raw");
+    tryToAddWrongProp(propositions, "Non monotone", "raw");
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const getAffineVariationsFromTwoImagesQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const typeX1 = random(arrayedOptions.typeX);
+    const typeX2 = random(arrayedOptions.typeX);
+    const typeY1 = random(arrayedOptions.typeY);
+    const typeY2 = random(arrayedOptions.typeY);
+    const nodeX1 = createRandomNode(typeX1);
+    const nodeX2 = (() => {
+        let nodeCandidate;
+        do {
+            nodeCandidate = createRandomNode(typeX2);
+        } while (NodeComparator.isEqualViaSub(nodeCandidate, nodeX1));
+        return nodeCandidate;
+    })();
+    const nodeY1 = createRandomNode(typeY1);
+    const nodeY2 = probaFlip(0.9) ? createRandomNode(typeY2) : nodeY1;
+    const point1 = new Point("P1", nodeX1, nodeY1);
+    const point2 = new Point("P2", nodeX2, nodeY2);
+    const identifiers = {
+        pointIds: [point1, point2].map((point) => point.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const optsDefault = {
+    typeX: ["Entier", "Décimal"],
+    typeY: ["Entier", "Décimal"],
+};
+const options = [
+    {
+        id: "typeX",
+        label: "Types de nombres pour les antécédents",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entier", "Décimal", "Fraction", "Réel"],
+        defaultValue: optsDefault.typeX,
+    },
+    {
+        id: "typeY",
+        label: "Types de nombres pour les images",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entier", "Décimal", "Fraction", "Réel"],
+        defaultValue: optsDefault.typeY,
+    },
+];
+export const affineVariationsFromTwoImages = {
+    id: "affineVariationsFromTwoImages",
+    label: "Déterminer le sens de variations d'une fonction affine à partir des images de deux réels",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAffineVariationsFromTwoImagesQuestion(opts), nb),
+    options,
+    validateOptions: (opts) => {
+        return {
+            valid: !!(opts?.typeX &&
+                opts?.typeX.length > 0 &&
+                opts?.typeY &&
+                opts?.typeY.length > 0),
+            message: "Veuillez choisir au moins un type de nombre pour les antécédents et un type de nombre pour les images'.",
+        };
+    },
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/functions/exponentials/exponentialFunctionImage.d.ts

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

package/lib/exercises/math/functions/exponentials/exponentialFunctionImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialFunctionImage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/exponentialFunctionImage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA2FF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAmB1D,CAAC"}

package/lib/exercises/math/functions/exponentials/exponentialFunctionImage.js

@@ -0,0 +1,99 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(0.1, 5, 2).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, xIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    return round(power(a, x).simplify({ calculatePowers: true }).evaluate(), 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, xIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    return `Soit $f$ la fonction définie sur $[0; +\\infty[$ par : 
+  
+$$
+f(x) = ${power(a, "x").toTex()}
+$$
+
+Calculer $f\\left(${x.toTex()}\\right)$ (donner une valeur arrondie au centième).`;
+};
+const getHint = (identifiers) => {
+    const { xIds } = identifiers;
+    const x = reifyAlgebraic(xIds);
+    return `Utilise la calculatrice, et remplace $x$ par $${x.toTex()}$ dans l'expression de la fonction.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, xIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    return `On remplace $x$ par $${x.toTex()}$ dans l'expression de la fonction, puis on utilise la calculatrice :
+  
+$$
+f(${x.toTex()}) = ${power(a, x).toTex()} ${approxOrEqual(power(a, x).evaluate(), 2).join("")}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer, 2);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getExponentialFunctionImageQuestion = () => {
+    const aIds = randfloat(0.1, 5, 2).toTree().toIdentifiers();
+    const xIds = randfloat(0.1, 5, 2).toTree().toIdentifiers();
+    const identifiers = {
+        aIds,
+        xIds,
+    };
+    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 exponentialFunctionImage = {
+    id: "exponentialFunctionImage",
+    connector: "=",
+    label: "Calculer l'image d'un nombre par une fonction exponentielle du type $a^x$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExponentialFunctionImageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -2,4 +2,9 @@ export * from "./exponentialsVariations.js";
 export * from "./exponentialsRawVariations.js";
 export * from "./readExponentialFunctionParamsOnGraph.js";
 export * from "./plausibleExponentialFunctionExpressionFromGraph.js";
+export * from "./exponentialFunctionImage.js";
+export * from "./realPowersProduct.js";
+export * from "./realPowersFraction.js";
+export * from "./realPowersPower.js";
+export * from "./realPowersMixOperations.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,sDAAsD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2CAA2C,CAAC;AAC1D,cAAc,sDAAsD,CAAC;AAErE,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC"}

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

@@ -3,3 +3,8 @@ export * from "./exponentialsRawVariations.js";
 export * from "./readExponentialFunctionParamsOnGraph.js";
 export * from "./plausibleExponentialFunctionExpressionFromGraph.js";
 // export * from "./estimateExponentialFunctionImageFromGeometricScatterplot.js";
+export * from "./exponentialFunctionImage.js";
+export * from "./realPowersProduct.js";
+export * from "./realPowersFraction.js";
+export * from "./realPowersPower.js";
+export * from "./realPowersMixOperations.js";

package/lib/exercises/math/functions/exponentials/realPowersFraction.d.ts

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

package/lib/exercises/math/functions/exponentials/realPowersFraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realPowersFraction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/realPowersFraction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAoHF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

package/lib/exercises/math/functions/exponentials/realPowersFraction.js

@@ -0,0 +1,125 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { isInt } from "../../../../utils/isInt.js";
+const getPropositions = (n, { answer, aIds, xIds, yIds }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    tryToAddWrongProp(propositions, power(a, add(x, y)).simplify().toTex());
+    tryToAddWrongProp(propositions, power(a, multiply(x, y)).simplify().toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, power(a, randfloat(0.1, 5, 1)).simplify().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return power(a, substract(x, y)).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return `Écrire sous la forme d'une seule puissance : 
+  
+$$
+${frac(power(a, x), power(a, y)).toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Utilise la propriété suivante : pour tous nombres réels positifs $x$ et $y$ et pour tout nombre réel $a>0$, on a : 
+  
+$$
+\\frac{a^x}{a^y}= a^{x-y}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, xIds, yIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const x = reifyAlgebraic(xIds);
+    const y = reifyAlgebraic(yIds);
+    return `Pour tous nombres réels positifs $x$ et $y$ et pour tout nombre réel $a>0$, on a : 
+    
+$$
+\\frac{a^x}{a^y}= a^{x-y}
+$$
+  
+Ici, on a donc : 
+
+$$
+${frac(power(a, x), power(a, y)).toTex()} = ${power(a, substract(x, y)).toTex()} = ${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify({ forbidPowerDivision: true }).toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRealPowersFractionQuestion = () => {
+    const a = randfloat(0.1, 5, 1, [1]);
+    let x = doWhile(() => randfloat(0.1, 5, 1), (v) => isInt(v));
+    let y = randfloat(0.1, 5, 1);
+    if (coinFlip())
+        [x, y] = [y, x]; //comme ca l'éventuel entier est n'importe ou
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        xIds: x.toTree().toIdentifiers(),
+        yIds: y.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 realPowersFraction = {
+    id: "realPowersFraction",
+    connector: "=",
+    label: "Simplifier une division de puissances réelles",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRealPowersFractionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/exponentials/realPowersMixOperations.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    xIds: NodeIdentifiers;
+    yIds: NodeIdentifiers;
+    zIds: NodeIdentifiers;
+    tIds: NodeIdentifiers;
+};
+export declare const realPowersMixOperations: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=realPowersMixOperations.d.ts.map

package/lib/exercises/math/functions/exponentials/realPowersMixOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realPowersMixOperations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponentials/realPowersMixOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAwIF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAkBzD,CAAC"}