math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/functions/logarithm/logInequationLnAXPlusBInfK.js

@@ -0,0 +1,330 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { splitAndKeep } from "../../../../utils/strings/splitAndKeep.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { random } from "../../../../utils/alea/random.js";
+import { round } from "../../../../math/utils/round.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { InequationSymbol, } from "../../../../math/inequations/inequation.js";
+import { InequationSolutionNode } from "../../../../tree/nodes/inequations/inequationSolutionNode.js";
+import { InequationNode } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { NamedIntervalIds, NamedIntervalNodeConstructor, } from "../../../../tree/nodes/sets/namedIntervalNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { unionIntervalParser } from "../../../../tree/parsers/unionIntervalParser.js";
+const getHydrated = (identifiers) => {
+    const { a, b, nodeIdsK, inegSymbol, nodeIdsIntervalRequired } = identifiers;
+    const nodeK = NodeConstructor.fromIdentifiers(nodeIdsK);
+    const nodeIntervalRequired = NodeConstructor.fromIdentifiers(nodeIdsIntervalRequired);
+    const nodeVarX = new VariableNode("x");
+    const nodeAffine = add(multiply(a, nodeVarX), b);
+    const nodeLogOfAffine = new LogNode(nodeAffine);
+    //step1 :
+    //     ln(ax+b) <<= k
+    //<=>     ax+b  <<= e^k
+    //<=>        ax <<= e^b - b
+    //<=> a>0 ? x <<= (e^b - b)/a : x >>= (e^b - b)/a
+    //<=> a>0 ? I_free = ]-\\infty; (e^b - b)/a [] : [] (e^b - b)/a ; +\\infty [
+    //step 2 :
+    //ln(ax+b) is defined on I_possible = a>0 ? : ] -b/a ; +\\infty [ :  ]-\\infty; -b/a [
+    //I_available = I_possible inter I_free
+    //step 3 :
+    //S = I_required inter I_available
+    const nodeRoot = frac(substract(exp(nodeK), b).simplify(), a).simplify();
+    const nodeIntervalFree = new InequationNode([nodeVarX, nodeRoot], a > 0 ? inegSymbol : new InequationSymbol(inegSymbol).reversed()).toInterval();
+    const nodeIntervalPossible = new InequationNode([nodeVarX, frac(-b, a).simplify()], a > 0 ? ">" : "<").toInterval();
+    const nodeIntervalAvailable = nodeIntervalPossible.intersection(nodeIntervalFree);
+    const nodeIntervalSolution = nodeIntervalRequired.intersection(nodeIntervalAvailable);
+    const nodeAnswer = new InequationSolutionNode(nodeIntervalSolution);
+    return {
+        a,
+        b,
+        nodeK,
+        inegSymbol,
+        nodeIntervalRequired,
+        nodeAffine,
+        nodeLogOfAffine,
+        nodeRoot,
+        nodeIntervalFree,
+        nodeIntervalPossible,
+        nodeIntervalAvailable,
+        nodeIntervalSolution,
+        nodeAnswer,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { a, b, nodeIdsK, inegSymbol, nodeIdsIntervalRequired } = identifiers;
+    const nodeK = NodeConstructor.fromIdentifiers(nodeIdsK);
+    const nodeIntervalRequired = NodeConstructor.fromIdentifiers(nodeIdsIntervalRequired);
+    const nodeVarX = new VariableNode("x");
+    const nodeAffine = add(multiply(a, nodeVarX), b);
+    const nodeLogOfAffine = new LogNode(nodeAffine);
+    const nodeInequation = new InequationNode([nodeLogOfAffine, nodeK], inegSymbol);
+    return `Résoudre dans $${nodeIntervalRequired.toTex()}$ l'inéquation : 
+
+$$
+${nodeInequation.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeAnswer } = getHydrated(identifiers);
+    return nodeAnswer.toTex();
+};
+const getHint = (identifiers) => {
+    const { a, b } = identifiers;
+    const nodeVarX = new VariableNode("x");
+    const nodeAffine = add(multiply(a, nodeVarX), b);
+    const nodeLogOfAffine = new LogNode(nodeAffine);
+    return `Suppose qu'une solution existe et calcule-la, 
+puis calcule l'intersection avec l'ensemble de définition de $x \\mapsto ${nodeLogOfAffine.toTex()}$, 
+et enfin calcule l'intersection avec l'ensemble imposé dans l'énoncé.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, nodeK, inegSymbol, nodeIntervalRequired, nodeAffine, nodeLogOfAffine, nodeIntervalFree, nodeIntervalPossible, nodeIntervalAvailable, nodeIntervalSolution, } = getHydrated(identifiers);
+    const nodeVarX = new VariableNode("x");
+    const nodeInequation1 = new InequationNode([nodeLogOfAffine, nodeK], inegSymbol);
+    const nodeInequation2 = new InequationNode([nodeAffine, exp(nodeK).simplify()], inegSymbol);
+    const nodeInequation3 = new InequationNode([multiply(a, nodeVarX), substract(exp(nodeK), b).simplify()], inegSymbol);
+    const inegSymbol4 = a > 0 ? inegSymbol : new InequationSymbol(inegSymbol).reversed();
+    const nodeInequation4 = new InequationNode([nodeVarX, frac(substract(exp(nodeK), b).simplify(), a)], inegSymbol4);
+    return `Supposons qu'une solution existe.
+
+On aurait :
+
+${alignTex([
+        ["\\ \\ ", ...splitAndKeep(nodeInequation1.toTex(), inegSymbol)],
+        ["\\Leftrightarrow", ...splitAndKeep(nodeInequation2.toTex(), inegSymbol)],
+        ["\\Leftrightarrow", ...splitAndKeep(nodeInequation3.toTex(), inegSymbol)],
+        ["\\Leftrightarrow", ...splitAndKeep(nodeInequation4.toTex(), inegSymbol4)],
+    ])}
+
+La fonction $x \\mapsto ${new LogNode(nodeVarX).toTex()}$ est définie sur $]0; +\\infty[$.
+La fonction $x \\mapsto ${nodeLogOfAffine.toTex()}$ est définie sur $${nodeIntervalPossible.toTex()}$.
+
+${alignTex([
+        [
+            `S_{\\text{provisoire}}`,
+            "=",
+            `${nodeIntervalPossible.toTex()} \\cap \\ ${nodeIntervalFree.toTex()}`,
+        ],
+        ["", "=", nodeIntervalAvailable.toTex()],
+    ])}
+
+L'intervalle imposé dans l'énoncé est $${nodeIntervalRequired.toTex()}$.
+
+La solution de l'équation proposée est donc :
+
+${alignTex([
+        [
+            `S`,
+            "=",
+            `${nodeIntervalRequired.toTex()} \\cap \\ ${nodeIntervalAvailable.toTex()}`,
+        ],
+        ["", "=", nodeIntervalSolution.toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //correct inegSymbol
+    {
+        const { nodeIntervalFree, nodeIntervalPossible, nodeIntervalAvailable } = getHydrated(identifiers);
+        //student: does not care about intervals
+        {
+            tryToAddWrongProp(propositions, nodeIntervalFree.toTex());
+        }
+        //student: cares only about the definition of ln(ax+b)
+        {
+            tryToAddWrongProp(propositions, nodeIntervalPossible.toTex());
+        }
+        //student: does not take required interval into account
+        {
+            tryToAddWrongProp(propositions, nodeIntervalAvailable.toTex());
+        }
+    }
+    //reversed inegSymbol
+    {
+        const identifiersWrong = {
+            ...identifiers,
+            inegSymbol: new InequationSymbol(identifiers.inegSymbol).reversed(),
+        };
+        const { nodeIntervalFree, nodeIntervalPossible, nodeIntervalAvailable } = getHydrated(identifiersWrong);
+        //student: does not care about intervals
+        {
+            tryToAddWrongProp(propositions, nodeIntervalFree.toTex());
+        }
+        //student: cares only about the definition of ln(ax+b)
+        {
+            tryToAddWrongProp(propositions, nodeIntervalPossible.toTex());
+        }
+        //student: does not take required interval into account
+        {
+            tryToAddWrongProp(propositions, nodeIntervalAvailable.toTex());
+        }
+    }
+    //student: a -> -a
+    {
+        const identifiersWrong = {
+            ...identifiers,
+            a: -identifiers.a,
+        };
+        const { nodeIntervalFree, nodeIntervalPossible, nodeIntervalAvailable } = getHydrated(identifiersWrong);
+        //student: does not care about intervals
+        {
+            tryToAddWrongProp(propositions, nodeIntervalFree.toTex());
+        }
+        //student: cares only about the definition of ln(ax+b)
+        {
+            tryToAddWrongProp(propositions, nodeIntervalPossible.toTex());
+        }
+        //student: does not take required interval into account
+        {
+            tryToAddWrongProp(propositions, nodeIntervalAvailable.toTex());
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [
+        "x",
+        "equal",
+        "lnBrackets",
+        "e",
+        "epower",
+        "lbracket",
+        "S",
+        "semicolon",
+        "rbracket",
+        "varnothing",
+    ];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        //S=\ \varnothing
+        {
+            const answerRefined = answer.replace("\\ ", "");
+            if (ans === answerRefined) {
+                return true;
+            }
+        }
+        //else
+        const parsed = unionIntervalParser(ans.replaceAll("S", "").replaceAll("=", ""));
+        if (!parsed)
+            return false;
+        return "S=\\ " + parsed.simplify().toTex() === answer;
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getLogInequationLnAXPlusBInfKQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const a = randint(-9, 20, [0]);
+    const b = randint(-9, 20, [0]);
+    const nodeK = (() => {
+        switch (opts.typeK) {
+            case "$k$":
+                return randint(-9, 20, [0]).toTree();
+            case "$\\ln(k')$":
+                return new LogNode(randint(2, 20, [0]).toTree());
+            default:
+                throw new Error("Unsupported opts.typeK: " + opts.typeK);
+        }
+    })();
+    const inegSymbol = random(["<", "\\le", "\\ge", ">"]);
+    const nodeIntervalRequired = (() => {
+        switch (opts.typeIntervalRequired) {
+            case "$\\mathbb{R}$":
+                return NamedIntervalNodeConstructor.fromName(NamedIntervalIds.R);
+            case "intervalle aléatoire": {
+                const nodeBoundLowPossible = frac(-b, a);
+                const nodeBoundLowRequired = (() => {
+                    const valueBoundLowPossibleRounded = round(nodeBoundLowPossible.evaluate(), 0);
+                    return randint(valueBoundLowPossibleRounded - 10, valueBoundLowPossibleRounded + 10).toTree();
+                })();
+                const nodeBoundLowMax = substract(nodeBoundLowRequired, nodeBoundLowPossible).evaluate() > 0
+                    ? nodeBoundLowRequired
+                    : nodeBoundLowPossible;
+                const nodeBoundHighRequired = Math.ceil(add(nodeBoundLowMax, randint(1, 11)).evaluate()).toTree();
+                const closureType = random([
+                    ClosureType.OO,
+                    ClosureType.OF,
+                    ClosureType.FO,
+                    ClosureType.FF,
+                ]);
+                return new IntervalNode(nodeBoundLowRequired, nodeBoundHighRequired, closureType);
+            }
+            default:
+                throw new Error("Unsupported opts.typeIntervalRequired: " + opts.typeIntervalRequired);
+        }
+    })();
+    const identifiers = {
+        a,
+        b,
+        nodeIdsK: nodeK.toIdentifiers(),
+        inegSymbol,
+        nodeIdsIntervalRequired: nodeIntervalRequired.toIdentifiers(),
+    };
+    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 optsDefault = {
+    typeIntervalRequired: "$\\mathbb{R}$",
+    typeK: "$k$",
+};
+const options = [
+    {
+        id: "typeIntervalRequired",
+        label: "Résoudre dans : ",
+        type: GeneratorOptionType.select,
+        target: GeneratorOptionTarget.generation,
+        values: ["$\\mathbb{R}$", "intervalle aléatoire"],
+        defaultValue: optsDefault.typeIntervalRequired,
+    },
+    {
+        id: "typeK",
+        label: "Format du membre de droite",
+        type: GeneratorOptionType.select,
+        target: GeneratorOptionTarget.generation,
+        values: ["$k$", "$\\ln(k')$"],
+        defaultValue: optsDefault.typeK,
+    },
+];
+export const logInequationLnAXPlusBInfK = {
+    id: "logInequationLnAXPlusBInfK",
+    connector: "=",
+    label: "Résoudre des équations de type $\\ln(ax+b) < k$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getLogInequationLnAXPlusBInfKQuestion(opts), nb),
+    options,
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/logarithm/logLinearCombinationSimplifiying.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    pm: number;
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+};
+export declare const logLinearCombinationSimplifiying: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=logLinearCombinationSimplifiying.d.ts.map

package/lib/exercises/math/functions/logarithm/logLinearCombinationSimplifiying.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logLinearCombinationSimplifiying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logLinearCombinationSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AA+BrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4NF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}

package/lib/exercises/math/functions/logarithm/logLinearCombinationSimplifiying.js

@@ -0,0 +1,185 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { primeDecompNode } from "../../../../math/utils/arithmetic/primeDecompNode.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { isLogNode, LogNode } from "../../../../tree/nodes/functions/logNode.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 { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydratedMini = (identifiers) => {
+    const { pm, a, b, c, d } = identifiers;
+    const [nodeLhs, nodeRhs] = [
+        [a, b],
+        [c, d],
+    ].map(([vFactor, v]) => multiply(vFactor, new LogNode(v.toTree())));
+    const addSub = pm === 1 ? add : substract;
+    const nodeSumRaw = addSub(nodeLhs, nodeRhs);
+    const mulFrac = pm === 1 ? multiply : frac;
+    const nodeInside = mulFrac(power(b, a), power(d, c));
+    const nodeSumRewrittenSimplified = new LogNode(nodeInside.simplify({ calculatePowers: true, forbidFactorize: true }));
+    return {
+        nodeSumRaw,
+        nodeSumRewrittenSimplified,
+    };
+};
+const getHydrated = (identifiers) => {
+    const { pm, a, b, c, d } = identifiers;
+    const [nodeLhs, nodeRhs] = [
+        [a, b],
+        [c, d],
+    ].map(([vFactor, v]) => multiply(vFactor, new LogNode(v.toTree())));
+    const addSub = pm === 1 ? add : substract;
+    const nodeSumRaw = addSub(nodeLhs, nodeRhs);
+    const mulFrac = pm === 1 ? multiply : frac;
+    const nodeInside = mulFrac(power(b, a), power(d, c));
+    const nodeSumRewritten = new LogNode(nodeInside);
+    const [nodeDecompB, nodeDecompD] = [b, d].map((v) => primeDecompNode(v, true));
+    const nodeSumRewrittenDeveloped = new LogNode(mulFrac(power(nodeDecompB, a), power(nodeDecompD, c)));
+    const nodeSumRewrittenSimplified = new LogNode(nodeInside.simplify({ calculatePowers: true, forbidFactorize: true }));
+    return {
+        nodeSumRaw,
+        nodeSumRewritten,
+        nodeSumRewrittenDeveloped,
+        nodeSumRewrittenSimplified,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeSumRaw } = getHydrated(identifiers);
+    return `Écrire le nombre suivant sous la forme $\\ln\\left(k\\right)$ : 
+  
+$$
+${nodeSumRaw.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeSumRewrittenSimplified } = getHydratedMini(identifiers);
+    return nodeSumRewrittenSimplified.toTex();
+};
+const getHint = (_identifiers) => {
+    return `Utilise les propriétés suivantes, pour $a$ et $b$ entiers positifs :
+
+$$
+b \\ln(a) = \\ln(a^b)
+$$
+
+$$
+\\ln(a) + \\ln(b) = \\ln(ab)
+$$
+
+$$
+\\ln(a) - \\ln(b) = \\ln(\\frac{a}{b})
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { pm } = identifiers;
+    const { nodeSumRaw, nodeSumRewritten, nodeSumRewrittenDeveloped, nodeSumRewrittenSimplified, } = getHydrated(identifiers);
+    return `
+  
+${alignTex([
+        ["", nodeSumRaw.toTex()],
+        ["=", nodeSumRewritten.toTex()],
+        ...(pm === -1 ? [["=", nodeSumRewrittenDeveloped.toTex()]] : []),
+        ["=", nodeSumRewrittenSimplified.toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { pm, a, b, c, d } = identifiers;
+    //student: ignores factors ln(b) + ln(d)
+    {
+        const identifiersWrong = { pm, a: 1, c: 1, b, d };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    }
+    //student: ignores rhs
+    {
+        const identifiersWrong = { pm, a, b, c: 0, d: 1 };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    }
+    //student: pm -> mp
+    {
+        const identifiersWrong = { pm: -pm, a, b, c, d };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["lnBrackets"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    const nodeAns = parseAlgebraic(ans);
+    if (!isLogNode(nodeAns)) {
+        return false;
+    }
+    const nodeAnswer = parseAlgebraic(answer);
+    const [nodeChildAns, nodeChildAnswer] = [nodeAns, nodeAnswer].map((node) => node.child);
+    return (NodeComparator.isEqualViaSub(nodeChildAns, nodeChildAnswer) ||
+        NodeComparator.isEqualViaFrac(nodeChildAns, nodeChildAnswer));
+};
+const createRandomIdentifiers = () => {
+    const pm = coinFlip() ? +1 : -1;
+    const [a, b, c, d] = (() => {
+        if (pm === +1) {
+            const [b, d] = randomMany([2, 3, 5, 7], 2);
+            const a = randint(2, 5);
+            const c = randint(2, 5);
+            return [a, b, c, d];
+        }
+        else {
+            const [p1, p2, p3] = randomMany([2, 3, 5, 7], 3);
+            const b = p1 * p2;
+            const d = p2 * p3;
+            const a = randint(2, 5);
+            const c = randint(2, 5);
+            return [a, b, c, d];
+        }
+    })();
+    const identifiers = { pm, a, b, c, d };
+    return identifiers;
+};
+const getLogLinearCombinationSimplifiying = () => {
+    const identifiers = createRandomIdentifiers();
+    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;
+};
+export const logLinearCombinationSimplifiying = {
+    id: "logLinearCombinationSimplifiying",
+    connector: "\\iff",
+    label: "Simplifier $a \\ln(b) + c \\ln(d)$",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getLogLinearCombinationSimplifiying, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -25,4 +25,5 @@ export * from "./dataRepresentations/index.js";
 export * from "./tests/index.js";
 export * from "./pcExosInMath.js";
 export * from "./scratch/index.js";
+export * from "./integration/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}

package/lib/exercises/math/index.js

@@ -25,4 +25,5 @@ export * from "./dataRepresentations/index.js";
 export * from "./tests/index.js";
 export * from "./pcExosInMath.js";
 export * from "./scratch/index.js";
+export * from "./integration/index.js";
 // export * from "./_debug/index.js";

package/lib/exercises/math/integration/fromExpr/areaBetweenCrossingCurvesFixedPosFromExpr.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsF: NodeIdentifiers;
+    nodeIdsG: NodeIdentifiers;
+    nodeIdsBounds: [NodeIdentifiers, NodeIdentifiers];
+};
+type Options = {
+    typeCrossingCurves: string;
+    typeSignBoundLow: string;
+    typeSignBoundHigh: string;
+};
+export declare const areaBetweenCrossingCurvesFixedPosFromExpr: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=areaBetweenCrossingCurvesFixedPosFromExpr.d.ts.map

package/lib/exercises/math/integration/fromExpr/areaBetweenCrossingCurvesFixedPosFromExpr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"areaBetweenCrossingCurvesFixedPosFromExpr.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/areaBetweenCrossingCurvesFixedPosFromExpr.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;CACnD,CAAC;AAojBF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAkDF,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAC9D,WAAW,EACX,OAAO,CAsBR,CAAC"}