math-exercises 3.0.177 → 3.0.179

package/lib/exercises/math/derivation/derivativeNumber/valueTableImageAndDerivativeFromFunctionExpression.js

@@ -0,0 +1,272 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.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 { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPrettyDerivativeNode = (nodeF) => {
+    const nodeDerivativeRaw = nodeF.derivative().simplify();
+    if (isFractionNode(nodeDerivativeRaw)) {
+        const nodeNumSimplified = nodeDerivativeRaw.leftChild.simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        const nodeDenSimplified = nodeDerivativeRaw.rightChild.simplify();
+        return frac(nodeNumSimplified, nodeDenSimplified);
+    }
+    else {
+        return nodeDerivativeRaw;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    return `Soit $f$ une fonction telle que, pour tout $x$ bien choisi :
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+On a alors :
+
+$$
+f'(x) = ${nodeDerivative.toTex()}
+$$
+  
+Compléter le tableau de valeurs.`;
+};
+const getAnswerTable = (identifiers) => {
+    const { arrNodeIdsX, nodeIdsF } = identifiers;
+    const arrNodeX = arrNodeIdsX.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    const nodeVarX = "x".toTree();
+    const arrNodeValueFunction = arrNodeX.map((nodeX) => nodeBySubstitutingVar(nodeF, nodeX, nodeVarX).simplify());
+    const arrNodeValueDerivative = arrNodeX.map((nodeX) => nodeBySubstitutingVar(nodeDerivative, nodeX, nodeVarX).simplify());
+    return [
+        ["a", ...arrNodeX.map((node) => node.toTex())],
+        ["f'(a)", ...arrNodeValueDerivative.map((node) => node.toTex())],
+        ["f(a)", ...arrNodeValueFunction.map((node) => node.toTex())],
+    ];
+};
+const getHint = () => {
+    return `Dans ce tableau de valeurs, la deuxième ligne contient les images, par la fonction $f'$, des valeurs sur la première ligne.
+La troisième ligne contient, quant à elle, les images des valeurs sur la première ligne par la fonction $f$.`;
+};
+const getCorrection = (identifiers) => {
+    const { arrNodeIdsX, nodeIdsF } = identifiers;
+    const arrNodeX = arrNodeIdsX.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    const nodeVarX = "x".toTree();
+    return `
+On calcule : 
+
+${arrNodeX.map((nodeX) => {
+        const nodeValueFunction = nodeBySubstitutingVar(nodeF, nodeX, nodeVarX);
+        const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeX, nodeVarX);
+        return `${alignTex([
+            [`f'(${nodeX.toTex()})`, "=", nodeValueDerivative.toTex()],
+            [`f'(${nodeX.toTex()})`, "=", nodeValueDerivative.simplify().toTex()],
+        ])}
+  
+${alignTex([
+            [`f(${nodeX.toTex()})`, "=", nodeValueFunction.toTex()],
+            [`f(${nodeX.toTex()})`, "=", nodeValueFunction.simplify().toTex()],
+        ])}`;
+    }).join(`
+
+`)}
+
+Le tableau de valeurs complété est donc : 
+
+${mdTable(getAnswerTable(identifiers), true)}
+
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerTableValid = (ansTable, { answerTable }) => {
+    try {
+        for (let i = 0; i < answerTable.length; i++) {
+            for (let j = 1; j < ansTable[i].length; j++) {
+                const ans = ansTable[i][j];
+                const answer = answerTable[i][j];
+                const nodeAns = parseAlgebraic(ans);
+                const nodeAnswer = parseAlgebraic(answer);
+                const valid = substract(nodeAns, nodeAnswer).evaluate() === 0;
+                if (!valid)
+                    return false;
+            }
+        }
+        return true;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const nbX = 2;
+    const poolX = [...Array(11).keys()].map((i) => i - 5);
+    const arrX = randomMany(poolX, nbX);
+    const arrNodeX = arrX.map((x) => x.toTree());
+    const typeF = random(["affine", "trinom", "k/x", "k/x^2", "(ax+b)/(cx+d)"]);
+    const nodeF = (() => {
+        switch (typeF) {
+            case "affine":
+                return AffineConstructor.random().toTree();
+            case "trinom":
+                return TrinomConstructor.random().toTree();
+            case "k/x":
+                return frac(randint(-5, 6, [0]), "x".toTree());
+            case "k/x^2":
+                return frac(randint(-5, 6, [0]), power("x".toTree(), 2));
+            case "(ax+b)/(cx+d)": {
+                const [nodeNum, nodeDen] = AffineConstructor.differentRandoms(2).map((affine) => affine.toTree());
+                return frac(nodeNum, nodeDen);
+            }
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    const initTable = [
+        ["a", ...arrNodeX.map((node) => node.toTex())],
+        ["f'(a)", ...arrNodeX.map(() => "")],
+        ["f(a)", ...arrNodeX.map(() => "")],
+    ];
+    const identifiers = {
+        arrNodeIdsX: arrNodeX.map((node) => node.toIdentifiers()),
+        nodeIdsF: nodeF.toIdentifiers(),
+        initTable,
+    };
+    return identifiers;
+};
+const getValueTableImageAndDerivativeFromFunctionExpressionQuestion = () => {
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        const isExploding = (identifiers) => {
+            const { arrNodeIdsX, nodeIdsF } = identifiers;
+            const arrNodeX = arrNodeIdsX.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+            const nodeDerivative = getPrettyDerivativeNode(nodeF);
+            let isExploding = false;
+            try {
+                arrNodeX.forEach((nodeX) => {
+                    const _nodeValueFunction = nodeBySubstitutingVar(nodeF, nodeX, "x".toTree()).simplify();
+                    const _nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeX, "x".toTree()).simplify();
+                });
+            }
+            catch (_) {
+                isExploding = true;
+            }
+            return isExploding;
+        };
+        isValid = !isExploding(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            arrNodeIdsX: [
+                {
+                    id: 7,
+                    value: -1,
+                },
+                {
+                    id: 7,
+                    value: 2,
+                },
+            ],
+            nodeIdsF: {
+                id: 0,
+                leftChild: {
+                    id: 2,
+                    leftChild: {
+                        id: 7,
+                        value: -5,
+                    },
+                    rightChild: {
+                        id: 5,
+                        leftChild: {
+                            id: 10,
+                            name: "x",
+                        },
+                        rightChild: {
+                            id: 7,
+                            value: 2,
+                        },
+                    },
+                },
+                rightChild: {
+                    id: 0,
+                    leftChild: {
+                        id: 2,
+                        leftChild: {
+                            id: 7,
+                            value: -9,
+                        },
+                        rightChild: {
+                            id: 10,
+                            name: "x",
+                        },
+                    },
+                    rightChild: {
+                        id: 7,
+                        value: 3,
+                    },
+                },
+            },
+            initTable: [
+                ["a", "-1", "2"],
+                ["f'(a)", "", ""],
+                ["f(a)", "", ""],
+            ],
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
+    };
+};
+export const valueTableImageAndDerivativeFromFunctionExpression = {
+    id: "valueTableImageAndDerivativeFromFunctionExpression",
+    connector: "=",
+    label: "Déterminer $f(a)$ et $f'(a)$ avec $f(x)$ et $f'(x)$ donnés",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getValueTableImageAndDerivativeFromFunctionExpressionQuestion(opts), nb),
+    valueTableTimer: 120,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "valueTable",
+    isAnswerTableValid,
+};

package/lib/exercises/math/derivation/problems/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./problemMaximizeBoxVolumeFindX.js";
+export * from "./problemProjectileHeightFindAbscissa.js";
+export * from "./problemMaximizeProfitFindProduction.js";
+export * from "./problemMovementOnLineFindSpeedAtPoint.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/problems/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,4CAA4C,CAAC"}

package/lib/exercises/math/derivation/problems/index.js

@@ -0,0 +1,4 @@
+export * from "./problemMaximizeBoxVolumeFindX.js";
+export * from "./problemProjectileHeightFindAbscissa.js";
+export * from "./problemMaximizeProfitFindProduction.js";
+export * from "./problemMovementOnLineFindSpeedAtPoint.js";

package/lib/exercises/math/derivation/problems/problemMaximizeBoxVolumeFindX.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+};
+export declare const problemMaximizeBoxVolumeFindX: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=problemMaximizeBoxVolumeFindX.d.ts.map

package/lib/exercises/math/derivation/problems/problemMaximizeBoxVolumeFindX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"problemMaximizeBoxVolumeFindX.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/problemMaximizeBoxVolumeFindX.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAgCrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyKF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAgB/D,CAAC"}

package/lib/exercises/math/derivation/problems/problemMaximizeBoxVolumeFindX.js

@@ -0,0 +1,171 @@
+import { addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SetVEA } from "../../../../exercises/vea/setVEA.js";
+import { createNodeFPolynomialFromCoeffs, getAnswerStuffSolveSecondDegreePolynomial, getArrNodeCoeffOfPolynomialNode, getTexSolveSecondDegreeEquation, } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { round } from "../../../../math/utils/round.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.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 { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getNodeF = (a, b) => {
+    const nodeVarX = "x".toTree();
+    return multiply(multiply(substract(a, multiply(2, nodeVarX)), substract(b, multiply(2, nodeVarX))), nodeVarX);
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Dans une feuille rectangulaire de dimensions $${a.frenchify()} \\ \\times \\ ${b.frenchify()}$, 
+on découpe dans les coins des carrés de côté $x$ pour former une boîte sans couvercle.
+  
+Donner toutes les valeurs de $x$ (arrondies à $2$ décimales) pour lesquelles le volume de la boîte est maximal.`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { a, b } = identifiers;
+    const nodeF = getNodeF(a, b);
+    const nodeDerivative = nodeF.derivative();
+    return getAnswerStuffSolveSecondDegreePolynomial(nodeDerivative);
+};
+const getAnswerNode = (identifiers) => {
+    const { a } = identifiers;
+    const { arrNodeX } = getAnswerStuff(identifiers);
+    const arrNodeXPossible = arrNodeX.filter((node) => {
+        const value = node.evaluate();
+        return 0 <= value && value <= a / 2.0;
+    });
+    const arrNodeXRounded = arrNodeXPossible.map((node) => round(node.evaluate(), 2).toTree());
+    return new EquationSolutionNode(new DiscreteSetNode(arrNodeXRounded));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Le volume de la boîte peut être calculé avec la formule : 
+  
+${alignTex([
+        [`\\text{Volume}`, "=", `\\ \\ \\text{longueur}`],
+        ["", "", `\\times \\ \\text{largeur}`],
+        ["", "", `\\times \\ \\text{profondeur}`],
+    ])}
+
+Ici, la largeur est $a-2x$, 
+la longueur est $b-2x$ 
+et la profondeur est $x$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const nodeF = getNodeF(a, b);
+    const nodeDerivative = nodeF.derivative();
+    const nodeDerivativeExpanded = (() => {
+        const arrNodeCoeff = getArrNodeCoeffOfPolynomialNode(nodeDerivative);
+        return createNodeFPolynomialFromCoeffs(arrNodeCoeff);
+    })();
+    const nodeMaxBound = frac(a, 2);
+    return `On calcule le volume en fonction de $x$ : 
+
+$$
+V(x) = ${nodeF.toTex()}
+$$
+
+$x$ est compris entre $0$ et $${[
+        ...new Set([nodeMaxBound.toTex(), nodeMaxBound.simplify().toTex()]),
+    ].join("=")}$.
+
+On a :
+
+$$
+V(0) = V(${nodeMaxBound.simplify().toTex()}) = 0
+$$
+
+et pour $x$ différent de $0$ et de $${nodeMaxBound.simplify().toTex()}$ : 
+    
+$$
+V(x)>0
+$$
+
+On cherche à maximiser $V$.
+$V$ est continue et dérivable. On calcule :
+
+${alignTex([
+        [`V'(x)`, "=", nodeDerivative.toTex()],
+        [``, "=", nodeDerivativeExpanded.toTex()],
+    ])}
+
+On résout $V'(x)=0$ :
+
+${getTexSolveSecondDegreeEquation(nodeDerivativeExpanded)}
+
+On ne garde que les valeurs de $x$ qui sont possibles (c'est-à-dire entre $0$ et $${nodeMaxBound
+        .simplify()
+        .toTex()}$) :
+
+$$
+${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, _optsIn) => {
+    const answerNode = getAnswerNode(identifiers);
+    const arrNodeAnswer = answerNode.solutionsSet.elements;
+    const parsed = discreteSetParser(ans);
+    if (!parsed) {
+        return false;
+    }
+    const arrAns = parsed.elements;
+    return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+};
+const createRandomIdentifiers = () => {
+    const pool = [...Array(30).keys()].map((i) => i + 1);
+    const [a, b] = randomMany(pool, 2).toSorted((v1, v2) => v1 - v2);
+    const identifiers = {
+        a,
+        b,
+    };
+    return identifiers;
+};
+const getProblemMaximizeBoxVolumeFindXQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const problemMaximizeBoxVolumeFindX = {
+    id: "problemMaximizeBoxVolumeFindX",
+    connector: "=",
+    label: "Problème d'optimisation géométrique : Trouver $x$ pour maximiser le volume d'une boîte",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getProblemMaximizeBoxVolumeFindXQuestion(), nb),
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    isAnswerValid,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/problems/problemMaximizeProfitFindProduction.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointOfFunctionIdentifiers } from "../../../../math/utils/polynomial/polynomialInterpolationUtils.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsF: NodeIdentifiers;
+    pofIds: PointOfFunctionIdentifiers[];
+    boundPHigh: number;
+    typeF: string;
+};
+type Options = {
+    typeF: string;
+};
+export declare const problemMaximizeProfitFindProduction: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=problemMaximizeProfitFindProduction.d.ts.map

package/lib/exercises/math/derivation/problems/problemMaximizeProfitFindProduction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"problemMaximizeProfitFindProduction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/problemMaximizeProfitFindProduction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAIL,0BAA0B,EAC3B,MAAM,6DAA6D,CAAC;AAYrE,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,MAAM,EAAE,0BAA0B,EAAE,CAAC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwYF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsBF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CACxD,WAAW,EACX,OAAO,CAoBR,CAAC"}