math-exercises 3.0.199 → 3.0.200

package/lib/exercises/math/combinatory/combination/mentalCalculateCombination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mentalCalculateCombination.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/combinatory/combination/mentalCalculateCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA8OF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAgBF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBrE,CAAC"}

package/lib/exercises/math/combinatory/combination/mentalCalculateCombination.js

@@ -0,0 +1,225 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { facto } from "../../../../tree/nodes/functions/factorialNode.js";
+import { binom } from "../../../../tree/nodes/operators/binomialCoefficientNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { statementFormulaType } = opts;
+    const { total, picked } = identifiers;
+    const texFormula = (() => {
+        switch (statementFormulaType) {
+            case "$\\binom{n}{k}$":
+                return binom(total, picked).toTex();
+            case "$\\frac{n!}{k!(n-k)!}$":
+                return binom(total, picked).toFormulaWithFactoFractionNode().toTex();
+            default:
+                throw new Error("Unsupported statementFormulaType:" + statementFormulaType);
+        }
+    })();
+    return `Sans calculatrice, et en utilisant des simplifications, calculer : 
+  
+$$
+${texFormula}
+$$`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { total, picked } = identifiers;
+    const nodeBinom = binom(total, picked);
+    const nodeFormulaRaw = nodeBinom.toFormulaWithFactoFractionNode();
+    const nodeAnswer = nodeBinom.toFormulaWithoutFacto();
+    return { nodeBinom, nodeFormulaRaw, nodeAnswer };
+};
+const getAnswer = (identifiers) => {
+    return getAnswerStuff(identifiers)
+        .nodeAnswer.simplify({
+        towardsDistribute: true,
+    })
+        .toTex();
+};
+const getHint = (identifiers) => {
+    const { total, picked } = identifiers;
+    const { nodeBinom, nodeFormulaRaw } = getAnswerStuff(identifiers);
+    return `Voici la formule pour $${picked}$ parmi $${total}$: 
+
+$$
+${nodeBinom.toTex()} = ${nodeFormulaRaw.toTex()}
+$$
+
+Voici les produits qui correspondent à chaque factorielle :
+
+${alignTex([facto(total), facto(picked), facto(total - picked)].flatMap((nodeFacto) => {
+        const texExpanded = nodeFacto
+            .toMultiplyNode()
+            .toTex({ forceNoSimplification: true, forceTimesSign: true });
+        const arrTexFactor = texExpanded.split("\\times");
+        const arrArrTexFactor = arrTexFactor.reduce((acc, texFactor, i, arr) => {
+            acc.running.push(texFactor);
+            if (acc.running.length >= 4 || i === arr.length - 1) {
+                acc.chunks.push(acc.running);
+                acc.running = [];
+            }
+            return acc;
+        }, {
+            chunks: [],
+            running: [],
+        }).chunks;
+        return arrArrTexFactor.map((arrTexFactor, i) => {
+            const texChunk = arrTexFactor.join(" \\times ");
+            if (i === 0) {
+                return [nodeFacto.toTex(), "= \\ \\ \\ ", texChunk];
+            }
+            else {
+                return [" ", "\\ \\ \\ \\times", texChunk];
+            }
+        });
+    }))}
+
+Remplace chaque factorielle par le produit qui lui correspond puis simplifie quand le même terme apparaît au numérateur et au dénominateur.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { total, picked } = identifiers;
+    const { nodeBinom, nodeFormulaRaw, nodeAnswer } = getAnswerStuff(identifiers);
+    const nodeFracFacto = frac(facto(total), facto(picked));
+    const nodeNum = nodeAnswer.leftChild;
+    return `Voici la formule pour $${picked}$ parmi $${total}$: 
+
+$$
+${nodeBinom.toTex()} = ${nodeFormulaRaw.toTex()}
+$$
+
+Or : 
+
+$$
+${nodeFracFacto.toTex()} = ${nodeNum.toTex()}
+$$
+
+Donc: 
+
+${alignTex([
+        [
+            nodeFormulaRaw.toTex(),
+            "=",
+            nodeAnswer.toTex({ forceTimesSign: true, forceNoSimplification: true }),
+        ],
+        ["", "=", nodeAnswer.simplify({ towardsDistribute: true }).toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { total, picked } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    function checkAndTryToAddNode(node) {
+        const value = node.evaluate();
+        if (0.01 <= value && value <= 220) {
+            tryToAddWrongProp(propositions, node.simplify({ towardsDistribute: true }).toTex());
+        }
+    }
+    //student: total!/(total-picked)!
+    {
+        const node = frac(facto(total), facto(substract(total, picked)));
+        checkAndTryToAddNode(node);
+    }
+    //student: total!/picked!
+    {
+        const node = frac(facto(total), facto(picked));
+        checkAndTryToAddNode(node);
+    }
+    //student: picked!/total!
+    {
+        const node = frac(facto(total), facto(picked));
+        checkAndTryToAddNode(node);
+    }
+    //student: forgets factorial somewhere
+    {
+        {
+            const node = frac(facto(total), multiply(picked, facto(substract(total, picked))));
+            checkAndTryToAddNode(node);
+        }
+        {
+            const node = frac(facto(picked), multiply(total, facto(substract(total, picked))));
+            checkAndTryToAddNode(node);
+        }
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const total = randint(5, 13);
+    const nbFactors = randint(2, 4);
+    const picked = coinFlip() ? nbFactors : total - nbFactors;
+    return {
+        total,
+        picked,
+    };
+};
+const getMentalCalculateCombinationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    statementFormulaType: "$\\binom{n}{k}$",
+};
+const options = [
+    {
+        id: "statementFormulaType",
+        label: "Type de formule dans l'énoncé",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["$\\binom{n}{k}$", "$\\frac{n!}{k!(n-k)!}$"],
+        defaultValue: optsDefault.statementFormulaType,
+    },
+];
+export const mentalCalculateCombination = {
+    id: "mentalCalculateCombination",
+    connector: "=",
+    label: "Calculer une combinaison sans calculatrice",
+    isSingleStep: true,
+    generator: (nb, opts) => [...Array(nb).keys()].map(() => getMentalCalculateCombinationQuestion(opts)),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: false,
+};

package/lib/exercises/math/combinatory/combination/writeCombinationFormulaUsingFactorial.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsTotal: NodeIdentifiers;
+    nodeIdsPicked: NodeIdentifiers;
+    operandType: string;
+};
+type Options = {
+    operandType: string;
+};
+export declare const writeCombinationFormulaUsingFactorial: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=writeCombinationFormulaUsingFactorial.d.ts.map

package/lib/exercises/math/combinatory/combination/writeCombinationFormulaUsingFactorial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeCombinationFormulaUsingFactorial.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/combinatory/combination/writeCombinationFormulaUsingFactorial.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiB7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,aAAa,EAAE,eAAe,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA2UF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/combinatory/combination/writeCombinationFormulaUsingFactorial.js

@@ -0,0 +1,285 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { facto } from "../../../../tree/nodes/functions/factorialNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { binom } from "../../../../tree/nodes/operators/binomialCoefficientNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.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 { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { nodeIdsTotal, nodeIdsPicked } = identifiers;
+    const [nodeTotal, nodePicked] = [nodeIdsTotal, nodeIdsPicked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Ecrire à l'aide de la factorielle la formule permettant de calculer : 
+  
+$$
+${binom(nodeTotal, nodePicked).toTex()}
+$$`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsTotal, nodeIdsPicked } = identifiers;
+    const [nodeTotal, nodePicked] = [nodeIdsTotal, nodeIdsPicked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeBinom = binom(nodeTotal, nodePicked);
+    const nodeAnswer = nodeBinom.toFormulaWithFactoFractionNode();
+    return { nodeBinom, nodeAnswer };
+};
+const getAnswer = (identifiers) => {
+    return getAnswerStuff(identifiers).nodeAnswer.toTex({
+        forceParenthesis: true,
+    });
+};
+const getHint = () => {
+    return `Le nombre de combinaisons de $k$ élements parmi $n$ (noté $${binom(new VariableNode("n"), new VariableNode("k")).toTex()}$) 
+est égal au nombre de façon de prendre $k$ éléments parmi $n$ sans tenir compte de l'ordre.
+
+Exemple: 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsTotal, nodeIdsPicked, operandType } = identifiers;
+    const [nodeTotal, nodePicked] = [nodeIdsTotal, nodeIdsPicked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeBinom = binom(nodeTotal, nodePicked);
+    const nodeAnswerRaw = nodeBinom.toFormulaWithFactoFractionNode(false);
+    const nodeAnswerPretty = nodeBinom.toFormulaWithFactoFractionNode(true);
+    switch (operandType) {
+        case "lettres":
+            return `
+
+$$
+${nodeBinom.toTex()} = ${nodeBinom.toTex()}
+$$
+
+`;
+        case "entiers":
+            return `
+
+${alignTex([
+                [nodeBinom.toTex(), "=", nodeAnswerRaw.toTex()],
+                ["", "=", nodeAnswerPretty.toTex()],
+            ])}
+
+`;
+        default:
+            throw new Error("Unsupported operandType: " + operandType);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIdsTotal, nodeIdsPicked, operandType } = identifiers;
+    const [nodeTotal, nodePicked] = [nodeIdsTotal, nodeIdsPicked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //student: total<->picked
+    {
+        switch (operandType) {
+            case "lettres":
+                {
+                    const node = frac(facto(nodePicked), multiply(facto(nodeTotal), facto(substract(nodePicked, nodeTotal))));
+                    tryToAddWrongProp(propositions, node.toTex());
+                }
+                break;
+            case "entiers":
+                {
+                    const node = frac(facto(nodePicked), multiply(facto(nodeTotal), facto(substract(nodeTotal, nodePicked).simplify({
+                        towardsDistribute: true,
+                    }))));
+                    tryToAddWrongProp(propositions, node.toTex());
+                }
+                break;
+            default:
+                throw new Error("Unsupported operandType: " + operandType);
+        }
+    }
+    //student: total!/(total-picked)!
+    {
+        const node = frac(facto(nodeTotal), facto(substract(nodeTotal, nodePicked).simplify({ towardsDistribute: true })));
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    //student: total!/picked!
+    {
+        const node = frac(facto(nodeTotal), facto(nodePicked));
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    //student: picked!/total!
+    {
+        const node = frac(facto(nodePicked), facto(nodeTotal));
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    //student: forgets factorial somewhere
+    {
+        {
+            const node = frac(facto(nodeTotal), multiply(nodePicked, facto(substract(nodeTotal, nodePicked).simplify({
+                towardsDistribute: true,
+            }))));
+            tryToAddWrongProp(propositions, node.toTex());
+        }
+        switch (operandType) {
+            case "lettres":
+                {
+                    {
+                        const node = frac(facto(nodePicked), multiply(nodeTotal, facto(substract(nodePicked, nodeTotal))));
+                        tryToAddWrongProp(propositions, node.toTex());
+                    }
+                }
+                break;
+            case "entiers":
+                {
+                    const node = frac(facto(nodePicked), multiply(nodeTotal, facto(substract(nodeTotal, nodePicked).simplify({
+                        towardsDistribute: true,
+                    }))));
+                    tryToAddWrongProp(propositions, node.toTex());
+                }
+                break;
+            default:
+                throw new Error("Unsupported operandType: " + operandType);
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { operandType } = identifiers;
+    const keyFacto = {
+        id: "custom",
+        label: "!",
+        labelType: "tex",
+        mathfieldInstructions: {
+            method: "write",
+            content: "!",
+        },
+    };
+    switch (operandType) {
+        case "lettres": {
+            const { nodeIdsTotal, nodeIdsPicked } = identifiers;
+            const [nodeTotal, nodePicked] = [nodeIdsTotal, nodeIdsPicked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            return [
+                // "facto",
+                keyFacto,
+                ...[nodeTotal, nodePicked].map((node) => node.name),
+            ];
+        }
+        case "entiers":
+            // return ["facto"];
+            return [keyFacto];
+        default:
+            throw new Error("Unsupported operandType: " + operandType);
+    }
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { operandType } = identifiers;
+    switch (operandType) {
+        case "lettres": {
+            try {
+                //TODO: parse factorial
+                const nodeAnswer = getAnswerStuff(identifiers).nodeAnswer;
+                const isFormat1 = (str) => str === nodeAnswer.toTex();
+                const isFormat2 = (str) => str ===
+                    (() => {
+                        const nodeDenum = nodeAnswer.rightChild;
+                        const nodeAnswer2 = frac(nodeAnswer.leftChild, multiply(nodeDenum.rightChild, nodeDenum.leftChild));
+                        return nodeAnswer2;
+                    })().toTex();
+                return isFormat1(ans) || isFormat2(ans);
+            }
+            catch (err) {
+                return handleVEAError(err);
+            }
+        }
+        case "entiers": {
+            try {
+                //TODO: parse factorial
+                function countFactorialSymbols(str) {
+                    return str.split("").filter((str) => str === "!").length;
+                }
+                if (countFactorialSymbols(ans) !== countFactorialSymbols(answer)) {
+                    return false;
+                }
+                const nodeAns = parseAlgebraic(ans);
+                const nodeAnswer = parseAlgebraic(answer);
+                return NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer);
+            }
+            catch (err) {
+                return handleVEAError(err);
+            }
+        }
+        default:
+            throw new Error("Unsupported operandType: " + operandType);
+    }
+};
+const createRandomIdentifiers = (operandType) => {
+    switch (operandType) {
+        case "lettres": {
+            const poolLetters = "abcdklmnpqrst".split("");
+            const [nodeTotal, nodePicked] = randomMany(poolLetters, 2).map((letter) => new VariableNode(letter));
+            return {
+                nodeIdsTotal: nodeTotal.toIdentifiers(),
+                nodeIdsPicked: nodePicked.toIdentifiers(),
+                operandType,
+            };
+        }
+        case "entiers": {
+            const total = randint(30, 61);
+            const picked = randint(5, 21);
+            const [nodeTotal, nodePicked] = [total, picked].map((v) => v.toTree());
+            return {
+                nodeIdsTotal: nodeTotal.toIdentifiers(),
+                nodeIdsPicked: nodePicked.toIdentifiers(),
+                operandType,
+            };
+        }
+        default:
+            throw new Error("Unsupported operandType: " + operandType);
+    }
+};
+const getWriteCombinationFormulaUsingFactorialQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const operandType = random(arrayedOpts.operandType);
+    const identifiers = createRandomIdentifiers(operandType);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    operandType: ["entiers"],
+};
+const options = [
+    {
+        id: "operandType",
+        label: "Type d'opérandes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["lettres", "entiers"],
+        defaultValue: arrayedOptsDefault.operandType,
+    },
+];
+export const writeCombinationFormulaUsingFactorial = {
+    id: "writeCombinationFormulaUsingFactorial",
+    connector: "=",
+    label: "Écrire à l'aide de factorielles la formule pour $\\binom{n}{k}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getWriteCombinationFormulaUsingFactorialQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: false,
+};

package/lib/exercises/math/dataRepresentations/scatterPlot/scatterPlotInterpreting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scatterPlotInterpreting.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/scatterPlot/scatterPlotInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAwC7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AA2aF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}
+{"version":3,"file":"scatterPlotInterpreting.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/scatterPlot/scatterPlotInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAwC7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AA2aF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAoBzD,CAAC"}

package/lib/exercises/math/dataRepresentations/scatterPlot/scatterPlotInterpreting.js

@@ -384,7 +384,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 export const scatterPlotInterpreting = {
     id: "scatterPlotInterpreting",
-    label: "Interpréter un nuage de points",
+    label: "Compter le nombre de points dans un nuage de points vérifiant une condition",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getScatterPlotInterpretingQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/derivation/derivative/trigo/productOfSinAXPlusBCosCXPlusDDerivative.d.ts

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

package/lib/exercises/math/derivation/derivative/trigo/productOfSinAXPlusBCosCXPlusDDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"productOfSinAXPlusBCosCXPlusDDerivative.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/trigo/productOfSinAXPlusBCosCXPlusDDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,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;CAC3B,CAAC;AAiRF,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAAC,WAAW,CAmBzE,CAAC"}