math-exercises 3.0.93 → 3.0.95

package/lib/exercises/math/functions/variations/partialVarTableFromGraph.js

@@ -0,0 +1,198 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getFunc = (identifiers) => {
+    const { coeffs } = identifiers;
+    const poly = new Polynomial(coeffs);
+    return (x) => coeffs;
+};
+const getRoots = (coeffs) => {
+    const [d, c, b, a] = coeffs;
+    const sqrtDelta = 2 * Math.sqrt(b ** 2 - 3 * a * c);
+    const x1 = (-2 * b - sqrtDelta) / (6 * a);
+    const x2 = (-2 * b + sqrtDelta) / (6 * a);
+    return [x1, x2].sort((a, b) => a - b);
+};
+const getGGBOptions = (identifiers) => {
+    const { coeffs } = identifiers;
+    const poly = new Polynomial(coeffs);
+    const commands = [`f(x) =${poly.toMathString()}`];
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+    });
+    const [x1, x2] = getRoots(coeffs);
+    const fx1 = poly.calculate(x1);
+    const fx2 = poly.calculate(x2);
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: x1 - 2,
+            xMax: x2 + 2,
+            yMin: Math.min(fx1, fx2) - 2,
+            yMax: Math.max(fx1, fx2) + 2,
+        }),
+    });
+};
+const getFirstLine = (x1, x2) => {
+    return [
+        "$x$",
+        "-\\infty",
+        "\\ ",
+        x1.toTree().toTex(),
+        "\\ ",
+        x2.toTree().toTex(),
+        "\\ ",
+        "+\\infty",
+    ];
+};
+const getSecondsLines = (coeffs) => {
+    const [d, c, b, a] = coeffs;
+    const poly = new Polynomial(coeffs);
+    const [x1, x2] = getRoots(coeffs);
+    const fx1 = poly.calculate(x1);
+    const fx2 = poly.calculate(x2);
+    const vars = coeffs[3] > 0
+        ? ["\\nearrow", "\\searrow", "\\nearrow"]
+        : ["\\searrow", "\\nearrow", "\\searrow"];
+    return [
+        [
+            "$\\ $",
+            "\\ ",
+            "\\ ",
+            a > 0 ? fx1.toTree().toTex() : "\\ ",
+            "\\ ",
+            a > 0 ? "\\ " : fx1.toTree().toTex(),
+            "\\ ",
+            "\\ ",
+        ],
+        ["$f(x)$", "\\ ", vars[0], "\\ ", vars[1], "\\ ", vars[2], "\\ "],
+        [
+            "$\\ $",
+            "\\ ",
+            "\\ ",
+            a > 0 ? "\\ " : fx2.toTree().toTex(),
+            "\\ ",
+            a > 0 ? fx2.toTree().toTex() : "\\ ",
+            "\\ ",
+            "\\ ",
+        ],
+    ];
+};
+const getAnswerTable = (identifiers) => {
+    const { coeffs } = identifiers;
+    const [x1, x2] = getRoots(coeffs);
+    return [getFirstLine(x1, x2), ...getSecondsLines(coeffs)];
+};
+const getInstruction = (identifiers) => {
+    return `Dresser le tableau de variations de la fonction $f$ définie sur $\\mathbb{R}$ dont la courbe représentative est donnée ci-dessous :`;
+};
+const getHint = (identifiers) => {
+    return `La fonction est définie sur $\\mathbb{R}$, donc les valeurs de $x$ vont de $-\\infty$ à $+\\infty$.
+  
+Repère ensuite les points de la courbe auxquels le sens de variation change. Dans la première ligne du tableau, il faut mettre les abscisses de ces points, et dans la deuxième ligne, les ordonnées.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs } = identifiers;
+    const [d, c, b, a] = coeffs;
+    const poly = new Polynomial(coeffs);
+    const [x1, x2] = getRoots(coeffs);
+    const fx1 = poly.calculate(x1);
+    const fx2 = poly.calculate(x2);
+    const words = a > 0
+        ? ["croissante", "décroissante", "croissante"]
+        : ["décroissante", "croissante", "décroissante"];
+    return `D'après le graphique, la fonction $f$ est ${words[0]} sur $]-\\infty; ${x1}]$, puis ${words[1]} sur $[${x1}; ${x2}]$, puis ${words[2]} sur $[${x2}; +\\infty[$.
+
+De plus, on lit graphiquement que l'image de $${x1}$ est $${fx1}$, et celle de $${x2}$ est $${fx2}$.
+
+
+`;
+};
+const getKeys = (identifiers) => {
+    return ["infty"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return ans.every((row, i) => row.every((cell, j) => cell === answerTable[i][j]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+// const lists = [
+//   "x^3 - 3x",
+//   "x^3 -6x^2 + 9x",
+//   "-x^3 + 3x^2 + 9x",
+//   "2x^3 - 9x^2 + 12x",
+//   "-x^3+6x^2-9x",
+//   "4x^3 -24x^2 + 36x",
+// ];
+const poly3Coeffs = [
+    [0, -3, 0, 1],
+    [0, 9, -6, 1],
+    // [0, 9, 3, -1],
+    [0, 12, -9, 2],
+    [0, -9, 6, -1],
+    // [0, 36, -24, 4],
+];
+const getTestSignTableQuestion = (ops) => {
+    const index = randint(0, 4);
+    const lineAsked = randint(0, 2);
+    const coeffs = coinFlip()
+        ? poly3Coeffs[index]
+        : poly3Coeffs[index].map((x) => -x);
+    const finalCoeffs = [coeffs[0] + randint(-10, 10), ...coeffs.slice(1)];
+    const [x1, x2] = getRoots(finalCoeffs);
+    const initTable = [
+        lineAsked === 0
+            ? ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""]
+            : getFirstLine(x1, x2),
+    ];
+    if (lineAsked === 1) {
+        initTable.push(["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "], ["$f(x)$", "\\ ", "", "", "", "", "", "\\ "], ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "]);
+    }
+    else {
+        initTable.push(...getSecondsLines(finalCoeffs));
+    }
+    const identifiers = {
+        type: 0,
+        coeffs: finalCoeffs,
+        initTable,
+        lineAsked,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const partialVarTableFromGraph = {
+    id: "partialVarTableFromGraph",
+    label: "Compléter le tableau de variations d'une fonction à partir de sa représentation graphique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTestSignTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "varTable",
+    hasGeogebra: true,
+};

package/lib/exercises/math/functions/variations/varTableFromSentences.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=varTableFromSentences.d.ts.map

package/lib/exercises/math/functions/variations/varTableFromSentences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varTableFromSentences.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/varTableFromSentences.ts"],"names":[],"mappings":""}

package/lib/exercises/math/functions/variations/varTableFromSentences.js

@@ -0,0 +1,137 @@
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   GetAnswer,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetKeys,
+//   GetQuestionFromIdentifiers,
+//   GetAnswerTable,
+//   TableVEA,
+// } from "../../../../exercises/exercise.js";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+// import {
+//   NodeIdentifiers,
+//   reifyAlgebraic,
+// } from "../../../../tree/nodes/nodeConstructor.js";
+// import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+// import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+export {};
+// type Identifiers = {
+//   vars: string[];
+//   xs: NodeIdentifiers[];
+// };
+// /**
+//  *
+//  * xs
+//  * [-10, -4, 3, 10]
+//  * [f(-10), "\\nearrow", f(-4), "\\searrow", "f(3)", "\\nearrow", f(10)]
+//  */
+// const getAnswerTable: GetAnswerTable<Identifiers> = (identifiers) => {
+//   const { vars, xs } = identifiers;
+//   const xsNodes = xs.map((x) => reifyAlgebraic(x));
+//   const secondLine: string[][] = [[], [], []];
+//   for (let i = 0; i < vars.length; i++) {
+//     if (i % 2 === 0) {
+//       let row = 0;
+//       if (i === 0) {
+//         row = vars[1] === "\\nearrow" ? 2 : 0;
+//       } else {
+//         row = vars[i - 1] === "\\nearrow" ? 0 : 2;
+//       }
+//       secondLine[row].push(vars[i]);
+//       secondLine[2 - row].push("\\ ");
+//       secondLine[1].push("\\ ");
+//     } else {
+//       secondLine[1].push(vars[i]);
+//       secondLine[0].push("\\ ");
+//       secondLine[2].push("\\ ");
+//     }
+//   }
+//   return [
+//     ["$x$", ...xsNodes.join("\\ ")],
+//     ["$\\ $", ...secondLine[0]],
+//     ["$f(x)$", ...secondLine[1]],
+//     ["$\\ $", ...secondLine[2]],
+//   ];
+// };
+// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
+//     const { vars, xs } = identifiers;
+//   const xsNodes = xs.map((x) => reifyAlgebraic(x));
+//   return `La fonction $f$ est définie sur ...
+// Elle est croissante sur ...
+// Elle est décroissante sur ...
+// De plus, on a $f()=...$`;
+// };
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return `La première ligne d'un tableau de variations contient les valeurs de $x$. La deuxième ligne donne les variations de la fonction en fonction des valeurs de $x$ de la premiere ligne.`;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return ``;
+// };
+// const getKeys: GetKeys<Identifiers> = (identifiers) => {
+//   return [];
+// };
+// const isAnswerTableValid: TableVEA<Identifiers> = (ans, { answerTable }) => {
+//   try {
+//     return ans.every((row, i) =>
+//       row.every((cell, j) => cell === answerTable[i][j]),
+//     );
+//   } catch (err) {
+//     return handleVEAError(err);
+//   }
+// };
+// const getVarTableFromSentencesQuestion: QuestionGenerator<Identifiers> = (
+//   ops,
+// ) => {
+//   const x = randTupleInt(4, {allDifferent: true, from: -10, to: 11})
+//   const xs = x.sort((a,b)=>a-b);
+//   const sens = coinFlip()
+//   const vars = [];
+//   const identifiers: Identifiers = {
+//     xs: xs.map((e)=>e.toTree().toIdentifiers()),
+//     vars,
+//   };
+//   return getQuestionFromIdentifiers(identifiers);
+// };
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (
+//   identifiers,
+// ) => {
+//   return {
+//     answerTable: getAnswerTable(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: "tex",
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers),
+//   };
+// };
+// export const varTableFromSentences: Exercise<Identifiers> = {
+//   id: "varTableFromSentences",
+//   label:
+//     "Dresser le tableau de variations d'une fonction à partir de phrases descriptives",
+//   isSingleStep: true,
+//   generator: (nb, opts) =>
+//     getDistinctQuestions(() => getVarTableFromSentencesQuestion(opts), nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   isAnswerTableValid,
+//   subject: "Mathématiques",
+//   getInstruction,
+//   getHint,
+//   getCorrection,
+//   getAnswerTable,
+//   getQuestionFromIdentifiers,
+//   hasHintAndCorrection: true,
+//   answerType: "varTable",
+// };

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

@@ -9,4 +9,5 @@ export * from "./powersProduct.js";
 export * from "./scientificToDecimal.js";
 export * from "./powersMixOperations.js";
 export * from "./powersOfTenMixOperations.js";
+export * from "./powerNotation.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC"}

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

