math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/integration/fromExpr/boundIntegralByBoundingFunctionWithAffinesFromExpr.js

@@ -0,0 +1,433 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, orange, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { nodeBySubstitutingX } from "../../../../math/utils/functions/functionDecomposition.js";
+import { createIntegratedPolynomialNode } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { IntegralNode } from "../../../../tree/nodes/functions/integralNode.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 { 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 { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds, nodeIdsAffineMinor, nodeIdsAffineMajor, nodeIdsVariableForIntegration, } = identifiers;
+    const [nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh, nodeAffineMinor, nodeAffineMajor, nodeVariableForIntegrationMinor, nodeVariableForIntegrationMajor,] = [
+        nodeIdsF,
+        ...nodeIdsBounds,
+        nodeIdsAffineMinor,
+        nodeIdsAffineMajor,
+        ...nodeIdsVariableForIntegration,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeIntegralMinorForTex, nodeIntegralMajorForTex] = zip([nodeAffineMinor, nodeAffineMajor], [nodeVariableForIntegrationMinor, nodeVariableForIntegrationMajor]).map(([nodeAffine, nodeVariableForIntegration]) => {
+        const varName = nodeVariableForIntegration.name;
+        return new IntegralNode(nodeBySubstitutingX(nodeAffine, varName), nodeIntegralBoundLow, nodeIntegralBoundHigh, varName);
+    });
+    const nodeVarI = new VariableNode("I");
+    const nodeInequationForTex = new InequationNode([nodeIntegralMinorForTex, nodeVarI, nodeIntegralMajorForTex], ["\\le", "\\le"]);
+    const nodeVarX = new VariableNode("x");
+    const [nodeAffineMinorPrimitive, nodeAffineMajorPrimitive] = [
+        nodeAffineMinor,
+        nodeAffineMajor,
+    ].map((nodeAffine) => createIntegratedPolynomialNode(nodeAffine, (0).toTree()).simplify({
+        towardsDistribute: true,
+    }));
+    const [nodeIntegralMinorForResult, nodeIntegralMajorForResult] = [
+        nodeAffineMinorPrimitive,
+        nodeAffineMajorPrimitive,
+    ].map((nodeAffinePrimitive) => substract(nodeBySubstitutingVar(nodeAffinePrimitive, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeAffinePrimitive, nodeIntegralBoundLow, nodeVarX)));
+    const nodeInequationForResult = new InequationNode([
+        nodeIntegralMinorForResult
+            .simplify({
+            towardsDistribute: true,
+            calculatePowers: true,
+        })
+            .simplify({ forceAddFractions: true }),
+        nodeVarI,
+        nodeIntegralMajorForResult
+            .simplify({
+            towardsDistribute: true,
+            calculatePowers: true,
+        })
+            .simplify({ forceAddFractions: true }),
+    ], ["\\le", "\\le"]);
+    return {
+        nodeF,
+        nodeIntegralBoundLow,
+        nodeIntegralBoundHigh,
+        nodeAffineMinor,
+        nodeAffineMajor,
+        nodeAffineMinorPrimitive,
+        nodeAffineMajorPrimitive,
+        nodeInequationForTex,
+        nodeInequationForResult,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsBounds, nodeIdsAffineMinor, nodeIdsAffineMajor } = identifiers;
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh, nodeAffineMinor, nodeAffineMajor,] = [...nodeIdsBounds, nodeIdsAffineMinor, nodeIdsAffineMajor].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Sur le graphique ci-dessous est affichée la courbe représentative de la fonction $f$ telle que :
+
+Pour tout $x$ dans l'intervalle $[${nodeIntegralBoundLow.toTex()};${nodeIntegralBoundHigh.toTex()}]$ :
+  
+$$
+${nodeAffineMinor.toTex()} \\leq f(x) \\leq ${nodeAffineMajor.toTex()}
+$$
+
+En utilisant l'encadrement par les deux fonctions affines, donner un encadrement de : 
+
+$$
+I = \\int_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}} f
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeInequationForResult } = getHydrated(identifiers);
+    return nodeInequationForResult.toTex();
+};
+const getHint = () => {
+    return `Soient $a$ et $b$ deux réels tels que $a<b$. Soient $g,h,l$ trois fonctions définies et intégrables sur $\\mathbb{R}$.
+
+Si, pour tout $x$ de l'intervalle $[a;b]$ :
+
+$$
+g(x) \\leq h(x) \\leq l(x)
+$$
+
+alors
+
+$$
+\\int_{a}^{b} g  \\leq \\int_{a}^{b} h  \\leq \\int_{a}^{b} l
+$$
+
+Il te faut donc intégrer les deux fonctions affines qui encadrent la fonction $f$ sur l'intervalle donné.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralBoundLow, nodeIntegralBoundHigh, nodeAffineMinor, nodeAffineMajor, nodeAffineMinorPrimitive, nodeAffineMajorPrimitive, nodeInequationForTex, nodeInequationForResult, } = getHydrated(identifiers);
+    const _texNotWorking = (() => {
+        const [arrTex1, arrTex3] = [
+            nodeInequationForTex,
+            nodeInequationForResult,
+        ].map((nodeInequation) => nodeInequation
+            .toTex()
+            .split("\\leq")
+            .reduce((acc, tex) => [...acc, "\\leq", tex], [])
+            .slice(1));
+        return `${alignTex([
+            arrTex1,
+            [
+                `\\left[ ${nodeAffineMinorPrimitive.toTex()} \\right]_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}}`,
+                `\\leq`,
+                `I`,
+                `\\leq`,
+                `\\left[ ${nodeAffineMajorPrimitive.toTex()} \\right]_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}}`,
+            ],
+            arrTex3,
+        ])}`;
+    })();
+    return `Pour tout réel $x$ dans l'intervalle $[${nodeIntegralBoundLow.toTex()};${nodeIntegralBoundHigh.toTex()}]$, on a :
+  
+$$
+${nodeAffineMinor.toTex()} \\leq f(x) \\leq ${nodeAffineMajor.toTex()}
+$$
+
+Par conséquent : 
+
+$$
+${nodeInequationForTex.toTex()}
+$$
+
+$$
+${[
+        `\\left[ ${nodeAffineMinorPrimitive.toTex()} \\right]_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}}`,
+        `\\leq`,
+        `I`,
+        `\\leq`,
+        `\\left[ ${nodeAffineMajorPrimitive.toTex()} \\right]_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}}`,
+    ].join(" ")}
+$$
+
+$$
+${nodeInequationForResult.toTex()}
+$$`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds, nodeIdsAffineMinor, nodeIdsAffineMajor } = identifiers;
+    const [nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh, nodeAffineMinor, nodeAffineMajor,] = [nodeIdsF, ...nodeIdsBounds, nodeIdsAffineMinor, nodeIdsAffineMajor].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const xMin = nodeIntegralBoundLow.evaluate() - 1;
+    const xMax = nodeIntegralBoundHigh.evaluate() + 1;
+    const yMin = -1.5;
+    const yMax = (() => {
+        const valueBoundLow = nodeIntegralBoundLow.evaluate();
+        const valueBoundHigh = nodeIntegralBoundHigh.evaluate();
+        const nbSteps = 50;
+        const valueStepAbscissa = (valueBoundHigh - valueBoundLow) / nbSteps;
+        return [...Array(nbSteps).keys()].reduce((acc, i) => {
+            const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+            const valueImageI = nodeAffineMajor.evaluate({ x: valueAbscissa });
+            if (i === 0) {
+                return valueImageI;
+            }
+            else {
+                return Math.max(acc, valueImageI);
+            }
+        });
+    })();
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `affminor = 0 * x +${nodeAffineMinor.toMathString()}`,
+        `SetColor(affminor, "${orange}")`,
+        `affmajor = 0 * x + ${nodeAffineMajor.toMathString()}`,
+        `SetColor(affmajor, "${orange}")`,
+        //integrals
+        `integralMinor = Integral(${nodeAffineMinor.toMathString()},${nodeIntegralBoundLow.toMathString()},${nodeIntegralBoundHigh.toMathString()})`,
+        `SetColor(integralMinor, "${blueMain}")`,
+        `SetFilling(integralMinor, 0.9)`,
+        `ShowLabel(integralMinor, false)`,
+        `integralMajor = Integral(${nodeAffineMajor.toMathString()},${nodeIntegralBoundLow.toMathString()},${nodeIntegralBoundHigh.toMathString()})`,
+        `SetColor(integralMajor, "${red}")`,
+        `SetFilling(integralMajor, 0.3)`,
+        `ShowLabel(integralMajor, false)`,
+        `integralI = Integral(${nodeF.toMathString()},${nodeIntegralBoundLow.toMathString()},${nodeIntegralBoundHigh.toMathString()})`,
+        `SetColor(integralI, "${greenMain}")`,
+        `SetFilling(integralI, 0.7)`,
+        `ShowLabel(integralI, false)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: (xMax - xMin) / (yMax - yMin),
+        yAxis: {
+            hideNumbers: true,
+        },
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds, nodeIdsAffineMinor, nodeIdsAffineMajor } = identifiers;
+    const [nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh, nodeAffineMinor, nodeAffineMajor,] = [nodeIdsF, ...nodeIdsBounds, nodeIdsAffineMinor, nodeIdsAffineMajor].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const xMin = nodeIntegralBoundLow.evaluate() - 1;
+    const xMax = nodeIntegralBoundHigh.evaluate() + 1;
+    const yMin = -1.5;
+    const yMax = (() => {
+        const valueBoundLow = nodeIntegralBoundLow.evaluate();
+        const valueBoundHigh = nodeIntegralBoundHigh.evaluate();
+        const nbSteps = 50;
+        const valueStepAbscissa = (valueBoundHigh - valueBoundLow) / nbSteps;
+        return [...Array(nbSteps).keys()].reduce((acc, i) => {
+            const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+            const valueImageI = nodeAffineMajor.evaluate({ x: valueAbscissa });
+            if (i === 0) {
+                return valueImageI;
+            }
+            else {
+                return Math.max(acc, valueImageI);
+            }
+        });
+    })();
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `affminor = 0 * x + ${nodeAffineMinor.toMathString()}`,
+        `SetColor(affminor, "${orange}")`,
+        `affmajor = 0 * x + ${nodeAffineMajor.toMathString()}`,
+        `SetColor(affmajor, "${orange}")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: (xMax - xMin) / (yMax - yMin),
+        yAxis: {
+            hideNumbers: true,
+        },
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+    });
+};
+const getPropositions = (n, { answer }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers(opts);
+        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 = (opts) => {
+    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 valueTotalLengthOfF = randint(5, 11);
+    const [valueBoundLow, valueBoundHigh] = (() => {
+        if (opts.typeSignBoundLow === "Négative" &&
+            opts.typeSignBoundHigh === "Négative") {
+            const valueBoundHigh = generateValueNegative.next().value;
+            const valueBoundLow = valueBoundHigh - valueTotalLengthOfF;
+            return [valueBoundLow, valueBoundHigh];
+        }
+        else if (opts.typeSignBoundLow === "Positive" &&
+            opts.typeSignBoundHigh === "Positive") {
+            const valueBoundLow = generateValuePositive.next().value;
+            const valueBoundHigh = valueBoundLow + valueTotalLengthOfF;
+            return [valueBoundLow, valueBoundHigh];
+        }
+        else {
+            const valueBoundLow = -randint(2, valueTotalLengthOfF - 1);
+            const valueBoundHigh = valueBoundLow + valueTotalLengthOfF;
+            return [valueBoundLow, valueBoundHigh];
+        }
+    })();
+    const [nodeBoundLow, nodeBoundHigh] = [valueBoundLow, valueBoundHigh].map((v) => v.toTree());
+    const nodeVarX = new VariableNode("x");
+    const valueImageLowMinor = randint(1, 6);
+    const valueImageHighMinor = valueImageLowMinor + randint(1, 6);
+    const valueImageLowMajor = valueImageLowMinor + randint(1, 6);
+    const valueImageHighMajor = valueImageHighMinor + randint(1, 6);
+    function createNodeAffineFromCoords(coordsLow, coordsHigh) {
+        const nodeA = frac(coordsHigh[1] - coordsLow[1], coordsHigh[0] - coordsLow[0]);
+        //y0 = a x0 + b => b = y0 - a x0
+        const nodeB = substract(coordsLow[1], multiply(nodeA, coordsLow[0]));
+        return add(multiply(nodeA, nodeVarX), nodeB).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+    }
+    const nodeAffineMinor = createNodeAffineFromCoords([valueBoundLow, valueImageLowMinor], [valueBoundHigh, valueImageHighMinor]);
+    const nodeAffineMajor = createNodeAffineFromCoords([valueBoundLow, valueImageLowMajor], [valueBoundHigh, valueImageHighMajor]);
+    const nodeF = add(multiply(multiply(frac(1, 2), add(1, cos(nodeVarX))), nodeAffineMinor), multiply(multiply(frac(1, 2), substract(1, cos(nodeVarX))), nodeAffineMajor));
+    const [nodeVariableForIntegrationMinor, nodeVariableForIntegrationMajor] = shuffle(["x", "t", "u"]).map((letter) => new VariableNode(letter));
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsBounds: [nodeBoundLow, nodeBoundHigh].map((node) => node.toIdentifiers()),
+        nodeIdsAffineMinor: nodeAffineMinor.toIdentifiers(),
+        nodeIdsAffineMajor: nodeAffineMajor.toIdentifiers(),
+        nodeIdsVariableForIntegration: [
+            nodeVariableForIntegrationMinor,
+            nodeVariableForIntegrationMajor,
+        ].map((node) => node.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getBoundIntegralByBoundingFunctionWithAffinesFromExprQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    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;
+};
+const optsDefault = {
+    typeSignBoundLow: "Positive",
+    typeSignBoundHigh: "Positive",
+};
+const options = [
+    {
+        id: "typeSignBoundLow",
+        label: "Signe de la borne inférieure",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Positive", "Négative"],
+        defaultValue: optsDefault.typeSignBoundLow,
+    },
+    {
+        id: "typeSignBoundHigh",
+        label: "Signe de la borne supérieure",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Positive", "Négative"],
+        defaultValue: optsDefault.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 boundIntegralByBoundingFunctionWithAffinesFromExpr = {
+    id: "boundIntegralByBoundingFunctionWithAffinesFromExpr",
+    connector: "=",
+    label: "Donner un encadrement d'une intégrale pour une fonction comprise entre deux fonctions affines sur un intervalle",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getBoundIntegralByBoundingFunctionWithAffinesFromExprQuestion(opts), nb),
+    options,
+    validateOptions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/integration/fromExpr/boundIntegralByManualRectanglesMethodFromExpr.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[];
+    nbRectanglesRequired: number;
+};
+type Options = {
+    nbRectangles: string;
+    typeSignBoundLow: string;
+    typeSignBoundHigh: string;
+};
+export declare const boundIntegralByManualRectanglesMethodFromExpr: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=boundIntegralByManualRectanglesMethodFromExpr.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boundIntegralByManualRectanglesMethodFromExpr.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/boundIntegralByManualRectanglesMethodFromExpr.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAycF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAkDF,eAAO,MAAM,6CAA6C,EAAE,QAAQ,CAClE,WAAW,EACX,OAAO,CAsBR,CAAC"}