math-exercises 3.0.133 → 3.0.135

package/lib/exercises/math/calculLitteral/equation/equationSecondDegreeWithNoB.js

@@ -0,0 +1,160 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Rational } from "../../../../math/numbers/rationals/rational.js";
+import { SquareRoot } from "../../../../math/numbers/reals/real.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { OppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { diceFlip } from "../../../../utils/alea/diceFlip.js";
+import { isInt } from "../../../../utils/isInt.js";
+import { random } from "../../../../utils/alea/random.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const squares = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].map((el) => el ** 2);
+const higherFactor = (n) => {
+    for (let i = Math.floor(Math.sqrt(n)); i > 0; i--)
+        if (n % i ** 2 === 0)
+            return i;
+    return 1;
+};
+const getInstruction = (identifiers) => {
+    const { randNbr } = identifiers;
+    return `Résoudre l'équation : 
+  
+$$
+x^2 = ${randNbr}
+$$`;
+};
+const getHint = () => {
+    return `L'équation $x^2 = k$ : 
+    
+- n'admet pas de solution si $k<0$ ;
+- admet une solution si $k=0$, qui est $0$ ;
+- admet deux solutions si $k>0$, qui sont $-\\sqrt{k}$ et $\\sqrt{k}$.
+    `;
+};
+const getAnswer = (identifiers) => {
+    const { randNbr } = identifiers;
+    let solutionsSet;
+    if (randNbr < 0) {
+        solutionsSet = new DiscreteSetNode([]);
+    }
+    else if (randNbr === 0) {
+        solutionsSet = new DiscreteSetNode([new NumberNode(0)]);
+    }
+    else {
+        const tree = new SquareRoot(randNbr).simplify().toTree();
+        solutionsSet = new DiscreteSetNode([new OppositeNode(tree), tree]);
+    }
+    const answer = new EquationSolutionNode(solutionsSet).toTex();
+    return answer;
+};
+const getCorrection = (identifiers) => {
+    const { randNbr } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `
+${randNbr < 0
+        ? `L'équation $x^2 = ${randNbr}$ n'admet pas de solution, car $${randNbr}$ est négatif. Ainsi, $${answer}$.`
+        : randNbr === 0
+            ? `L'équation $x^2 = 0$ admet une unique solution : $0$. En effet, $0$ est le seul nombre qui au carré est égal à $0$. Ainsi, $${answer}$.`
+            : `Puisque $${randNbr}>0$, l'équation $x^2 = ${randNbr}$ admet deux solutions : $-\\sqrt{${randNbr}}$ et $\\sqrt{${randNbr}}$. 
+    
+${new SquareRoot(randNbr).isSimplifiable()
+                ? `Or, $\\sqrt{${randNbr}}=${new SquareRoot(randNbr)
+                    .simplify()
+                    .toTree()
+                    .toTex()}$.`
+                : ""}
+
+Ainsi, $${answer}$.
+`}
+    `;
+};
+const getEquationSimpleSquare = () => {
+    let randNbr;
+    const rand = diceFlip(10);
+    if (rand === 1)
+        randNbr = randint(-20, 0);
+    else if (rand < 6)
+        randNbr = random(squares);
+    else
+        randNbr = randint(2, 100);
+    const identifiers = { randNbr };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, randNbr }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const half = new Rational(randNbr, 2).simplify().toTree();
+    if (randNbr < 0) {
+        tryToAddWrongProp(propositions, `S=\\left\\{-\\sqrt{${-randNbr}}\\right\\}`);
+        tryToAddWrongProp(propositions, `S=\\left\\{\\sqrt{-${-randNbr}}\\right\\}`);
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([half])).toTex());
+    }
+    else if (isInt(Math.sqrt(randNbr))) {
+        const sqrt = Math.sqrt(randNbr);
+        tryToAddWrongProp(propositions, `S=\\left\\{${sqrt}\\right\\}`);
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([half])).toTex());
+        propWhile(propositions, n, () => {
+            const tempAns = sqrt + randint(-sqrt + 1, 7, [0]);
+            tryToAddWrongProp(propositions, coinFlip()
+                ? `S=\\left\\{-${tempAns};${tempAns}\\right\\}`
+                : `S=\\varnothing`);
+        });
+    }
+    else {
+        const sqrtTree = new SquareRoot(randNbr).simplify().toTree();
+        const factor = higherFactor(randNbr);
+        const radicand = randNbr / factor ** 2;
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([sqrtTree])).toTex());
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([half])).toTex());
+        propWhile(propositions, n, () => {
+            const tempFactor = factor + randint(-factor + 1, 7, [0]);
+            const tempRadicand = radicand + randint(-radicand + 1, 7, [0]);
+            tryToAddWrongProp(propositions, coinFlip()
+                ? `S=\\left\\{-${tempFactor}\\sqrt{${tempRadicand}};${tempFactor}\\sqrt{${tempRadicand}}\\right\\}`
+                : `S=\\varnothing`);
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = discreteSetParser(ans);
+        if (!parsed)
+            return false;
+        return "S=" + parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const equationSecondDegreeWithNoB = {
+    id: "equationSecondDegreeWithNoB",
+    connector: "=",
+    label: "Résoudre une équation du type $ax^2 + b = 0$",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getEquationSimpleSquare, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/calculLitteral/simplifying/compareMinusA.js

@@ -82,7 +82,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 export const compareMinusA = {
     id: "compareMinusA",
-    label: "Comparer $(−1) \\times a$ ; $\\frac{a}{-1}$ et $-a$",
+    label: "Comparer $(-1) \\times a$ ; $\\frac{a}{-1}$ et $-a$",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getCompareMinusAQuestion(), nb, 30),
     qcmTimer: 60,

package/lib/exercises/math/dataRepresentations/barChartInterpreting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"barChartInterpreting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EAYL,QAAQ,EAKT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,cAAc,GAAG,cAAc,CAAC;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5C,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,GAAG,GAAG;IACT,KAAK,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,QAAQ,EAAE,CAAC;CACxB,CAAC;AA8tBF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe/D,CAAC"}
+{"version":3,"file":"barChartInterpreting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EAYL,QAAQ,EAKT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,cAAc,GAAG,cAAc,CAAC;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5C,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,GAAG,GAAG;IACT,KAAK,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,QAAQ,EAAE,CAAC;CACxB,CAAC;AA6tBF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe/D,CAAC"}

package/lib/exercises/math/dataRepresentations/barChartInterpreting.js

@@ -427,7 +427,6 @@ const getGGBOptions = (identifiers, opts) => {
     }
 };
 const getBarChartInterpretingQuestion = (optsIn) => {
-    console.log("optsIn", optsIn);
     const arrayedOptions = optsIn ?? optsDefault;
     const opts = {
         displayType: random(arrayedOptions.displayType),

package/lib/exercises/math/derivation/derivative/composition/functionCompositionDerivative.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeUIds: NodeIdentifiers;
+    nodeVIds: NodeIdentifiers;
+    nodeUPrimeIds: NodeIdentifiers;
+    nodeVPrimeIds: NodeIdentifiers;
+};
+export declare const functionCompositionDerivative: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=functionCompositionDerivative.d.ts.map

package/lib/exercises/math/derivation/derivative/composition/functionCompositionDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionCompositionDerivative.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/composition/functionCompositionDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAsE7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,eAAe,CAAC;IAC/B,aAAa,EAAE,eAAe,CAAC;CAChC,CAAC;AAoXF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

package/lib/exercises/math/derivation/derivative/composition/functionCompositionDerivative.js

@@ -0,0 +1,372 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { isEquivalentNodes } from "../../../../../math/utils/functions/functionComparison.js";
+import { nodeBySubstitutingVar } from "../../../../../math/utils/functions/functionComposition.js";
+import { realize } from "../../../../../math/utils/latex/realize.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { isFunctionNode, } from "../../../../../tree/nodes/functions/functionNode.js";
+import { NodeConstructor, } 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 { isOperatorNode } from "../../../../../tree/nodes/operators/operatorNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getFunctionNode = (nodeU, nodeV) => {
+    return nodeBySubstitutingVar(nodeU, nodeV);
+};
+const getFunctionDerivativeNode = (nodeUPrime, nodeV, nodeVPrime) => {
+    return multiply(nodeVPrime, nodeBySubstitutingVar(nodeUPrime, nodeV));
+};
+const functionNameForFunctionId = (functionId) => {
+    return [
+        "opposite",
+        "sqrt",
+        "cos",
+        "sin",
+        "tan",
+        "log",
+        "log10",
+        "exp",
+        "abs",
+        "arcsin",
+        "arccos",
+        "arctan",
+    ][functionId];
+};
+const extractElementaryFunctionNamesDict = (nodes, functionNamesDictIn = {}) => {
+    let functionNamesDict = functionNamesDictIn;
+    nodes.forEach((node) => {
+        if (isFunctionNode(node)) {
+            const functionId = node.id;
+            const functionName = functionNameForFunctionId(functionId);
+            if (!(functionName in functionNamesDict)) {
+                functionNamesDict[functionName] = functionName;
+            }
+            functionNamesDict = Object.assign(functionNamesDict, extractElementaryFunctionNamesDict([node.child], functionNamesDict));
+        }
+        else if (isOperatorNode(node)) {
+            functionNamesDict = Object.assign(functionNamesDict, extractElementaryFunctionNamesDict([node.leftChild, node.rightChild], functionNamesDict));
+        }
+    });
+    return functionNamesDict;
+};
+const getInstruction = (identifiers) => {
+    const nodeUOV = getFunctionNodeFromIdentifiers(identifiers);
+    return `Déterminer l'expression de la fonction dérivée $f'$ de la fonction $f$ (sur son intervalle de dérivation) :
+  
+$$
+f(x)=${nodeUOV.toTex()}
+$$
+
+`;
+};
+const getHint = () => {
+    return `Pour tout $x$ réel on a: 
+  
+$$
+(u \\circ v)'(x)  = v'(x) \\times (u' \\circ v)(x)
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeUIds, nodeUPrimeIds, nodeVIds, nodeVPrimeIds } = identifiers;
+    const [nodeU, nodeUPrime, nodeV, nodeVPrime] = [
+        nodeUIds,
+        nodeUPrimeIds,
+        nodeVIds,
+        nodeVPrimeIds,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Il faut calculer la dérivée de la fonction composée $u \\circ v$,
+
+avec :
+
+$$
+u(x) = ${nodeU.toTex()}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+On a :
+
+$$
+u'(x) = ${nodeUPrime.toTex()}
+$$
+
+$$
+v'(x) = ${nodeVPrime.toTex()}
+$$
+
+Donc
+  
+${alignTex([
+        [`f'(x)`, `=`, `v'(x) \\times (u' \\circ v)(x)`],
+        [
+            ``,
+            `=`,
+            `(${nodeVPrime.toTex()}) \\times (${nodeBySubstitutingVar(nodeUPrime, nodeV).toTex()})`,
+        ],
+        [``, `=`, `${getAnswerNode(identifiers).simplify().toTex()}`],
+    ])}`;
+};
+const getFunctionNodeFromIdentifiers = (identifiers) => {
+    const { nodeUIds, nodeVIds } = identifiers;
+    const [nodeU, nodeV] = [nodeUIds, nodeVIds].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return getFunctionNode(nodeU, nodeV);
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeUPrimeIds, nodeVIds, nodeVPrimeIds } = identifiers;
+    const [nodeUPrime, nodeV, nodeVPrime] = [
+        nodeUPrimeIds,
+        nodeVIds,
+        nodeVPrimeIds,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return getFunctionDerivativeNode(nodeUPrime, nodeV, nodeVPrime);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers)
+        .simplify({
+        distributePowersOnFrac: true,
+        calculatePowers: true,
+    })
+        .toTex();
+};
+const isAnswerValid = (ans, { answer }) => {
+    if (ans === answer) {
+        return true;
+    }
+    else {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return isEquivalentNodes(nodeAns, nodeAnswer);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeUIds, nodeUPrimeIds, nodeVIds, nodeVPrimeIds } = identifiers;
+    const [nodeU, nodeUPrime, nodeV, nodeVPrime] = [
+        nodeUIds,
+        nodeUPrimeIds,
+        nodeVIds,
+        nodeVPrimeIds,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const answerNode = getAnswerNode(identifiers);
+    const propositions = [];
+    addValidProp(propositions, answerNode.toTex());
+    const wannabeWrongNodes = [
+        //(vou)'
+        multiply(nodeUPrime, nodeBySubstitutingVar(nodeVPrime, nodeU)),
+        //v(x) * u'(v'(x))
+        multiply(nodeV, nodeBySubstitutingVar(nodeUPrime, nodeVPrime)),
+        //u'v+uv'
+        add(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrime)),
+        //(u'v-uv')/v²
+        frac(substract(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrime)), multiply(nodeV, nodeV).simplify()),
+    ];
+    wannabeWrongNodes.forEach((wannabeWrongNode) => {
+        if (!isEquivalentNodes(wannabeWrongNode, answerNode)) {
+            tryToAddWrongProp(propositions, wannabeWrongNode.toTex());
+        }
+    });
+    if (propositions.length < n) {
+        [
+            `${nodeBySubstitutingVar(nodeU, nodeU).toTex({
+                forceParenthesis: true,
+            })}`,
+            `${nodeBySubstitutingVar(nodeU, nodeU).simplify().toTex()}`,
+            `${nodeBySubstitutingVar(nodeV, nodeV).toTex({
+                forceParenthesis: true,
+            })}`,
+            `${nodeBySubstitutingVar(nodeV, nodeV).simplify().toTex()}`,
+        ].forEach((wrongTex) => {
+            tryToAddWrongProp(propositions, wrongTex);
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeUIds, nodeUPrimeIds, nodeVIds, nodeVPrimeIds } = identifiers;
+    const [nodeU, nodeUPrime, nodeV, nodeVPrime] = [
+        nodeUIds,
+        nodeUPrimeIds,
+        nodeVIds,
+        nodeVPrimeIds,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const functionNamesDict = extractElementaryFunctionNamesDict([
+        nodeU,
+        nodeUPrime,
+        nodeV,
+        nodeVPrime,
+    ]);
+    const texs = Object.values(functionNamesDict)
+        .map((functionName) => {
+        switch (functionName) {
+            case "cos":
+            case "sin":
+            case "tan":
+            case "arcsin":
+            case "arccos":
+            case "arctan":
+            case "abs":
+                return `\\${functionName}`;
+            case "log":
+                return "\\ln";
+            case "log10":
+                return "\\log";
+            case "exp":
+                return "e";
+            case "sqrt":
+            case "opposite":
+            default:
+                return undefined;
+        }
+    })
+        .filter((tex) => !!tex);
+    return [
+        "x",
+        ...texs.map((tex) => {
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const dictFunctionAndDerivative = {
+    // "ax+b": {
+    //   f: "ax+b",
+    //   fprime: "a",
+    // },
+    "(ax+b)^2": {
+        f: "(ax+b)^2",
+        fprime: "2ax+2ab",
+    },
+    "ax^2+bx+c": {
+        f: "ax^2+bx+c",
+        fprime: "2ax+b",
+    },
+    // "(x+a)(x+b)": {
+    //   f: "(x+a)(x+b)",
+    //   fprime: "2x+(a+b)",
+    // },
+    sin: {
+        f: "\\sin{x}",
+        fprime: "\\cos{x}",
+    },
+    cos: {
+        f: "\\cos{x}",
+        fprime: "-\\sin{x}",
+    },
+    ln: {
+        f: "\\ln{x}",
+        fprime: "\\frac{1}{x}",
+    },
+    "x^n": {
+        f: "x^n",
+        fprime: "n \\times x^{n-1}",
+    },
+    sqrt: {
+        f: "\\sqrt{x}",
+        fprime: "\\frac{1}{(2)\\sqrt{x}}",
+    },
+    exp: {
+        f: "e^x",
+        fprime: "e^x",
+    },
+};
+const getFunctionCompositionDerivativeQuestion = (_) => {
+    function realizeFunctionAndDerivative(functionAndDerivative) {
+        switch (functionAndDerivative.f) {
+            case "x^n": {
+                const n = randint(2, 10).toTree();
+                const randomNodeN = { custom: () => n };
+                return [functionAndDerivative.f, functionAndDerivative.fprime].map((f) => realize({ n: randomNodeN })(f));
+            }
+            // case "ax+b":
+            case "(ax+b)^2": {
+                // case "(x+a)(x+b)":
+                const a = randint(-9, 10, [0]).toTree();
+                const randomNodeA = { custom: () => a };
+                const b = randint(-9, 10, [0]).toTree();
+                const randomNodeB = { custom: () => b };
+                return [functionAndDerivative.f, functionAndDerivative.fprime].map((f) => realize({ a: randomNodeA, b: randomNodeB })(f));
+            }
+            case "ax^2+bx+c": {
+                const a = randint(-9, 10, [0]).toTree();
+                const randomNodeA = { custom: () => a };
+                const b = randint(-9, 10, [0]).toTree();
+                const randomNodeB = { custom: () => b };
+                const c = randint(-9, 10, [0]).toTree();
+                const randomNodeC = { custom: () => c };
+                return [functionAndDerivative.f, functionAndDerivative.fprime].map((f) => realize({ a: randomNodeA, b: randomNodeB, c: randomNodeC })(f));
+            }
+            default: {
+                return [functionAndDerivative.f, functionAndDerivative.fprime].map((f) => realize({})(f));
+            }
+        }
+    }
+    function createNodeFromRealized(strRealized) {
+        return parseAlgebraic(strRealized).simplify({ forbidFactorize: true });
+    }
+    function getRandomNodeNodeForFunctionAndDerivative(functionAndDerivative) {
+        return realizeFunctionAndDerivative(functionAndDerivative).map(createNodeFromRealized);
+    }
+    const functionAndDerivativeU = dictFunctionAndDerivative[random(["sin", "cos", "ln", "sqrt", "exp", "x^n"])];
+    const functionAndDerivativeV = (() => {
+        switch (functionAndDerivativeU.f) {
+            case "x^n": {
+                //pour éviter le problème de ...^2^5 au moment de .toTex()
+                return dictFunctionAndDerivative[random(["sin", "cos", "ln", "sqrt"])];
+            }
+            default: {
+                return dictFunctionAndDerivative[random(Object.keys(dictFunctionAndDerivative))];
+            }
+        }
+    })();
+    const [nodeU, nodeUPrime] = getRandomNodeNodeForFunctionAndDerivative(functionAndDerivativeU);
+    const [nodeV, nodeVPrime] = getRandomNodeNodeForFunctionAndDerivative(functionAndDerivativeV);
+    const identifiers = {
+        nodeUIds: nodeU.toIdentifiers(),
+        nodeVIds: nodeV.toIdentifiers(),
+        nodeUPrimeIds: nodeUPrime.toIdentifiers(),
+        nodeVPrimeIds: nodeVPrime.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 functionCompositionDerivative = {
+    id: "functionCompositionDerivative",
+    label: "Déterminer la dérivée d'une fonction composée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFunctionCompositionDerivativeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,2 @@
+export * from "./functionCompositionDerivative.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/derivative/composition/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/composition/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./functionCompositionDerivative.js";

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

@@ -7,4 +7,5 @@ export * from "./polynomial/index.js";
 export * from "./trigo/index.js";
 export * from "./power/index.js";
 export * from "./sqrt/index.js";
+export * from "./composition/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC"}

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

@@ -7,3 +7,4 @@ export * from "./polynomial/index.js";
 export * from "./trigo/index.js";
 export * from "./power/index.js";
 export * from "./sqrt/index.js";
+export * from "./composition/index.js";

package/lib/exercises/math/functions/affines/recognizeAffineGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeAffineGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/recognizeAffineGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,UAAU,GAAG;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAmBF,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA6JF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}
+{"version":3,"file":"recognizeAffineGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/recognizeAffineGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,UAAU,GAAG;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAmBF,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAgKF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

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

@@ -42,13 +42,14 @@ const getInstruction = (identifiers) => {
 };
 const getGGBOptions = (identifiers) => {
     const { arrFProps } = identifiers;
+    const { xMin, xMax, yMin, yMax } = DISPLAY_PROPS;
     function createFunctionCommands(nodeIds, fName, color) {
         const nodeF = NodeConstructor.fromIdentifiers(nodeIds);
         const expr = nodeF.toMathString();
         return [
             `${fName} = Function(${expr}, x, -20, 20)`,
-            // `ShowLabel(${fName}, true)`,
-            // `SetCaption(${fName}, "C_${fName}")`,
+            `ShowLabel(${fName}, true)`,
+            `SetCaption(${fName}, "$\\mathcal C_${fName}$")`,
             `SetColor(${fName}, "${color}")`,
         ];
     }
@@ -56,7 +57,6 @@ const getGGBOptions = (identifiers) => {
     const ggb = new GeogebraConstructor({
         commands,
     });
-    const { xMin, xMax, yMin, yMax } = DISPLAY_PROPS;
     return ggb.getOptions({
         coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
     });

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

@@ -252,7 +252,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 export const recognizeExprAffine = {
     id: "recognizeExprAffine",
-    label: "Reconnaître l’expression d’une fonction affine",
+    label: "Reconnaître l'expression d'une fonction affine",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getRecognizeExprAffineQuestion({
         askedType: "affine",
@@ -268,7 +268,7 @@ export const recognizeExprAffine = {
 };
 export const recognizeExprLinear = {
     id: "recognizeExprLinear",
-    label: "Reconnaître l’expression d’une fonction linéaire",
+    label: "Reconnaître l'expression d'une fonction linéaire",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getRecognizeExprAffineQuestion({
         askedType: "linear",

package/lib/exercises/math/functions/composition/functionComposition.js

@@ -195,7 +195,7 @@ const getFunctionCompositionQuestion = (_) => {
                 `\\sin(x)`,
                 realize({ a: "I" })(`\\sin(ax)`),
                 `\\cos(x)`,
-                realize({ a: "I" })(`\\sin(ax)`),
+                realize({ a: "I" })(`\\cos(ax)`),
             ].map((tex) => parseAlgebraic(tex)),
             //! TODO: simplify({maxSimplificationSteps: 100}) to allow using fracs
             // frac(randomNodeWithType("I"), "x"),