@@ -9,3 +9,4 @@ export * from "./powersProduct.js";
 export * from "./scientificToDecimal.js";
 export * from "./powersMixOperations.js";
 export * from "./powersOfTenMixOperations.js";
+export * from "./powerNotation.js";

package/lib/exercises/math/powers/powerNotation.d.ts

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

package/lib/exercises/math/powers/powerNotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powerNotation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powerNotation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAmIF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}

package/lib/exercises/math/powers/powerNotation.js

@@ -0,0 +1,126 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.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 { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { isPowerNode, 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 { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (nn, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { a, n } = identifiers;
+    // Soit 1/a^n
+    // (a+1)^n
+    tryToAddWrongProp(propositions, power(add(a, 1).simplify(), n).toTex());
+    // (a-1)^n
+    tryToAddWrongProp(propositions, power(substract(a, 1).simplify(), n).toTex());
+    // -a^n
+    tryToAddWrongProp(propositions, power(multiply(-1, a), n).toTex());
+    // -a^(-n)
+    tryToAddWrongProp(propositions, power(multiply(-1, a), multiply(-1, n)).toTex());
+    // a*-1^(-n)
+    tryToAddWrongProp(propositions, multiply(a, power(-1, multiply(-1, n))).toTex());
+    // n^a
+    tryToAddWrongProp(propositions, power(n, a).toTex());
+    // -n^a
+    tryToAddWrongProp(propositions, power(multiply(-1, n), a).toTex());
+    // n^(-a)
+    tryToAddWrongProp(propositions, power(n, multiply(-1, a)).toTex());
+    return shuffleProps(propositions, nn);
+};
+const getAnswer = (identifiers) => {
+    // (1/a^n) <=> a^(-n)
+    const { a, n } = identifiers;
+    return `${power(a, multiply(-1, n)).toTex()}`;
+};
+const getInstruction = (identifiers) => {
+    const { a, n, isSimplified } = identifiers;
+    const an = power(a, n);
+    const fraction = frac(1, isSimplified ? an.evaluate() : an);
+    return `Écrire $${fraction.toTex()}$ sous la forme $a^n$, avec $n \\in \\mathbb{Z}.$`;
+};
+const getHint = (identifiers) => {
+    const fracForm = frac(1, power("a", "n")).toTex();
+    return `On a : 
+  
+$$
+${fracForm} = ${power("a", multiply(-1, "n")).toTex()}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, n, isSimplified } = identifiers;
+    const fraction = frac(1, power(a, n));
+    const fracForm = frac(1, power("a", "n")).toTex();
+    return `On sait que : 
+  
+$$
+${fracForm} = ${power("a", multiply(-1, "n")).toTex()}
+$$
+
+Ici on a donc :
+
+$$
+${fraction.toTex()} = ${power(a, multiply(-1, n)).toTex()}
+$$
+
+avec $a = ${a}$ et $n = ${n}$${isSimplified
+        ? `, sachant que $${power(a, n).evaluate()} = ${power(a, n).toTex()}$`
+        : ""}.`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { a, n } = identifiers;
+    const node = parseAlgebraic(ans);
+    try {
+        return (isPowerNode(node) &&
+            node.simplify().equals(power(a, multiply(-1, n)).simplify()));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPowerNotationQuestion = (ops) => {
+    const isSimplePower = (a, n) => {
+        return (n === 2 && a <= 11) || (n === 3 && a <= 3);
+    };
+    const a = randint(2, 12);
+    const n = randint(2, 5);
+    const isSimplified = isSimplePower(a, n) ? coinFlip() : false;
+    const identifiers = { a, n, isSimplified };
+    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 powerNotation = {
+    id: "powerNotation",
+    label: "Écrire une fraction sous la forme $a^n$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPowerNotationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: false,
+};

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

@@ -2,4 +2,5 @@ export * from "./intervals/index.js";
 export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
 export * from "./subsetsOfKnownSets.js";
+export * from "./isNumberDecimal.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC"}

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

@@ -2,3 +2,4 @@ export * from "./intervals/index.js";
 export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
 export * from "./subsetsOfKnownSets.js";
+export * from "./isNumberDecimal.js";

package/lib/exercises/math/sets/isNumberDecimal.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    options: {
+        a: NodeIdentifiers;
+        isDecimal: boolean;
+    }[];
+};
+export declare const isNumberdecimal: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isNumberDecimal.d.ts.map

package/lib/exercises/math/sets/isNumberDecimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNumberDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/isNumberDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE;QACP,CAAC,EAAE,eAAe,CAAC;QACnB,SAAS,EAAE,OAAO,CAAC;KACpB,EAAE,CAAC;CACL,CAAC;AAqIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}