math-exercises 3.0.199 → 3.0.201

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

@@ -0,0 +1,493 @@
+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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } 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 getHydrated = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds, isConstantFunc } = identifiers;
+    const [nodeF, nodeBoundLow, nodeBoundHigh] = [nodeIdsF, ...nodeIdsBounds].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeImageBoundLow, nodeImageBoundHigh] = [
+        nodeBoundLow,
+        nodeBoundHigh,
+    ].map((nodeBound) => nodeBySubstitutingVar(nodeF, nodeBound, new VariableNode("x")).simplify({
+        towardsDistribute: true,
+    }));
+    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));
+    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,
+        dictPoint,
+        nodeLengthAD,
+        nodeLengthAB,
+        nodeRectArea,
+        nodeTriangleArea,
+        nodeIntegral,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsBounds } = identifiers;
+    const [nodeBoundLow, nodeBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Calculer par lecture graphique l'intégrale entre $${nodeBoundLow.toTex()}$ et $${nodeBoundHigh.toTex()}$ de la fonction affine $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 { nodeIdsBounds } = identifiers;
+    const [nodeBoundLow, nodeBoundHigh] = nodeIdsBounds.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()}$.
+Tu la peux calculer en additionnant l'aire du rectangle et l'aire du triangle qui composent le trapèze contenu sous la courbe.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeBoundLow, nodeBoundHigh, nodeRectArea, nodeTriangleArea, nodeIntegral, } = getHydrated(identifiers);
+    return `Pour calculer l'intégrale de la fonction $f$ entre entre $${nodeBoundLow.toTex()}$ et $${nodeBoundHigh.toTex()}$, 
+on détermine l'aire de la surface contenue sous la courbe entre les abscisses $${nodeBoundLow.toTex()}$ et $${nodeBoundHigh.toTex()}$.
+
+On calcule l'aire du rectangle : 
+
+${alignTex([
+        [
+            "\\mathcal{A}_{rect}",
+            "=",
+            nodeRectArea.toTex({ forceTimesSign: true, forceNoSimplification: true }),
+        ],
+        [
+            "",
+            "=",
+            nodeRectArea
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex(),
+        ],
+    ])}
+
+${(() => {
+        if (nodeTriangleArea !== undefined) {
+            return `On calcule l'aire du triangle : 
+
+${alignTex([
+                [
+                    "\\mathcal{A}_{triangle}",
+                    "=",
+                    nodeTriangleArea.toTex({
+                        forceTimesSign: true,
+                        forceNoSimplification: true,
+                    }),
+                ],
+                [
+                    "",
+                    "=",
+                    nodeTriangleArea
+                        .simplify({ towardsDistribute: true, forbidFactorize: true })
+                        .toTex(),
+                ],
+            ])}
+
+On a donc : 
+
+${alignTex([
+                [
+                    `\\int_{${nodeBoundLow.toTex()}}^{${nodeBoundHigh.toTex()}} f(x)dx`,
+                    "=",
+                    `\\mathcal{A}_{rectangle} + \\mathcal{A}_{triangle}`,
+                ],
+                [
+                    "",
+                    "=",
+                    nodeIntegral
+                        .simplify({ towardsDistribute: true, forbidFactorize: true })
+                        .toTex(),
+                ],
+            ])}
+
+`;
+        }
+        else {
+            return `On a donc : 
+
+${alignTex([
+                [
+                    `\\int_{${nodeBoundLow.toTex()}}^{${nodeBoundHigh.toTex()}} f(x)dx`,
+                    "=",
+                    `\\mathcal{A}_{rectangle}`,
+                ],
+                [
+                    "",
+                    "=",
+                    nodeIntegral
+                        .simplify({ towardsDistribute: true, forbidFactorize: true })
+                        .toTex(),
+                ],
+            ])}
+
+`;
+        }
+    })()}
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeF, nodeBoundHigh, nodeBoundLow, nodeImageBoundLow, nodeImageBoundHigh, dictPoint, nodeRectArea, nodeTriangleArea, } = getHydrated(identifiers);
+    const { A, B, C, D, E } = dictPoint;
+    const xMin = nodeBoundLow.evaluate() - 1;
+    const xMax = nodeBoundHigh.evaluate() + 1;
+    const yMin = -1.5;
+    const yMax = Math.max(nodeImageBoundLow.evaluate(), nodeImageBoundHigh.evaluate());
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        //boundLow
+        `Llow = Line(${A.toMathString()}, ${B.toMathString()})`,
+        `SetColor(Llow, "#000000")`,
+        //boundHigh
+        `Lhigh = Line(${D.toMathString()}, ${C.toMathString()})`,
+        `SetColor(Lhigh, "#000000")`,
+        //rectangle
+        `Rect = Polygon(${A.toMathString()}, ${B.toMathString()},${C.toMathString()}, ${D.toMathString()})`,
+        `SetColor(Rect, "${greenMain}")`,
+        `SetFilling(Rect, 0.36)`,
+        `SetCaption(Rect, "$\\\\ \\footnotesize \\color{black} ${nodeRectArea
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex()}$")`,
+        `ShowLabel(Rect, true)`,
+        //triangle
+        ...(nodeTriangleArea !== undefined
+            ? [
+                `Tria = Polygon(${B.toMathString()},${C.toMathString()}, ${E.toMathString()})`,
+                `SetColor(Tria, "${greenLight}")`,
+                `SetFilling(Tria, 0.36)`,
+                `SetCaption(Tria, "$\\footnotesize \\color{black} ${nodeTriangleArea
+                    .simplify({ towardsDistribute: true, forbidFactorize: true })
+                    .toTex()}$")`,
+                `ShowLabel(Tria, true)`,
+            ]
+            : []),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeF, nodeBoundHigh, nodeBoundLow, nodeImageBoundLow, nodeImageBoundHigh, } = getHydrated(identifiers);
+    const xMin = nodeBoundLow.evaluate() - 1;
+    const xMax = nodeBoundHigh.evaluate() + 1;
+    const yMin = -1.5;
+    const yMax = Math.max(nodeImageBoundLow.evaluate(), nodeImageBoundHigh.evaluate());
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getPropositions = (n, { answer }, optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        functionType: random(arrayedOpts.functionType),
+        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 createRandomIdentifiers = (opts) => {
+    const isConstantFunc = opts.functionType === "Constante";
+    const generateValuePositive = (function* () {
+        const arrValue = [...[...Array(8).keys()].map((i) => i + 1)];
+        yield* shuffle([...arrValue]);
+    })();
+    const generateValueNegative = (function* () {
+        const arrValue = [...[...Array(8).keys()].map((i) => i + 1).map((v) => -v)];
+        yield* shuffle([...arrValue]);
+    })();
+    const [nodeBoundLow, nodeBoundHigh, nodeF] = (() => {
+        switch (opts.functionType) {
+            case "Affine": {
+                const nodeBoundLowCandidate = (() => {
+                    const value = (opts.typeSignBoundLow === "Positive"
+                        ? generateValuePositive.next().value
+                        : generateValueNegative.next().value);
+                    return value.toTree();
+                })();
+                const nodeBoundHighCandidate = (() => {
+                    const value = (opts.typeSignBoundHigh === "Positive"
+                        ? generateValuePositive.next().value
+                        : generateValueNegative.next().value);
+                    return value.toTree();
+                })();
+                const [nodeBoundLow, nodeBoundHigh] = [
+                    nodeBoundLowCandidate,
+                    nodeBoundHighCandidate,
+                ].toSorted((node1, node2) => node1.evaluate() - node2.evaluate());
+                const [nodeImageBoundLow, nodeImageBoundHigh] = (() => {
+                    const isSlopePositive = coinFlip();
+                    if (isSlopePositive) {
+                        const nodeImageBoundLow = randint(1, 6).toTree();
+                        const nodeImageBoundHigh = add(nodeImageBoundLow, randint(1, 4).toTree()).simplify();
+                        return [nodeImageBoundLow, nodeImageBoundHigh];
+                    }
+                    else {
+                        const [nodeImageBoundHigh, nodeImageBoundLow] = randomMany([...Array(9).keys()].map((i) => i + 1), 2)
+                            .toSorted((v1, v2) => v1 - v2)
+                            .map((v) => v.toTree());
+                        return [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 });
+                const nodeF = add(multiply(nodeA, new VariableNode("x")), nodeB);
+                return [nodeBoundLow, nodeBoundHigh, nodeF];
+            }
+            case "Linéaire": {
+                const valueBoundClose = randint(1, 4);
+                const valueImageBoundClose = randint(1, valueBoundClose + 1);
+                const valueFactor = randint(2, 4);
+                const [valueBoundFar, _valueImageBoundFar] = [
+                    valueBoundClose,
+                    valueImageBoundClose,
+                ].map((v) => v * valueFactor);
+                if (opts.typeSignBoundLow === "Positive") {
+                    const [nodeBoundLow, nodeBoundHigh] = [
+                        valueBoundClose.toTree(),
+                        valueBoundFar.toTree(),
+                    ];
+                    const nodeA = frac(valueImageBoundClose, valueBoundClose).simplify({
+                        towardsDistribute: true,
+                        forbidFactorize: true,
+                    });
+                    const nodeF = multiply(nodeA, new VariableNode("x"));
+                    return [nodeBoundLow, nodeBoundHigh, nodeF];
+                }
+                else {
+                    const [nodeBoundLow, nodeBoundHigh] = [
+                        (-valueBoundFar).toTree(),
+                        (-valueBoundClose).toTree(),
+                    ];
+                    const nodeA = frac(valueImageBoundClose, -valueBoundClose).simplify({
+                        towardsDistribute: true,
+                        forbidFactorize: true,
+                    });
+                    const nodeF = multiply(nodeA, new VariableNode("x"));
+                    return [nodeBoundLow, nodeBoundHigh, nodeF];
+                }
+            }
+            case "Constante": {
+                const nodeBoundLowCandidate = (() => {
+                    const value = (opts.typeSignBoundLow === "Positive"
+                        ? generateValuePositive.next().value
+                        : generateValueNegative.next().value);
+                    return value.toTree();
+                })();
+                const nodeBoundHighCandidate = (() => {
+                    const value = (opts.typeSignBoundHigh === "Positive"
+                        ? generateValuePositive.next().value
+                        : generateValueNegative.next().value);
+                    return value.toTree();
+                })();
+                const [nodeBoundLow, nodeBoundHigh] = [
+                    nodeBoundLowCandidate,
+                    nodeBoundHighCandidate,
+                ].toSorted((node1, node2) => node1.evaluate() - node2.evaluate());
+                const nodeB = randint(2, 10).toTree();
+                const nodeF = nodeB;
+                return [nodeBoundLow, nodeBoundHigh, nodeF];
+            }
+            default:
+                throw new Error("Unsupported opts.functionType: " + opts.functionType);
+        }
+    })();
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsBounds: [nodeBoundLow, nodeBoundHigh].map((node) => node.toIdentifiers()),
+        isConstantFunc,
+    };
+    return identifiers;
+};
+const getIntegralOfAffineFromGraphQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        functionType: random(arrayedOpts.functionType),
+        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 = {
+    functionType: ["Affine"],
+    typeSignBoundLow: ["Positive"],
+    typeSignBoundHigh: ["Positive"],
+};
+const options = [
+    {
+        id: "functionType",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Affine", "Linéaire", "Constante"],
+        defaultValue: arrayedOptsDefault.functionType,
+    },
+    {
+        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.functionType === "Linéaire" &&
+        opts.typeSignBoundLow !== opts.typeSignBoundHigh) {
+        return {
+            valid: false,
+            message: "Pour une fonction linéaire, les deux bornes doivent être de même signe.",
+        };
+    }
+    else 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 integralOfAffineFromGraph = {
+    id: "integralOfAffineFromGraph",
+    connector: "=",
+    label: "Calculer par lecture graphique une intégrale d'une fonction affine",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getIntegralOfAffineFromGraphQuestion(opts), nb),
+    options,
+    validateOptions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"integralOfPiecewiseAffineFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromGraph/integralOfPiecewiseAffineFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiC7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,qBAAqB,EAAE,eAAe,EAAE,CAAC;CAC1C,CAAC;AAyiBF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAwDF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,WAAW,EACX,OAAO,CAsBR,CAAC"}