math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/integration/fromExpr/meanValue/meanValueOfTrinomFromIntegralFromExpr.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsForP: NodeIdentifiers[];
+    nodeIdsBounds: [NodeIdentifiers, NodeIdentifiers];
+};
+type Options = {
+    nbChangesOfSign: string;
+    typeSignBoundLow: string;
+    typeSignBoundHigh: string;
+};
+export declare const meanValueOfTrinomFromIntegralFromExpr: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=meanValueOfTrinomFromIntegralFromExpr.d.ts.map

package/lib/exercises/math/integration/fromExpr/meanValue/meanValueOfTrinomFromIntegralFromExpr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meanValueOfTrinomFromIntegralFromExpr.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/integration/fromExpr/meanValue/meanValueOfTrinomFromIntegralFromExpr.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;CACnD,CAAC;AAkeF,KAAK,OAAO,GAAG;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAkDF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAqBR,CAAC"}

package/lib/exercises/math/integration/fromExpr/meanValue/meanValueOfTrinomFromIntegralFromExpr.js

@@ -0,0 +1,429 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, red } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { nodeBySubstitutingVar } from "../../../../../math/utils/functions/functionComposition.js";
+import { createIntegratedPolynomialNode } from "../../../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { abs } from "../../../../../tree/nodes/functions/absNode.js";
+import { IntegralNode } from "../../../../../tree/nodes/functions/integralNode.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 { 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 { nodeIdsForP, nodeIdsBounds } = identifiers;
+    const [nodeA, nodeRootLow, nodeRootHigh] = nodeIdsForP.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVarX = new VariableNode("x");
+    const nodeP = multiply(nodeA, multiply(substract(nodeVarX, nodeRootLow), substract(nodeVarX, nodeRootHigh)));
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = nodeP.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const nodePrimitiveOfF = createIntegratedPolynomialNode(nodeF, (0).toTree());
+    const nodeIntegral = new IntegralNode(nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh, "x");
+    const nodeIntegralAsSub = substract(nodeBySubstitutingVar(nodePrimitiveOfF, nodeIntegralBoundHigh, nodeVarX).simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    }), nodeBySubstitutingVar(nodePrimitiveOfF, nodeIntegralBoundLow, nodeVarX).simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    }));
+    const nodeLengthInterval = substract(nodeIntegralBoundHigh, nodeIntegralBoundLow);
+    const nodeMeanValue = frac(nodeIntegralAsSub.simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    }), nodeLengthInterval.simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    }));
+    return {
+        nodeF,
+        nodeIntegralBoundLow,
+        nodeIntegralBoundHigh,
+        nodePrimitiveOfF,
+        nodeIntegral,
+        nodeIntegralAsSub,
+        nodeLengthInterval,
+        nodeMeanValue,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh } = getHydrated(identifiers);
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par :
+
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+Donner la valeur moyenne de $f$ sur l'intervalle $[${nodeIntegralBoundLow.toTex()};${nodeIntegralBoundHigh.toTex()}]$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeMeanValue } = getHydrated(identifiers);
+    return nodeMeanValue
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    })
+        .toTex();
+};
+const getHint = () => {
+    return `Soit $g$ continue sur un intervalle de réels $[a;b]$.
+  
+La valeur moyenne $m$ de $g$ sur $[a;b]$ est la valeur que prendrait $g$, si elle était constante, pour donner la même valeur de l'intégrale :
+
+$$
+\\int_{a}^{b} g = \\int_{a}^{b} m = m (b - a)
+$$
+
+Ce qui donne :
+
+$$
+m = \\frac{\\int_{a}^{b} g}{b - a}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralBoundLow, nodeIntegralBoundHigh, nodePrimitiveOfF, nodeIntegral, nodeIntegralAsSub, nodeLengthInterval, nodeMeanValue, } = getHydrated(identifiers);
+    return `La fonction $f$ est un polynôme de degré $2$. Elle est continue sur $\\mathbb{R}$.
+
+On peut donc calculer :
+
+${alignTex([
+        ["", nodeIntegral.toTex()],
+        [
+            "=",
+            `\\left[ ${nodePrimitiveOfF.toTex()} \\right]_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}}`,
+        ],
+        [
+            "=",
+            nodeIntegralAsSub
+                .simplify({
+                towardsDistribute: true,
+                forceAddFractions: true,
+            })
+                .toTex(),
+        ],
+    ])}
+
+La valeur moyenne de $f$ sur $[${nodeIntegralBoundLow.toTex()};${nodeIntegralBoundHigh.toTex()}]$ est la valeur que prendrait $f$, si elle était constante, pour donner la même valeur de l'intégrale :
+
+$$
+\\int_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}} f = \\int_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}} m = m (${nodeLengthInterval.toTex()})
+$$
+
+La valeur moyenne $m$ de $f$ sur l'intervalle est donc :
+
+${alignTex([
+        ["m", "=", frac(nodeIntegral, nodeLengthInterval).toTex()],
+        [
+            "",
+            "=",
+            nodeMeanValue
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .simplify({ forceAddFractions: true })
+                .toTex(),
+        ],
+    ])}
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeF, nodeMeanValue, nodeIntegralBoundLow, nodeIntegralBoundHigh } = getHydrated(identifiers);
+    const xMin = nodeIntegralBoundLow.evaluate() - 1;
+    const xMax = nodeIntegralBoundHigh.evaluate() + 1;
+    const [yMin, 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 [vMin, vMax] = acc;
+            const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+            const valueImageI = nodeF.evaluate({ x: valueAbscissa });
+            return [Math.min(vMin, valueImageI), Math.max(vMax, valueImageI)];
+        }, [-1.5, 1.5]);
+    })();
+    const nodeFPositive = frac(add(nodeF, abs(nodeF)), 2);
+    const nodeFNegative = frac(substract(nodeF, abs(nodeF)), 2);
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        //integrals
+        `integralPositive = Integral(${nodeFPositive.toMathString()},${nodeIntegralBoundLow.toMathString()},${nodeIntegralBoundHigh.toMathString()})`,
+        `SetColor(integralPositive, "${red}")`,
+        `SetFilling(integralPositive, 0.8)`,
+        `ShowLabel(integralPositive, false)`,
+        `integralNegative = Integral(${nodeFNegative.toMathString()},${nodeIntegralBoundLow.toMathString()},${nodeIntegralBoundHigh.toMathString()})`,
+        `SetColor(integralNegative, "${blueMain}")`,
+        `SetFilling(integralNegative, 0.8)`,
+        `ShowLabel(integralNegative, false)`,
+        `integralIMean = Integral(0*x+${nodeMeanValue.toMathString()},${nodeIntegralBoundLow.toMathString()},${nodeIntegralBoundHigh.toMathString()})`,
+        `SetColor(integralIMean, "${greenMain}")`,
+        `SetFilling(integralIMean, 0.3)`,
+        `ShowLabel(integralIMean, 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 { nodeIdsForP, nodeIdsBounds } = identifiers;
+    const [nodeA, nodeRootLow, nodeRootHigh] = nodeIdsForP.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVarX = new VariableNode("x");
+    const nodeP = multiply(nodeA, multiply(substract(nodeVarX, nodeRootLow), substract(nodeVarX, nodeRootHigh)));
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = nodeP.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const xMin = nodeIntegralBoundLow.evaluate() - 1;
+    const xMax = nodeIntegralBoundHigh.evaluate() + 1;
+    const [yMin, 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 [vMin, vMax] = acc;
+            const valueAbscissa = valueBoundLow + i * valueStepAbscissa;
+            const valueImageI = nodeF.evaluate({ x: valueAbscissa });
+            return [Math.min(vMin, valueImageI), Math.max(vMax, valueImageI)];
+        }, [-1.5, 1.5]);
+    })();
+    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, () => {
+        try {
+            const identifierWrong = createRandomIdentifiers(opts);
+            tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+        }
+        catch (_) {
+            (() => { })();
+        }
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return [];
+};
+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 valueNbChangesOfSign = parseInt(opts.nbChangesOfSign);
+    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 [valueRootLow, valueRootHigh] = (() => {
+        switch (valueNbChangesOfSign) {
+            case 0: {
+                const valueRootLow = valueBoundLow - randint(1, 6);
+                const valueRootHigh = valueBoundHigh + randint(1, 6);
+                return [valueRootLow, valueRootHigh];
+            }
+            case 1: {
+                const valueBetweenBounds = randint(valueBoundLow, valueBoundHigh);
+                if (coinFlip()) {
+                    const valueRootLow = valueBetweenBounds;
+                    const valueRootHigh = valueBoundHigh + randint(1, 6);
+                    return [valueRootLow, valueRootHigh];
+                }
+                else {
+                    const valueRootLow = valueBoundLow - randint(1, 6);
+                    const valueRootHigh = valueBetweenBounds;
+                    return [valueRootLow, valueRootHigh];
+                }
+            }
+            case 2: {
+                const pool = [...Array(valueBoundHigh - valueBoundLow + 1).keys()]
+                    .map((i) => valueBoundLow + i)
+                    .slice(1, -1);
+                const [valueRootLow, valueRootHigh] = randomMany(pool, 2).toSorted((v1, v2) => v1 - v2);
+                return [valueRootLow, valueRootHigh];
+            }
+            default:
+                throw new Error("Unsupported valueNbChangesOfSign: " + valueNbChangesOfSign);
+        }
+    })();
+    const nodeA = (1).toTree();
+    const [nodeRootLow, nodeRootHigh] = [valueRootLow, valueRootHigh].map((v) => v.toTree());
+    const identifiers = {
+        nodeIdsForP: [
+            nodeA.toIdentifiers(),
+            nodeRootLow.toIdentifiers(),
+            nodeRootHigh.toIdentifiers(),
+        ],
+        nodeIdsBounds: [
+            nodeBoundLow.toIdentifiers(),
+            nodeBoundHigh.toIdentifiers(),
+        ],
+    };
+    return identifiers;
+};
+const getMeanValueOfTrinomFromIntegralFromExprQuestion = (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),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    nbChangesOfSign: "0",
+    typeSignBoundLow: "Positive",
+    typeSignBoundHigh: "Positive",
+};
+const options = [
+    {
+        id: "nbChangesOfSign",
+        label: "Nombre de changements de signe sur l'intervalle d'intégration",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["0", "1", "2"],
+        defaultValue: optsDefault.nbChangesOfSign,
+    },
+    {
+        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 meanValueOfTrinomFromIntegralFromExpr = {
+    id: "meanValueOfTrinomFromIntegralFromExpr",
+    connector: "=",
+    label: "Calcul de la valeur moyenne d'une fonction trinôme",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getMeanValueOfTrinomFromIntegralFromExprQuestion(opts), nb),
+    options,
+    validateOptions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"boundIntegralByManipulatingAutomaticRectanglesMethodFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromGraph/boundIntegralByManipulatingAutomaticRectanglesMethodFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AA+VF,eAAO,MAAM,6DAA6D,EAAE,QAAQ,CAAC,WAAW,CAuB7F,CAAC"}