math-exercises 3.0.199 → 3.0.201

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

@@ -0,0 +1,436 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { lowerSum, upperSum, } from "../../../../math/utils/integration/rectanglesMethod.js";
+import { randint } from "../../../../math/utils/random/randint.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 { power, square } from "../../../../tree/nodes/operators/powerNode.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, nbRectanglesRequired } = identifiers;
+    const [nodeF, nodeBoundLow, nodeBoundHigh] = [nodeIdsF, ...nodeIdsBounds].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeBoundSpan = substract(nodeBoundHigh, nodeBoundLow).simplify({
+        towardsDistribute: true,
+    });
+    const nodeLengthRectangle = frac(nodeBoundSpan, nbRectanglesRequired).simplify({ towardsDistribute: true });
+    const arrNodeAbscissa = [...Array(nbRectanglesRequired + 1).keys()].map((i) => add(nodeBoundLow, multiply(i, nodeLengthRectangle)).simplify({
+        towardsDistribute: true,
+    }));
+    const arrNodeImageVar = arrNodeAbscissa.map((nodeAbscissa) => new VariableNode(`f(${nodeAbscissa.toTex()})`));
+    const [nodeLowerSumFormula, nodeUpperSumFormula] = [
+        arrNodeImageVar.slice(0, -1),
+        arrNodeImageVar.slice(1),
+    ].map((arrNodeImageVar) => arrNodeImageVar.reduce((acc, nodeImage, i) => {
+        const nodeRectArea = multiply(nodeImage, nodeLengthRectangle);
+        if (i === 0) {
+            return nodeRectArea;
+        }
+        else {
+            return add(acc, nodeRectArea);
+        }
+    }, (0).toTree()));
+    const isShouldSimplifyAbscissa = true;
+    const [nodeLowerSum, nodeUpperSum] = [lowerSum, upperSum].map((funcSum) => funcSum(nodeF, nodeBoundLow, nodeBoundHigh, nbRectanglesRequired, isShouldSimplifyAbscissa));
+    const nodeVarI = new VariableNode("I");
+    const nodeInequation = new InequationNode([
+        nodeLowerSum.simplify({
+            towardsDistribute: true,
+            calculatePowers: true,
+        }),
+        nodeVarI,
+        nodeUpperSum.simplify({
+            towardsDistribute: true,
+            calculatePowers: true,
+        }),
+    ], ["\\le", "\\le"]);
+    return {
+        nodeF,
+        nodeBoundLow,
+        nodeBoundHigh,
+        nodeLowerSum,
+        nodeUpperSum,
+        nodeInequation,
+        nodeLowerSumFormula,
+        nodeUpperSumFormula,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds, nbRectanglesRequired } = identifiers;
+    const [nodeF, nodeBoundLow, nodeBoundHigh] = [nodeIdsF, ...nodeIdsBounds].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Sur le graphique ci-dessous est affichée la courbe représentative de la fonction $f$ définie sur $\\mathbb{R}$ par :
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+En utilisant la méthode des rectangles avec $${nbRectanglesRequired}$ rectangles, donner un encadrement de : 
+
+$$
+I = \\int_{${nodeBoundLow.toTex()}}^{${nodeBoundHigh.toTex()}} f
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeInequation } = getHydrated(identifiers);
+    return nodeInequation.toTex();
+};
+const getHint = () => {
+    return `On va nommer $a$ et $b$ les deux bornes d'intégration.
+Calcule la longueur entre les deux bornes d'intégration, puis divise-la par le nombre $n$ de rectangles que tu vas utiliser pour chaque somme.
+La longueur de chaque rectangle sera :
+
+$$
+l = \\frac{b-a}{n}
+$$
+
+Tu peux ainsi calculer les abscisses $(x_{i})$ que tu vas utiliser dans tes calculs.
+
+Pour $i$ allant de $0$ à $n$ inclus :
+
+$$
+x_{i} = a + il
+$$
+
+
+Ensuite, calcule les deux sommes : 
+
+$$
+S_{\\text{gauche}} = f(x_{0}) \\times l + ... + f(x_{n-1}) \\times l
+$$
+
+$$
+S_{\\text{droite}} = f(x_{1}) \\times l + ... + f(x_{n}) \\times l
+$$
+
+Tu peux alors affirmer que, puisque $f$ est croissante sur l'intervalle d'intégration,
+
+$$
+S_{\\text{gauche}} \\leq I \\leq S_{\\text{droite}}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nbRectanglesRequired } = identifiers;
+    const { nodeLowerSum, nodeUpperSum, nodeLowerSumFormula, nodeUpperSumFormula, nodeInequation, } = getHydrated(identifiers);
+    return `Avec $${nbRectanglesRequired.frenchify()}$ rectangles utilisés pour chaque somme, on a :
+
+${alignTex([
+        [
+            "S_{\\text{gauche}}",
+            "=",
+            nodeLowerSumFormula.toTex({
+                forceNoSimplification: true,
+                forceTimesSign: true,
+                forceParenthesis: true,
+            }),
+        ],
+        ["", "=", nodeLowerSum.toTex({ forceNoSimplification: true })],
+        [
+            "",
+            "=",
+            nodeLowerSum
+                .simplify({ towardsDistribute: true, calculatePowers: true })
+                .toTex(),
+        ],
+    ])}
+
+${alignTex([
+        [
+            "S_{\\text{droite}}",
+            "=",
+            nodeUpperSumFormula.toTex({ forceNoSimplification: true }),
+        ],
+        ["", "=", nodeUpperSum.toTex({ forceNoSimplification: true })],
+        [
+            "",
+            "=",
+            nodeUpperSum
+                .simplify({ towardsDistribute: true, calculatePowers: true })
+                .toTex(),
+        ],
+    ])}
+
+La $f$ est croissante sur l'intervalle d'intégration, par conséquent :
+
+$$
+${nodeInequation.toTex()}
+$$ 
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nbRectanglesRequired } = identifiers;
+    const { nodeF, nodeBoundHigh, nodeBoundLow } = getHydrated(identifiers);
+    const xMin = nodeBoundLow.evaluate() - 1;
+    const xMax = nodeBoundHigh.evaluate() + 1;
+    const yMin = -1.5;
+    const yMax = (() => {
+        const valueBoundLow = nodeBoundLow.evaluate();
+        const valueBoundHigh = nodeBoundHigh.evaluate();
+        const nbSteps = 50;
+        const valueStepAbscissa = (valueBoundHigh - valueBoundLow) / nbSteps;
+        return [...Array(nbSteps).keys()].reduce((acc, i) => {
+            const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+            const valueImageI = nodeF.evaluate({ x: valueAbscissa });
+            if (i === 0) {
+                return valueImageI;
+            }
+            else {
+                return Math.max(acc, valueImageI);
+            }
+        });
+    })();
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        //slider a
+        `a=${nodeBoundLow.toMathString()}`,
+        //slider b
+        `b=${nodeBoundHigh.toMathString()}`,
+        //slider n
+        `n=${nbRectanglesRequired}`,
+        //rect sums
+        `surfLowerSum = LowerSum(f,a,b,n)`,
+        `ShowLabel(surfLowerSum, false)`,
+        `surfUpperSum = UpperSum(f,a,b,n)`,
+        `ShowLabel(surfUpperSum, 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 { nodeF, nodeBoundHigh, nodeBoundLow } = getHydrated(identifiers);
+    const xMin = nodeBoundLow.evaluate() - 1;
+    const xMax = nodeBoundHigh.evaluate() + 1;
+    const yMin = -1.5;
+    const yMax = (() => {
+        const valueBoundLow = nodeBoundLow.evaluate();
+        const valueBoundHigh = nodeBoundHigh.evaluate();
+        const nbSteps = 50;
+        const valueStepAbscissa = (valueBoundHigh - valueBoundLow) / nbSteps;
+        return [...Array(nbSteps).keys()].reduce((acc, i) => {
+            const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+            const valueImageI = nodeF.evaluate({ x: valueAbscissa });
+            if (i === 0) {
+                return valueImageI;
+            }
+            else {
+                return Math.max(acc, valueImageI);
+            }
+        });
+    })();
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+    ];
+    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 valueNbChunks = parseInt(opts.nbRectangles);
+    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 [valueBoundLow, valueBoundHigh] = (() => {
+        const valueLengthRectangle = randint(1, 6);
+        const valueTotalLengthOfF = valueLengthRectangle * valueNbChunks;
+        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 valueOffsetX = valueBoundLow - randint(4, 10);
+    const nodeVarXOffsetted = substract(nodeVarX, valueOffsetX).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const nodeF = (() => {
+        const rand = randint(0, 2);
+        switch (rand) {
+            case 0: {
+                return add(multiply(randint(1, 4), square(nodeVarXOffsetted)), randint(1, 4));
+            }
+            case 1: {
+                return add(multiply(randint(1, 4), power(nodeVarXOffsetted, 3)), randint(1, 4));
+            }
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    })();
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsBounds: [nodeBoundLow, nodeBoundHigh].map((node) => node.toIdentifiers()),
+        nbRectanglesRequired: valueNbChunks,
+    };
+    return identifiers;
+};
+const getBoundIntegralByManualRectanglesMethodFromExprQuestion = (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 = {
+    nbRectangles: "2",
+    typeSignBoundLow: "Positive",
+    typeSignBoundHigh: "Positive",
+};
+const options = [
+    {
+        id: "nbRectangles",
+        label: "Nombre de rectangles",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["2", "3", "4"],
+        defaultValue: optsDefault.nbRectangles,
+    },
+    {
+        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 boundIntegralByManualRectanglesMethodFromExpr = {
+    id: "boundIntegralByManualRectanglesMethodFromExpr",
+    connector: "=",
+    label: "Obtenir un encadrement d'une intégrale par la mise en oeuvre manuelle de la méthode des rectangles",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getBoundIntegralByManualRectanglesMethodFromExprQuestion(opts), nb),
+    options,
+    validateOptions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,3 @@
+export * from "./integralOfAXPlusBTimesExpKXByParts.js";
+export * from "./integralOfPolynomialTimesLogXByParts.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/integration/fromExpr/byParts/index.ts"],"names":[],"mappings":"AAAA,cAAc,yCAAyC,CAAC;AACxD,cAAc,2CAA2C,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from "./integralOfAXPlusBTimesExpKXByParts.js";
+export * from "./integralOfPolynomialTimesLogXByParts.js";

package/lib/exercises/math/integration/fromExpr/byParts/integralOfAXPlusBTimesExpKXByParts.d.ts

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

package/lib/exercises/math/integration/fromExpr/byParts/integralOfAXPlusBTimesExpKXByParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integralOfAXPlusBTimesExpKXByParts.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/integration/fromExpr/byParts/integralOfAXPlusBTimesExpKXByParts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA0B7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;CACnD,CAAC;AA8SF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAiBpE,CAAC"}