math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/integration/fromGraph/boundIntegralByManipulatingAutomaticRectanglesMethodFromGraph.js

@@ -0,0 +1,286 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { lowerSumSameAsGGB, upperSumSameAsGGB, } from "../../../../math/utils/integration/rectanglesMethod.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { InequationNode } from "../../../../tree/nodes/inequations/inequationNode.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 { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds, nbRectanglesRequired } = identifiers;
+    const [nodeF, nodeBoundLow, nodeBoundHigh] = [nodeIdsF, ...nodeIdsBounds].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeLowerSum, nodeUpperSum] = [
+        lowerSumSameAsGGB,
+        upperSumSameAsGGB,
+    ].map((funcSum) => round(funcSum(nodeF, nodeBoundLow, nodeBoundHigh, nbRectanglesRequired), 2).toTree());
+    const nodeVarI = new VariableNode("I");
+    const nodeInequation = new InequationNode([nodeLowerSum, nodeVarI, nodeUpperSum], ["\\le", "\\le"]);
+    return {
+        nodeF,
+        nodeBoundLow,
+        nodeBoundHigh,
+        nodeLowerSum,
+        nodeUpperSum,
+        nodeInequation,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsBounds, nbRectanglesRequired } = identifiers;
+    const [nodeBoundLow, nodeBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Sur le graphique ci-dessous, on a représenté la courbe représentative d'une fonction $f$ définie sur $\\mathbb{R}$. 
+On note : 
+
+$$
+I = \\int_{${nodeBoundLow.toTex()}}^{${nodeBoundHigh.toTex()}} f
+$$ 
+
+En manipulant les points $A$ et $B$ sur le graphique, et le curseur $n$ fixant le nombre de rectangles utilisés, 
+donner l'encadrement que l'on obtient quand on utilise la méthode des rectangles avec $${nbRectanglesRequired}$ rectangles pour la somme inférieure 
+et $${nbRectanglesRequired}$ pour la somme supérieure.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeInequation } = getHydrated(identifiers);
+    return nodeInequation.toTex();
+};
+const getHint = () => {
+    return `Premièrement, manipule le curseur du nombre de rectangles utilisés pour mettre le nombre de rectangles demandé.
+Ensuite, manipule les points $A$ et $B$ pour faire correspondre leurs abscisses aux bornes d'intégration.`;
+};
+const getCorrection = (identifiers) => {
+    const { nbRectanglesRequired } = identifiers;
+    const { nodeBoundLow, nodeBoundHigh, nodeInequation } = getHydrated(identifiers);
+    return `La fonction $f$ est croissante sur l'intervalle d'intégration.
+Avec $${nbRectanglesRequired.frenchify()}$ utilisés, 
+en plaçant le point $A$ à l'abscisse $${nodeBoundLow.toTex()}$,
+en plaçant le point $B$ à l'abscisse  $${nodeBoundHigh.toTex()}$,
+on lit :
+
+$$
+${nodeInequation.toTex()}
+$$ 
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nbRectanglesRequired } = identifiers;
+    const { nodeF, nodeBoundHigh, nodeBoundLow } = getHydrated(identifiers);
+    const xMin = nodeBoundLow.evaluate() - 1;
+    const xMax = nodeBoundHigh.evaluate() + 1;
+    const yMin = -1.5;
+    const yMax = (() => {
+        const valueBoundLow = nodeBoundLow.evaluate();
+        const valueBoundHigh = nodeBoundHigh.evaluate();
+        const nbSteps = 50;
+        const valueStepAbscissa = (valueBoundHigh - valueBoundLow) / nbSteps;
+        return [...Array(nbSteps).keys()].reduce((acc, i) => {
+            const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+            const valueImageI = nodeF.evaluate({ x: valueAbscissa });
+            if (i === 0) {
+                return valueImageI;
+            }
+            else {
+                return Math.max(acc, valueImageI);
+            }
+        });
+    })();
+    const pointForLowerSumLabel = new Point("L", (xMin + 0.5 * (xMax - xMin)).toTree(), (yMin + 0 * (yMax - yMin)).toTree());
+    const pointForUpperSumLabel = new Point("U", (xMin + 0.5 * (xMax - xMin)).toTree(), (yMax - 0 * (yMax - yMin)).toTree());
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        //slider a
+        `a=${nodeBoundLow.toMathString()}`,
+        //slider b
+        `b=${nodeBoundHigh.toMathString()}`,
+        //pointA
+        `A = (a,0)`,
+        `ShowLabel(A, true)`,
+        //pointB
+        `B = (b,0)`,
+        `ShowLabel(B, true)`,
+        //slider n
+        `n=${nbRectanglesRequired}`,
+        //rect sums
+        `surfLowerSum = LowerSum(f,a,b,n)`,
+        `ShowLabel(surfLowerSum, false)`,
+        `surfUpperSum = UpperSum(f,a,b,n)`,
+        `ShowLabel(surfUpperSum, false)`,
+        //display of sums
+        `TextLowerSumLhs = Text("\\text{Somme à gauche :}", ${pointForLowerSumLabel.toMathString()}, true, true, -1, 0)`,
+        `TextLowerSumRhs = Text(surfLowerSum, ${pointForLowerSumLabel.toMathString()}, true, true, 1, 0)`,
+        `TextUpperSumLhs = Text("\\text{Somme à droite :}", ${pointForUpperSumLabel.toMathString()}, true, true, -1, 0)`,
+        `TextUpperSumRhs = Text(surfUpperSum, ${pointForUpperSumLabel.toMathString()}, true, true, 1, 0)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nbRectanglesRequired } = identifiers;
+    const { nodeF, nodeBoundHigh, nodeBoundLow } = getHydrated(identifiers);
+    const xMin = nodeBoundLow.evaluate() - 1;
+    const xMax = nodeBoundHigh.evaluate() + 1;
+    const yMin = -1.5;
+    const yMax = (() => {
+        const valueBoundLow = nodeBoundLow.evaluate();
+        const valueBoundHigh = nodeBoundHigh.evaluate();
+        const nbSteps = 50;
+        const valueStepAbscissa = (valueBoundHigh - valueBoundLow) / nbSteps;
+        return [...Array(nbSteps).keys()].reduce((acc, i) => {
+            const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+            const valueImageI = nodeF.evaluate({ x: valueAbscissa });
+            if (i === 0) {
+                return valueImageI;
+            }
+            else {
+                return Math.max(acc, valueImageI);
+            }
+        });
+    })();
+    const pointForLowerSumLabel = new Point("L", (xMin + 0.5 * (xMax - xMin)).toTree(), (yMin + 0 * (yMax - yMin)).toTree());
+    const pointForUpperSumLabel = new Point("U", (xMin + 0.5 * (xMax - xMin)).toTree(), (yMax - 0 * (yMax - yMin)).toTree());
+    const [valueSliderAInitial, valueSliderBInitial] = [
+        randfloat(4.5, 5.5, 5, [1]),
+        randfloat(5.5, 6.5, 6, [1]),
+    ];
+    const valueSliderNInitial = randint(1, 50, [nbRectanglesRequired]);
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        //slider a
+        `a=Slider(-10,10,0.5)`,
+        `SetValue(a, ${valueSliderAInitial})`,
+        `SetVisibleInView(a,1,false)`,
+        //slider b
+        `b=Slider(-10,10,0.5)`,
+        `SetValue(b, ${valueSliderBInitial})`,
+        `SetVisibleInView(b,1,false)`,
+        //pointA (moving)
+        `A = (a,0)`,
+        `ShowLabel(A, true)`,
+        //pointB (moving)
+        `B = (b,0)`,
+        `ShowLabel(B, true)`,
+        //slider n
+        `n=Slider(1,30,1)`,
+        `SetValue(n, ${valueSliderNInitial})`,
+        `SetVisibleInView(n,1,true)`,
+        //rect sums
+        `surfLowerSum = LowerSum(f,a,b,n)`,
+        `ShowLabel(surfLowerSum, false)`,
+        `surfUpperSum = UpperSum(f,a,b,n)`,
+        `ShowLabel(surfUpperSum, false)`,
+        //display of sums
+        `TextLowerSumLhs = Text("\\text{Somme à gauche :}", ${pointForLowerSumLabel.toMathString()}, true, true, -1, 0)`,
+        `TextLowerSumRhs = Text(surfLowerSum, ${pointForLowerSumLabel.toMathString()}, true, true, 1, 0)`,
+        `TextUpperSumLhs = Text("\\text{Somme à droite :}", ${pointForUpperSumLabel.toMathString()}, true, true, -1, 0)`,
+        `TextUpperSumRhs = Text(surfUpperSum, ${pointForUpperSumLabel.toMathString()}, true, true, 1, 0)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["leq", "I"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const arrNodeAns = ans.split("\\le").map((tex) => parseAlgebraic(tex));
+        const arrNodeAnswer = answer
+            .split("\\le")
+            .map((tex) => parseAlgebraic(tex));
+        return (arrNodeAns.length === arrNodeAnswer.length &&
+            zip(arrNodeAns, arrNodeAnswer).every(([nodeAns, nodeAnswer]) => NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+                NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer)));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const [nodeBoundLow, nodeBoundHigh] = [
+        randint(1, 5).toTree(),
+        randint(6, 10).toTree(),
+    ];
+    const nodeVarX = new VariableNode("x");
+    const nodeF = multiply(multiply(randfloat(0.05, 0.2).toTree(), nodeVarX), add(randfloat(0.5, 1.5).toTree(), add(cos(frac(multiply(randfloat(0.5, 1.5).toTree(), nodeVarX), 10)), sin(frac(multiply(randfloat(0.5, 1.5).toTree(), nodeVarX), 6)))));
+    const nbRectanglesRequired = randint(3, 26);
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsBounds: [nodeBoundLow, nodeBoundHigh].map((node) => node.toIdentifiers()),
+        nbRectanglesRequired,
+    };
+    return identifiers;
+};
+const getBoundIntegralByManipulatingAutomaticRectanglesMethodFromGraphQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const boundIntegralByManipulatingAutomaticRectanglesMethodFromGraph = {
+    id: "boundIntegralByManipulatingAutomaticRectanglesMethodFromGraph",
+    connector: "=",
+    label: "Obtenir un encadrement d'une intégrale par la manipulation d'une mise en oeuvre automatisée de la méthode des rectangles",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getBoundIntegralByManipulatingAutomaticRectanglesMethodFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/integration/fromGraph/imageOfPrimitiveByManipulatingIntegralBoundsFromGraph.d.ts

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

package/lib/exercises/math/integration/fromGraph/imageOfPrimitiveByManipulatingIntegralBoundsFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageOfPrimitiveByManipulatingIntegralBoundsFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromGraph/imageOfPrimitiveByManipulatingIntegralBoundsFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,eAAe,CAAC;IAC7B,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AA2QF,eAAO,MAAM,qDAAqD,EAAE,QAAQ,CAAC,WAAW,CAuBrF,CAAC"}

package/lib/exercises/math/integration/fromGraph/imageOfPrimitiveByManipulatingIntegralBoundsFromGraph.js

@@ -0,0 +1,231 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.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 { 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 { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsBigF, nodeIdsBounds } = identifiers;
+    const [nodeBigF, nodeBoundLow, nodeBoundHigh] = [
+        nodeIdsBigF,
+        ...nodeIdsBounds,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeIntegral = nodeBySubstitutingVar(nodeBigF, nodeBoundHigh, new VariableNode("x"));
+    const nodeF = nodeBigF.derivative();
+    return {
+        nodeBigF,
+        nodeBoundLow,
+        nodeBoundHigh,
+        nodeF,
+        nodeIntegral,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsBounds } = identifiers;
+    const [nodeBoundLow, nodeBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Sur le graphique ci-dessous, on a représenté la courbe représentative d'une fonction $f$ définie sur $\\mathbb{R}$. 
+Soit $F$ la fonction définie sur $\\mathbb{R}$ par : 
+
+$$
+F(x) = \\int_{${nodeBoundLow.toTex()}}^{x} f
+$$ 
+
+En manipulant les points $A$ et $B$ sur le graphique, donner une valeur approchée à $2$ décimales de $F(${nodeBoundHigh.toTex()})$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIntegral } = getHydrated(identifiers);
+    return round(nodeIntegral.evaluate(), 2).frenchify();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsBounds } = identifiers;
+    const [nodeBoundLow, nodeBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Premièrement, il te faut déterminer à quelle intégrale correspond $F(${nodeBoundHigh.toTex()})$.
+  
+Ensuite, pour calculer l'intégrale de la fonction $f$ entre entre $${nodeBoundLow.toTex()}$ et $${nodeBoundHigh.toTex()}$, 
+détermine l'aire de la surface contenue sous la courbe entre les abscisses $${nodeBoundLow.toTex()}$ et $${nodeBoundHigh.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeBoundLow, nodeBoundHigh, nodeIntegral } = getHydrated(identifiers);
+    const texAnswer = round(nodeIntegral.evaluate(), 2).frenchify();
+    return `On a : 
+
+$$
+F(x) = \\int_{${nodeBoundLow.toTex()}}^{x} f
+$$ 
+
+Donc :
+
+$$
+F(${nodeBoundHigh.toTex()}) = \\int_{${nodeBoundLow.toTex()}}^{${nodeBoundHigh.toTex()}} f
+$$ 
+
+On vient positionner $A$ à l'abscisse $${nodeBoundLow.toTex()}$ et $B$ à l'abscisse $${nodeBoundHigh.toTex()}$.
+On lit alors : 
+
+$$
+F(${nodeBoundHigh.toTex()}) \\approx ${texAnswer}
+$$ 
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeF, nodeBoundHigh, nodeBoundLow } = getHydrated(identifiers);
+    const xMin = nodeBoundLow.evaluate() - 1;
+    const xMax = nodeBoundHigh.evaluate() + 1;
+    const yMin = -1.5;
+    const yMax = 10;
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        //slider a
+        `a=${nodeBoundLow.toTex()}`,
+        //slider b
+        `b=${nodeBoundHigh.toTex()}`,
+        //pointA
+        `A = (a,0)`,
+        `ShowLabel(A, true)`,
+        //pointB
+        `B = (b,0)`,
+        `ShowLabel(B, true)`,
+        //integral
+        `surfInt = IntegralBetween(f,0,a,b)`,
+        `SetColor(surfInt, "${greenMain}")`,
+        `SetFilling(surfInt, 0.36)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeF, nodeBoundHigh, nodeBoundLow } = getHydrated(identifiers);
+    const xMin = nodeBoundLow.evaluate() - 1;
+    const xMax = nodeBoundHigh.evaluate() + 1;
+    const yMin = -1.5;
+    const yMax = 10;
+    const [valueSliderAInitial, valueSliderBInitial] = [
+        randfloat(4.5, 5.5, 5, [1]),
+        randfloat(5.5, 6.5, 6, [1]),
+    ];
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        //slider a
+        `a=Slider(-10,10,0.1)`,
+        `SetValue(a, ${valueSliderAInitial})`,
+        `SetVisibleInView(a,1,false)`,
+        //slider b
+        `b=Slider(-10,10,0.1)`,
+        `SetValue(b, ${valueSliderBInitial})`,
+        `SetVisibleInView(b,1,false)`,
+        //pointA (moving)
+        `A = (a,0)`,
+        `ShowLabel(A, true)`,
+        //pointB (moving)
+        `B = (b,0)`,
+        `ShowLabel(B, true)`,
+        //integral
+        `surfInt = IntegralBetween(f,0,a,b)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        const isValid = NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer);
+        return isValid;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const [nodeBoundLow, nodeBoundHigh] = [
+        randint(1, 5).toTree(),
+        randint(6, 10).toTree(),
+    ];
+    const nodeVarX = new VariableNode("x");
+    const nodeBigFBlueprint = multiply(multiply(randfloat(2, 4).toTree(), nodeVarX), add(randfloat(0.5, 1.5).toTree(), add(cos(frac(multiply(randfloat(0.5, 1.5).toTree(), nodeVarX), 10)), sin(frac(multiply(randfloat(0.5, 1.5).toTree(), nodeVarX), 6)))));
+    //ensure F(boundLow) = 0
+    const nodeBigF = substract(nodeBigFBlueprint, nodeBySubstitutingVar(nodeBigFBlueprint, nodeBoundLow, nodeVarX));
+    const identifiers = {
+        nodeIdsBigF: nodeBigF.toIdentifiers(),
+        nodeIdsBounds: [nodeBoundLow, nodeBoundHigh].map((node) => node.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getImageOfPrimitiveByManipulatingIntegralBoundsFromGraphQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const imageOfPrimitiveByManipulatingIntegralBoundsFromGraph = {
+    id: "imageOfPrimitiveByManipulatingIntegralBoundsFromGraph",
+    connector: "=",
+    label: "Déterminer une valeur de $F(x)=\\int_{a}^{x} f$ par la manipulation des bornes d'intégration sur un graphique",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getImageOfPrimitiveByManipulatingIntegralBoundsFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,7 @@
+export * from "./integralOfAffineFromGraph.js";
+export * from "./integralOfPiecewiseAffineFromGraph.js";
+export * from "./integralOfAffineFromExprByComputingArea.js";
+export * from "./imageOfPrimitiveByManipulatingIntegralBoundsFromGraph.js";
+export * from "./boundIntegralByManipulatingAutomaticRectanglesMethodFromGraph.js";
+export * from "./varTableOfPrimitiveFromGraph.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromGraph/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yCAAyC,CAAC;AACxD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,4DAA4D,CAAC;AAC3E,cAAc,oEAAoE,CAAC;AACnF,cAAc,mCAAmC,CAAC"}

package/lib/exercises/math/integration/fromGraph/index.js

@@ -0,0 +1,6 @@
+export * from "./integralOfAffineFromGraph.js";
+export * from "./integralOfPiecewiseAffineFromGraph.js";
+export * from "./integralOfAffineFromExprByComputingArea.js";
+export * from "./imageOfPrimitiveByManipulatingIntegralBoundsFromGraph.js";
+export * from "./boundIntegralByManipulatingAutomaticRectanglesMethodFromGraph.js";
+export * from "./varTableOfPrimitiveFromGraph.js";

package/lib/exercises/math/integration/fromGraph/integralOfAffineFromExprByComputingArea.d.ts

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

package/lib/exercises/math/integration/fromGraph/integralOfAffineFromExprByComputingArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integralOfAffineFromExprByComputingArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromGraph/integralOfAffineFromExprByComputingArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAwfF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAiEF,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAC5D,WAAW,EACX,OAAO,CAsBR,CAAC"}