math-exercises 3.0.200 → 3.0.201

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

@@ -0,0 +1,466 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { blueMain, greenLight, greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.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 { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const createGgbCommandsForChunkOfF = (chunkOfF, i, arr) => {
+    const { nodeF, nodeBoundLow, nodeBoundHigh } = chunkOfF;
+    return [
+        `f${i}(x) = Function(${nodeF.toMathString()}, ${i === 0 ? "-100" : nodeBoundLow.toMathString()}, ${i === arr.length - 1 ? "+100" : nodeBoundHigh.toMathString()})`,
+        `SetColor(f${i}, "${blueMain}")`,
+    ];
+};
+const createDictIntegralStuff = (chunkOfF) => {
+    const { nodeF, nodeBoundLow, nodeBoundHigh } = chunkOfF;
+    const [nodeImageBoundLow, nodeImageBoundHigh] = [
+        nodeBoundLow,
+        nodeBoundHigh,
+    ].map((nodeBound) => nodeBySubstitutingVar(nodeF, nodeBound, new VariableNode("x")).simplify({
+        towardsDistribute: true,
+    }));
+    const isConstantFunc = NodeComparator.isEqualViaSub(nodeImageBoundLow, nodeImageBoundHigh);
+    const nodeA = nodeF
+        .derivative()
+        .simplify({ towardsDistribute: true, forbidFactorize: true });
+    const [nodeImageMin, nodeImageMax] = [
+        nodeImageBoundLow,
+        nodeImageBoundHigh,
+    ].toSorted((node1, node2) => node1.evaluate() - node2.evaluate());
+    const arrPoint = [
+        new Point("A", nodeBoundLow, (0).toTree()),
+        new Point("B", nodeBoundLow, nodeImageMin),
+        new Point("C", nodeBoundHigh, nodeImageMin),
+        new Point("D", nodeBoundHigh, (0).toTree()),
+        ...(isConstantFunc
+            ? []
+            : [
+                new Point("E", nodeA.evaluate() > 0 ? nodeBoundHigh : nodeBoundLow, nodeImageMax),
+            ]),
+    ];
+    const dictPoint = arrPoint.reduce((acc, point) => {
+        return {
+            ...acc,
+            [point.name]: point,
+        };
+    }, {});
+    const { A, B, C, D, E } = dictPoint;
+    const [nodeLengthAD, nodeLengthAB] = [
+        [A, D],
+        [A, B],
+    ].map(([point1, point2]) => point1.distanceTo(point2), 0);
+    const nodeRectArea = multiply(nodeLengthAD, nodeLengthAB);
+    const [nodeTriangleArea, nodeIntegral] = (() => {
+        if (E !== undefined) {
+            const nodeLengthCE = (nodeA.evaluate() > 0 ? C.distanceTo(E) : B.distanceTo(E)).toTree();
+            const nodeTriangleArea = frac(multiply(nodeLengthAD, nodeLengthCE), 2);
+            const nodeIntegral = add(nodeRectArea, nodeTriangleArea);
+            return [nodeTriangleArea, nodeIntegral];
+        }
+        else {
+            return [undefined, nodeRectArea];
+        }
+    })();
+    return {
+        nodeF,
+        nodeBoundLow,
+        nodeBoundHigh,
+        nodeImageBoundLow,
+        nodeImageBoundHigh,
+        nodeImageMin,
+        nodeImageMax,
+        dictPoint,
+        nodeLengthAD,
+        nodeLengthAB,
+        nodeRectArea,
+        nodeTriangleArea,
+        nodeIntegral,
+    };
+};
+const getHydrated = (identifiers) => {
+    const { chunkIds, nodeIdsIntegralBounds } = identifiers;
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = nodeIdsIntegralBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrChunk = chunkIds.map((chunkIds) => {
+        const { nodeIdsF, nodeIdsBounds } = chunkIds;
+        const [nodeF, nodeBoundLow, nodeBoundHigh] = [
+            nodeIdsF,
+            ...nodeIdsBounds,
+        ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+        return {
+            nodeF,
+            nodeBoundLow,
+            nodeBoundHigh,
+        };
+    });
+    const arrIntegralChunks = arrChunk.slice(1, -1);
+    const arrIntegralStuff = arrIntegralChunks.map(createDictIntegralStuff);
+    const nodeIntegral = arrIntegralStuff.slice(1).reduce((acc, dictIntegralStuff) => {
+        return add(acc, dictIntegralStuff.nodeIntegral);
+    }, (() => {
+        const [dictIntegralStuffFirst] = arrIntegralStuff;
+        return dictIntegralStuffFirst.nodeIntegral;
+    })());
+    const [nodeImageMin, nodeImageMax] = arrIntegralStuff.slice(1).reduce((acc, { nodeImageMin, nodeImageMax }) => {
+        const [nodeImageMinRunning, nodeImageMaxRunning] = acc;
+        const nodeImageIntegralMin = NodeComparator.compareViaSub(nodeImageMinRunning, nodeImageMin) === -1
+            ? nodeImageMinRunning
+            : nodeImageMin;
+        const nodeImageIntegralMax = NodeComparator.compareViaSub(nodeImageMaxRunning, nodeImageMax) === +1
+            ? nodeImageMaxRunning
+            : nodeImageMax;
+        return [nodeImageIntegralMin, nodeImageIntegralMax];
+    }, (() => {
+        const [dictIntegralStuffFirst] = arrIntegralStuff;
+        return [
+            dictIntegralStuffFirst.nodeImageMin,
+            dictIntegralStuffFirst.nodeImageMax,
+        ];
+    })());
+    return {
+        arrChunk,
+        nodeIntegralBoundLow,
+        nodeIntegralBoundHigh,
+        nodeImageMin,
+        nodeImageMax,
+        arrIntegralStuff,
+        nodeIntegral,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsIntegralBounds } = identifiers;
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = nodeIdsIntegralBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Calculer par lecture graphique l'intégrale entre $${nodeIntegralBoundLow.toTex()}$ et $${nodeIntegralBoundHigh.toTex()}$ de la fonction affine par morceaux $f$ dont la courbe est donnée ci-dessous : `;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIntegral } = getHydrated(identifiers);
+    return nodeIntegral
+        .simplify({ towardsDistribute: true, forbidFactorize: true })
+        .toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsIntegralBounds } = identifiers;
+    const [nodeBoundLow, nodeBoundHigh] = nodeIdsIntegralBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `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()}$.
+Puisqu'elle est définie par morceaux, il faut additionner les intégrales de tous les morceaux compris entre les bornes d'intégration.
+Rappel : pour calculer l'intégrale d'un morceau, l'aire du rectangle et l'aire du triangle qui composent le trapèze contenu sous la courbe du morceau.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralBoundLow, nodeIntegralBoundHigh, arrIntegralStuff, nodeIntegral, } = getHydrated(identifiers);
+    return `Pour calculer l'intégrale de la fonction $f$ entre entre $${nodeIntegralBoundLow.toTex()}$ et $${nodeIntegralBoundHigh.toTex()}$, 
+on détermine l'aire de la surface contenue sous la courbe entre les abscisses $${nodeIntegralBoundLow.toTex()}$ et $${nodeIntegralBoundHigh.toTex()}$.
+On doit donc calculer les intégrales des $${arrIntegralStuff.length}$ morceaux compris entre les bornes d'intégration.
+
+${alignTex(arrIntegralStuff.map(({ nodeIntegral, nodeBoundLow, nodeBoundHigh }) => {
+        return [
+            `\\int_{${nodeBoundLow.toTex()}}^{${nodeBoundHigh.toTex()}} f(x)dx`,
+            "=",
+            nodeIntegral.toTex(),
+        ];
+    }))}
+
+On a donc : 
+
+${alignTex([
+        [
+            `\\int_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}} f(x)dx`,
+            "=",
+            nodeIntegral.toTex(),
+        ],
+        [
+            "",
+            "=",
+            nodeIntegral
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex(),
+        ],
+    ])}
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIntegralBoundLow, nodeIntegralBoundHigh, nodeImageMax, arrChunk, arrIntegralStuff, } = getHydrated(identifiers);
+    const xMin = nodeIntegralBoundLow.evaluate() - 1;
+    const xMax = nodeIntegralBoundHigh.evaluate() + 1;
+    const yMin = -2;
+    const yMax = nodeImageMax.evaluate() + 1;
+    const commands = [
+        //f
+        ...arrChunk.flatMap((chunkOfF, i, arr) => {
+            return createGgbCommandsForChunkOfF(chunkOfF, i, arr);
+        }),
+        //correction
+        ...arrIntegralStuff.flatMap((dictIntegralStuff, i) => {
+            const { dictPoint, nodeRectArea, nodeTriangleArea } = dictIntegralStuff;
+            const { A, B, C, D, E } = dictPoint;
+            return [
+                //boundLow
+                `Llow${i} = Line(${A.toMathString()}, ${B.toMathString()})`,
+                `SetColor(Llow${i}, "#000000")`,
+                //boundHigh
+                `Lhigh${i} = Line(${D.toMathString()}, ${C.toMathString()})`,
+                `SetColor(Lhigh${i}, "#000000")`,
+                //rectangle
+                `Rect${i} = Polygon(${A.toMathString()}, ${B.toMathString()},${C.toMathString()}, ${D.toMathString()})`,
+                `SetColor(Rect${i}, "${greenMain}")`,
+                `SetFilling(Rect${i}, 0.36)`,
+                `SetCaption(Rect${i}, "$\\\\ \\footnotesize \\color{black} ${nodeRectArea
+                    .simplify({ towardsDistribute: true, forbidFactorize: true })
+                    .toTex()}$")`,
+                `ShowLabel(Rect${i}, true)`,
+                //triangle
+                ...(nodeTriangleArea !== undefined
+                    ? [
+                        `Tria${i} = Polygon(${B.toMathString()},${C.toMathString()}, ${E.toMathString()})`,
+                        `SetColor(Tria${i}, "${greenLight}")`,
+                        `SetFilling(Tria${i}, 0.36)`,
+                        `SetCaption(Tria${i}, "$\\footnotesize \\color{black} ${nodeTriangleArea
+                            .simplify({ towardsDistribute: true, forbidFactorize: true })
+                            .toTex()}$")`,
+                        `ShowLabel(Tria${i}, true)`,
+                    ]
+                    : []),
+            ];
+        }),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeIntegralBoundLow, nodeIntegralBoundHigh, nodeImageMax, arrChunk, } = getHydrated(identifiers);
+    const xMin = nodeIntegralBoundLow.evaluate() - 1;
+    const xMax = nodeIntegralBoundHigh.evaluate() + 1;
+    const yMin = -2;
+    const yMax = nodeImageMax.evaluate() + 1;
+    const commands = [
+        //f
+        ...arrChunk.flatMap((chunkOfF, i, arr) => {
+            return createGgbCommandsForChunkOfF(chunkOfF, i, arr);
+        }),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getPropositions = (n, { answer }, optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        nbIntegralChunks: random(arrayedOpts.nbIntegralChunks),
+        typeSignBoundLow: random(arrayedOpts.typeSignBoundLow),
+        typeSignBoundHigh: random(arrayedOpts.typeSignBoundHigh),
+    };
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers(opts);
+        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 createNodeAffineWithBoundsAndImages = (nodeBoundLow, nodeBoundHigh, nodeImageBoundLow, nodeImageBoundHigh) => {
+    const nodeA = frac(substract(nodeImageBoundHigh, nodeImageBoundLow), substract(nodeBoundHigh, nodeBoundLow)).simplify({ towardsDistribute: true, forbidFactorize: true });
+    //f(boundLow) = a * boundLow + b <=> b = f(boundLow) - a * boundLow
+    const nodeB = substract(nodeImageBoundLow, multiply(nodeA, nodeBoundLow)).simplify({ towardsDistribute: true, forbidFactorize: true });
+    return add(multiply(nodeA, new VariableNode("x")), nodeB);
+};
+const createRandomIdentifiers = (opts) => {
+    const valueNbIntegralChunks = parseInt(opts.nbIntegralChunks);
+    const valueNbChunks = valueNbIntegralChunks + 2;
+    const generateValuePositive = (function* () {
+        const arrValue = [...[...Array(15).keys()].map((i) => i + 1)];
+        yield* shuffle([...arrValue]);
+    })();
+    const generateValueNegative = (function* () {
+        const arrValue = [
+            ...[...Array(15).keys()].map((i) => i + 1).map((v) => -v),
+        ];
+        yield* shuffle([...arrValue]);
+    })();
+    const [valueChunkBoundLow, _valueChunkBoundHigh, arrRandomLength] = (() => {
+        if (opts.typeSignBoundLow === "Négative" &&
+            opts.typeSignBoundHigh === "Négative") {
+            const arrRandomLength = [...Array(valueNbChunks).keys()].map(() => randint(2, 6));
+            const valueTotalLengthOfF = arrRandomLength.reduce((acc, v) => acc + v, 0);
+            const valueChunkBoundHigh = generateValueNegative.next().value;
+            const valueChunkBoundLow = valueChunkBoundHigh - valueTotalLengthOfF;
+            return [valueChunkBoundLow, valueChunkBoundHigh, arrRandomLength];
+        }
+        else if (opts.typeSignBoundLow === "Positive" &&
+            opts.typeSignBoundHigh === "Positive") {
+            const arrRandomLength = [...Array(valueNbChunks).keys()].map(() => randint(2, 6));
+            const valueTotalLengthOfF = arrRandomLength.reduce((acc, v) => acc + v, 0);
+            const valueChunkBoundLow = generateValuePositive.next().value;
+            const valueChunkBoundHigh = valueChunkBoundLow + valueTotalLengthOfF;
+            return [valueChunkBoundLow, valueChunkBoundHigh, arrRandomLength];
+        }
+        else {
+            const arrRandomLength = [...Array(valueNbChunks).keys()].map(() => randint(2, 6));
+            const valueTotalLengthOfF = arrRandomLength.reduce((acc, v) => acc + v, 0);
+            const valueChunkBoundLow = -randint(2, valueTotalLengthOfF - 1);
+            const valueChunkBoundHigh = valueChunkBoundLow + valueTotalLengthOfF;
+            return [valueChunkBoundLow, valueChunkBoundHigh, arrRandomLength];
+        }
+    })();
+    const arrChunk = arrRandomLength.reduce((acc, valueChunkLength) => {
+        const { valueChunkBoundLow, valueImageChunkBoundLow, arr } = acc;
+        const [chunkOfFPrevious] = arr.slice(-1);
+        const isPreviousChunkConstant = chunkOfFPrevious !== undefined &&
+            NodeComparator.isEqualViaSub(chunkOfFPrevious.nodeBoundLow, chunkOfFPrevious.nodeBoundHigh);
+        const valueChunkBoundHigh = valueChunkBoundLow + valueChunkLength;
+        const valueImageChunkBoundHigh = valueImageChunkBoundLow +
+            randint(-4, 5, isPreviousChunkConstant ? [0] : []);
+        const [nodeChunkBoundLow, nodeChunkBoundHigh, nodeImageChunkBoundLow, nodeImageChunkBoundHigh,] = [
+            valueChunkBoundLow,
+            valueChunkBoundHigh,
+            valueImageChunkBoundLow,
+            valueImageChunkBoundHigh,
+        ].map((v) => v.toTree());
+        const nodeF = createNodeAffineWithBoundsAndImages(nodeChunkBoundLow, nodeChunkBoundHigh, nodeImageChunkBoundLow, nodeImageChunkBoundHigh);
+        const chunkOfF = {
+            nodeF,
+            nodeBoundLow: nodeChunkBoundLow,
+            nodeBoundHigh: nodeChunkBoundHigh,
+        };
+        acc.arr = [...acc.arr, chunkOfF];
+        acc.valueChunkBoundLow = valueChunkBoundHigh;
+        acc.valueImageChunkBoundLow = valueImageChunkBoundHigh;
+        return acc;
+    }, {
+        arr: [],
+        valueChunkBoundLow,
+        valueImageChunkBoundLow: randint(3, 9),
+    }).arr;
+    const [[chunOfFIntegralFirst], [chunOfFIntegralLast]] = [
+        arrChunk.slice(1),
+        arrChunk.slice(-2),
+    ];
+    const nodeIntegralBoundLow = chunOfFIntegralFirst.nodeBoundLow;
+    const nodeIntegralBoundHigh = chunOfFIntegralLast.nodeBoundHigh;
+    const identifiers = {
+        chunkIds: arrChunk.map(({ nodeBoundLow, nodeBoundHigh, nodeF }) => {
+            return {
+                nodeIdsF: nodeF.toIdentifiers(),
+                nodeIdsBounds: [nodeBoundLow, nodeBoundHigh].map((node) => node.toIdentifiers()),
+            };
+        }),
+        nodeIdsIntegralBounds: [nodeIntegralBoundLow, nodeIntegralBoundHigh].map((node) => node.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getIntegralOfPiecewiseAffineFromGraphQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        nbIntegralChunks: random(arrayedOpts.nbIntegralChunks),
+        typeSignBoundLow: random(arrayedOpts.typeSignBoundLow),
+        typeSignBoundHigh: random(arrayedOpts.typeSignBoundHigh),
+    };
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+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;
+};
+const arrayedOptsDefault = {
+    nbIntegralChunks: ["2"],
+    typeSignBoundLow: ["Positive"],
+    typeSignBoundHigh: ["Positive"],
+};
+const options = [
+    {
+        id: "nbIntegralChunks",
+        label: "Nombre de morceaux dans l'intégrale",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["2", "3", "4"],
+        defaultValue: arrayedOptsDefault.nbIntegralChunks,
+    },
+    {
+        id: "typeSignBoundLow",
+        label: "Signe de la borne inférieure",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Positive", "Négative"],
+        defaultValue: arrayedOptsDefault.typeSignBoundLow,
+    },
+    {
+        id: "typeSignBoundHigh",
+        label: "Signe de la borne supérieure",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Positive", "Négative"],
+        defaultValue: arrayedOptsDefault.typeSignBoundHigh,
+    },
+];
+const validateOptions = (opts) => {
+    if (opts.typeSignBoundLow === "Positive" &&
+        opts.typeSignBoundHigh === "Négative")
+        return {
+            valid: false,
+            message: "La borne inférieure doit pouvoir être inférieure à la borne supérieure.",
+        };
+    return {
+        valid: true,
+        message: "",
+    };
+};
+export const integralOfPiecewiseAffineFromGraph = {
+    id: "integralOfPiecewiseAffineFromGraph",
+    connector: "=",
+    label: "Calculer par lecture graphique une intégrale d'une fonction affine par morceaux",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getIntegralOfPiecewiseAffineFromGraphQuestion(opts), nb),
+    options,
+    validateOptions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    type: number;
+    coeffs: number[];
+    initTable: string[][];
+    rootOfPrimitive: number;
+};
+export declare const varTableOfPrimitiveFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=varTableOfPrimitiveFromGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"varTableOfPrimitiveFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromGraph/varTableOfPrimitiveFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AA8LF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAsB9D,CAAC"}

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

@@ -0,0 +1,192 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { varTableVEA } from "../../../../exercises/vea/varTableVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getRoots = (coeffs) => {
+    const [_d, c, b, a] = coeffs;
+    const sqrtDelta = 2 * Math.sqrt(b ** 2 - 3 * a * c);
+    const x1 = (-2 * b - sqrtDelta) / (6 * a);
+    const x2 = (-2 * b + sqrtDelta) / (6 * a);
+    return [x1, x2].sort((a, b) => a - b);
+};
+const getInstruction = (identifiers) => {
+    const { rootOfPrimitive } = identifiers;
+    return `La courbe représentative d'une fonction $f$ définie sur $\\mathbb{R}$ est donnée ci-dessous. 
+Dresser le tableau de variations de $F$, la primitive de $f$ qui s'annule en $${rootOfPrimitive.frenchify()}$.`;
+};
+const getAnswerTable = (identifiers) => {
+    const { coeffs, rootOfPrimitive } = identifiers;
+    const [_d, _c, _b, a] = coeffs;
+    const [x1, x2] = getRoots(coeffs);
+    const vars = coeffs[3] > 0
+        ? ["\\nearrow", "\\searrow", "\\nearrow"]
+        : ["\\searrow", "\\nearrow", "\\searrow"];
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            x1.toTree().toTex(),
+            "\\ ",
+            x2.toTree().toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        [
+            "$\\ $",
+            "\\ ",
+            "\\ ",
+            a > 0 ? (rootOfPrimitive === x1 ? "0" : "\\ ") : "\\ ",
+            "\\ ",
+            a < 0 ? (rootOfPrimitive === x2 ? "0" : "\\ ") : "\\ ",
+            "\\ ",
+            "\\ ",
+        ],
+        ["$F(x)$", "\\ ", vars[0], "\\ ", vars[1], "\\ ", vars[2], "\\ "],
+        [
+            "$\\ $",
+            "\\ ",
+            "\\ ",
+            a < 0 ? (rootOfPrimitive === x1 ? "0" : "\\ ") : "\\ ",
+            "\\ ",
+            a > 0 ? (rootOfPrimitive === x2 ? "0" : "\\ ") : "\\ ",
+            "\\ ",
+            "\\ ",
+        ],
+    ];
+};
+const getHint = (identifiers) => {
+    const { rootOfPrimitive } = identifiers;
+    return `La fonction est définie sur $\\mathbb{R}$, donc les valeurs de $x$ vont de $-\\infty$ à $+\\infty$.
+
+La fonction $F$ est une primitive de $f$.
+$f$ est donc la dérivée de $F$.
+
+Tu peux donc repérer facilement les points de la courbe auxquels le sens de variation change : ce sont les points où $f$ est nulle.
+Dans la première ligne du tableau, il faut mettre les abscisses de ces points, et dans la deuxième ligne, les ordonnées.
+
+Pour le sens des flèches :
+
+Quand $f$ est positive, $F$ est croissante.
+Quand $f$ est négative, $F$ est décroissante.
+
+N'oublie pas que tu connais la valeur de $F$ en $${rootOfPrimitive.frenchify()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs, rootOfPrimitive } = identifiers;
+    const [_d, _c, _b, a] = coeffs;
+    const [x1, x2] = getRoots(coeffs);
+    const words = a > 0
+        ? ["croissante", "décroissante", "croissante"]
+        : ["décroissante", "croissante", "décroissante"];
+    return `La fonction $F$ est une primitive de $f$.
+$f$ est donc la dérivée de $F$.
+  
+D'après le graphique, la fonction $F$ est ${words[0]} sur $]-\\infty; ${x1}]$, puis ${words[1]} sur $[${x1}; ${x2}]$, puis ${words[2]} sur $[${x2}; +\\infty[$.
+De plus, on sait que $F$ s'annule en $${rootOfPrimitive.frenchify()}$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { coeffs } = identifiers;
+    const nodePrimitive = new Polynomial(coeffs).toTree();
+    const nodeF = nodePrimitive
+        .derivative()
+        .simplify({ towardsDistribute: true, calculatePowers: true });
+    const commands = [`f(x) =${nodeF.toMathString()}`];
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+    });
+    const [x1, x2] = getRoots(coeffs);
+    const fx1 = nodeF.evaluate({ x: x1 });
+    const fx2 = nodeF.evaluate({ x: x2 });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: x1 - 2,
+            xMax: x2 + 2,
+            yMin: Math.min(fx1, fx2) - 2,
+            yMax: Math.max(fx1, fx2) + 2,
+        }),
+    });
+};
+const getKeys = () => {
+    return ["infty"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return varTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+// const lists = [
+//   "x^3 - 3x",
+//   "x^3 -6x^2 + 9x",
+//   "-x^3 + 3x^2 + 9x",
+//   "2x^3 - 9x^2 + 12x",
+//   "-x^3+6x^2-9x",
+//   "4x^3 -24x^2 + 36x",
+// ];
+const poly3Coeffs = [
+    [0, -3, 0, 1],
+    [0, 9, -6, 1],
+    // [0, 9, 3, -1],
+    [0, 12, -9, 2],
+    [0, -9, 6, -1],
+    // [0, 36, -24, 4],
+];
+const getVarTableOfPrimitiveFromGraphQuestion = () => {
+    const index = randint(0, 4);
+    const coeffs = coinFlip()
+        ? poly3Coeffs[index]
+        : poly3Coeffs[index].map((x) => -x);
+    const initTable = [
+        ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+        ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+        ["$F(x)$", "\\ ", "", "", "", "", "", "\\ "],
+        ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+    ];
+    const rootOfPrimitive = random(getRoots(coeffs));
+    const identifiers = {
+        type: 0,
+        coeffs: [coeffs[0] + randint(-10, 10), ...coeffs.slice(1)],
+        initTable,
+        rootOfPrimitive,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const varTableOfPrimitiveFromGraph = {
+    id: "varTableOfPrimitiveFromGraph",
+    label: "Dresser le tableau de variations de la primitive d'une fonction à partir de sa représentation graphique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVarTableOfPrimitiveFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "varTable",
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,4 @@
+export * from "./fromGraph/index.js";
+export * from "./fromExpr/index.js";
+export * from "./integralOfPiecewiseFunctionByUsingComputedIntegrals.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/integration/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,0DAA0D,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./fromGraph/index.js";
+export * from "./fromExpr/index.js";
+export * from "./integralOfPiecewiseFunctionByUsingComputedIntegrals.js";