math-exercises 3.0.199 → 3.0.201

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

@@ -0,0 +1,464 @@
+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, 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 nodeTrapezoidArea = multiply(frac(add(nodeImageMin.simplify({
+        towardsDistribute: true,
+        forceAddFractions: true,
+    }), nodeImageMax.simplify({
+        towardsDistribute: true,
+        forceAddFractions: true,
+    })), 2), substract(nodeBoundHigh, nodeBoundLow));
+    const nodeIntegral = nodeTrapezoidArea;
+    return {
+        nodeF,
+        nodeBoundLow,
+        nodeBoundHigh,
+        nodeImageBoundLow,
+        nodeImageBoundHigh,
+        dictPoint,
+        nodeIntegral,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds } = identifiers;
+    const [nodeF, nodeBoundLow, nodeBoundHigh] = [nodeIdsF, ...nodeIdsBounds].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `En calculant une aire, calculer l'intégrale entre $${nodeBoundLow.toTex()}$ et $${nodeBoundHigh.toTex()}$ de la fonction affine $f$ dont l'expression est : 
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+`;
+};
+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()}$.
+$f$ est une fonction affine, donc l'aire à calculer est celle d'un trapèze.
+
+- Le côté vertical gauche du trapèze a pour longueur $f(${nodeBoundLow.toTex()})$.
+- Le côté vertical droit du trapèze a pour longueur $f(${nodeBoundHigh.toTex()})$.
+- Le côté horizontal bas du trapèze a pour longueur $(${substract(nodeBoundHigh, nodeBoundLow).toTex()})$.
+
+Rappel:
+
+$$
+\\mathcal{A}_{trapèze} = \\frac{ \\text{base}_{1} + \\text{base}_{2} }{2} \\times \\text{hauteur}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeBoundLow, nodeBoundHigh, nodeIntegral, nodeImageBoundLow, nodeImageBoundHigh, } = getHydrated(identifiers);
+    const [texImageBoundLow1, texImageBoundLow2] = [
+        nodeImageBoundLow
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex(),
+        nodeImageBoundLow
+            .simplify({ towardsDistribute: true, forceAddFractions: true })
+            .toTex(),
+    ];
+    const [texImageBoundHigh1, texImageBoundHigh2] = [
+        nodeImageBoundHigh
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex(),
+        nodeImageBoundHigh
+            .simplify({ towardsDistribute: true, forceAddFractions: true })
+            .toTex(),
+    ];
+    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()}$.
+
+$f$ est une fonction affine, donc l'aire à calculer est celle d'un trapèze.
+
+Le côté vertical gauche du trapèze a pour longueur :
+
+${alignTex([
+        [`f(${nodeBoundLow.toTex()})`, "=", texImageBoundLow1],
+        ...(texImageBoundLow2 !== texImageBoundLow1
+            ? [[``, "=", texImageBoundLow2]]
+            : []),
+    ])}
+
+Le côté vertical droit du trapèze a pour longueur :
+
+${alignTex([
+        [`f(${nodeBoundHigh.toTex()})`, "=", texImageBoundHigh1],
+        ...(texImageBoundHigh2 !== texImageBoundHigh1
+            ? [[``, "=", texImageBoundHigh2]]
+            : []),
+    ])}
+
+Le côté horizontal bas du trapèze a pour longueur $${substract(nodeBoundHigh, nodeBoundLow).toTex()} = ${substract(nodeBoundHigh, nodeBoundLow)
+        .simplify({ towardsDistribute: true })
+        .toTex()}$.
+
+On calcule l'aire du trapèze : 
+
+${alignTex([
+        [
+            "\\mathcal{A}_{\\text{trapèze}}",
+            "=",
+            `\\frac{ \\text{base}_{1} + \\text{base}_{2} }{2} \\times \\text{hauteur}`,
+        ],
+        [
+            "",
+            "=",
+            nodeIntegral.toTex({ forceTimesSign: true, forceNoSimplification: true }),
+        ],
+        [
+            "",
+            "=",
+            nodeIntegral
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex(),
+        ],
+    ])}
+
+On a donc : 
+
+${alignTex([
+        [
+            `\\int_{${nodeBoundLow.toTex()}}^{${nodeBoundHigh.toTex()}} f(x)dx`,
+            "=",
+            `\\mathcal{A}_{trapèze}`,
+        ],
+        [
+            "",
+            "=",
+            nodeIntegral
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex(),
+        ],
+    ])}
+
+`;
+};
+const _getCorrectionGGBOptions = (identifiers) => {
+    const { nodeF, nodeBoundHigh, nodeBoundLow, nodeImageBoundLow, nodeImageBoundHigh, dictPoint, nodeIntegral, } = 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")`,
+        //trapezoid
+        nodeImageBoundLow.evaluate() < nodeImageBoundHigh.evaluate()
+            ? `Trap = Polygon(${A.toMathString()}, ${B.toMathString()} ${E !== undefined ? `, ${E.toMathString()}` : ""}, ${D.toMathString()})`
+            : `Trap = Polygon(${A.toMathString()} ${E !== undefined ? `, ${E.toMathString()}` : ""} ,${C.toMathString()}, ${D.toMathString()})`,
+        `SetColor(Trap, "${greenMain}")`,
+        `SetFilling(Trap, 0.36)`,
+        `SetCaption(Trap, "$\\\\ \\footnotesize \\color{black} ${nodeIntegral
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex()}$")`,
+        `ShowLabel(Trap, true)`,
+    ];
+    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 getIntegralOfAffineFromExprByComputingAreaQuestion = (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: [],
+        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 integralOfAffineFromExprByComputingArea = {
+    id: "integralOfAffineFromExprByComputingArea",
+    connector: "=",
+    label: "Calculer une intégrale d'une fonction affine positive en calculant une aire",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getIntegralOfAffineFromExprByComputingAreaQuestion(opts), nb),
+    options,
+    validateOptions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    // hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/integration/fromGraph/integralOfAffineFromGraph.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 integralOfAffineFromGraph: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=integralOfAffineFromGraph.d.ts.map

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

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