math-exercises 3.0.177 → 3.0.179

package/lib/exercises/math/derivation/variations/signVarTableFromFunctionExpression.js

@@ -0,0 +1,530 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { varSignTableVEA } from "../../../../exercises/vea/varSignTableVEA.js";
+import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { createNodeFPolynomialFromCoeffs, getAnswerStuffSolveSecondDegreePolynomial, getTexSolveSecondDegreeEquation, } from "../../../../math/utils/polynomial/polynomialUtils.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, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { NodeUtils } from "../../../../tree/utilities/nodeUtils.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getNodeFForTypeF = (typeF, typeRoots) => {
+    const isIntegerRoots = typeRoots === "entières";
+    switch (typeF) {
+        case "polynôme (degré $2$)": {
+            //f(x)=ax^2+bx+c
+            //f'(x)=2ax+b
+            //f'(x)=0 <=> x = -b/2a
+            if (isIntegerRoots) {
+                function getNiceBA() {
+                    const a = randint(-10, 11, [0]);
+                    const x = randint(-10, 11, [0]);
+                    const b = x * (2 * a);
+                    return [b, a];
+                }
+                const [b, a] = getNiceBA();
+                const [nodeB, nodeA] = [b, a].map((v) => v.toTree());
+                const nodeC = randint(-10, 11, [0]).toTree();
+                const nodeF = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+                return nodeF;
+            }
+            else {
+                const nodeA = randint(-10, 11, [0]).toTree();
+                const nodeB = randint(-10, 11, [0]).toTree();
+                const nodeC = randint(-10, 11, [0]).toTree();
+                const nodeF = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+                return nodeF;
+            }
+        }
+        case "polynôme (degré $3$)": {
+            //3ax^2+2bx+c=0
+            //delta = (2b)²-4(3a)(c) = 4b^2 - 12ac = 4(b^2 - 3ac)
+            //=> smooth if (b^2 - 3ac) = n^2
+            //             (b^2 - n^2) % 3 = 0
+            function getNiceCBA() {
+                let [c, b, a] = [];
+                let isValid = false;
+                let counter = -1;
+                while (!isValid && counter < 1000) {
+                    counter++;
+                    b = randint(10, 100);
+                    const n = probaFlip(0.95) ? randint(1, b) : 0;
+                    const b2Minusn2 = b * b - n * n;
+                    isValid = b2Minusn2 % 3 === 0;
+                    if (isValid) {
+                        const ac = b2Minusn2 / 3;
+                        const arrDivisors = dividersOf(ac);
+                        a = random(arrDivisors);
+                        c = ac / a;
+                        //delta = 4n^2 => sqrt(delta) = 2n
+                        const x1 = (-(2 * b) - 2 * n) / (2 * (3 * a));
+                        const x2 = (-(2 * b) + 2 * n) / (2 * (3 * a));
+                        if (isIntegerRoots) {
+                            isValid = Number.isInteger(x1) && Number.isInteger(x2);
+                        }
+                    }
+                }
+                if (!isValid) {
+                    [c, b, a] = [1, 3, 3];
+                }
+                return [c, b, a];
+            }
+            const [c, b, a] = getNiceCBA();
+            const [nodeC, nodeB, nodeA] = [c, b, a].map((v) => v.toTree());
+            const nodeD = randint(-10, 10, [0]).toTree();
+            const nodeF = createNodeFPolynomialFromCoeffs([
+                nodeD,
+                nodeC,
+                nodeB,
+                nodeA,
+            ]);
+            return nodeF;
+        }
+        case "$\\frac{dx+m}{ax^2+bx+c}$": {
+            //f(x)=(ax^2+bx+c)/(dx+m)
+            //f'(x) = ((2ax+b)(dx+m)-(ax^2+bx+c)d)/((dx+m)^2)
+            //f'(x) = 0 <=>
+            //(2ad)x^2+(2am+bd)x+(bm)-(ad)x^2-(bd)x -(cd) = 0
+            //(ad)x^2+(2am)x+(bm-cd)=0
+            //delta = (2am)^2 - 4(ad)(bm-cd)
+            //=> smooth if bm-cd = 0
+            function getNiceMDCBA() {
+                let [m, d, c, b, a] = [];
+                let isValid = false;
+                let counter = -1;
+                while (!isValid && counter < 1000) {
+                    counter++;
+                    b = randint(1, 20);
+                    m = randint(1, 50);
+                    const bm = b * m;
+                    const arrDivisors = dividersOf(bm);
+                    c = random(arrDivisors);
+                    d = bm / c;
+                    if (isIntegerRoots) {
+                        isValid = Number.isInteger(m / d);
+                    }
+                    else {
+                        isValid = true;
+                    }
+                    a = randint(-10, 11, [0]);
+                    isValid = b * b - 4 * a * c < 0; //ensure no forbidden values
+                    return [m, d, c, b, a];
+                }
+                if (!isValid) {
+                    [m, d, c, b, a] = [19, 19, 2, 2, -8];
+                }
+                return [m, d, c, b, a];
+            }
+            const nodeF = (() => {
+                let nodeF;
+                let isValid = false;
+                let counter = -1;
+                while (!isValid && counter < 1000) {
+                    counter++;
+                    const [m, d, c, b, a] = getNiceMDCBA();
+                    const [nodeM, nodeD, nodeC, nodeB, nodeA] = [m, d, c, b, a].map((v) => v.toTree());
+                    const nodeG = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+                    const nodeH = createNodeFPolynomialFromCoeffs([nodeM, nodeD]);
+                    const { arrNodeX: arrNodeRootH } = getAnswerStuffSolveSecondDegreePolynomial(nodeG);
+                    isValid = arrNodeRootH.every((node) => Number.isInteger(node.evaluate()));
+                    nodeF = frac(nodeH, nodeG);
+                }
+                if (!isValid) {
+                    const [m, d, c, b, a] = [19, 19, 2, 2, -8];
+                    const [nodeM, nodeD, nodeC, nodeB, nodeA] = [m, d, c, b, a].map((v) => v.toTree());
+                    const nodeG = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+                    const nodeH = createNodeFPolynomialFromCoeffs([nodeM, nodeD]);
+                    nodeF = frac(nodeH, nodeG);
+                }
+                return nodeF;
+            })();
+            return nodeF;
+        }
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+const getPrettyNode = (node) => {
+    if (isFractionNode(node)) {
+        const nodeNumSimplified = node.leftChild.simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        const nodeDenSimplified = node.rightChild.simplify();
+        return frac(nodeNumSimplified, nodeDenSimplified);
+    }
+    else {
+        return node;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const [nodeF] = [nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeFPretty = getPrettyNode(nodeF);
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par : 
+
+$$
+f(x) = ${nodeFPretty.toTex()}
+$$
+
+Dresser le tableau de signes de $f'$ et de variations de $f$.
+
+`;
+};
+const getInitTable = (identifiers) => {
+    const { arrNodeX } = getAnswerStuff(identifiers);
+    const nbExtrema = arrNodeX.length;
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            ...[...Array(nbExtrema).keys()].flatMap(() => ["\\ ", ""]),
+            "\\ ",
+            "+\\infty",
+        ],
+        [
+            "$f'(x)$",
+            "\\ ",
+            ...[...Array(2 * nbExtrema + 1).keys()].map(() => ""),
+            "\\ ",
+        ],
+        [
+            "$\\ $",
+            "\\ ",
+            ...[...Array(2 * nbExtrema + 1).keys()].map(() => "\\ "),
+            "\\ ",
+        ],
+        [
+            "$f(x)$",
+            "\\ ",
+            ...[...Array(2 * nbExtrema + 1).keys()].map(() => ""),
+            "\\ ",
+        ],
+        [
+            "$\\ $",
+            "\\ ",
+            ...[...Array(2 * nbExtrema + 1).keys()].map(() => "\\ "),
+            "\\ ",
+        ],
+    ];
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeFPretty = getPrettyNode(nodeF);
+    const nodeDerivativeRaw = nodeFPretty.derivative().simplify();
+    const nodeDerivativePretty = getPrettyNode(nodeDerivativeRaw);
+    const nodePolynomial = (() => {
+        if (isFractionNode(nodeDerivativePretty)) {
+            return nodeDerivativePretty.leftChild;
+        }
+        else {
+            return nodeDerivativePretty;
+        }
+    })();
+    const { arrNodeX } = getAnswerStuffSolveSecondDegreePolynomial(nodePolynomial);
+    const arrNodeValueFunction = arrNodeX.map((nodeX) => nodeBySubstitutingVar(nodeFPretty, nodeX, "x".toTree()).simplify());
+    const arrNodeXNonRoot = [
+        add(arrNodeX[0], -1),
+        ...zip(arrNodeX.slice(0, -1), arrNodeX.slice(1)).map(([nodeX1, nodeX2]) => frac(add(nodeX1, nodeX2), 2)),
+        add(arrNodeX[arrNodeX.length - 1], 1),
+    ];
+    const arrSignOutsideRoots = arrNodeXNonRoot.map((nodeXNonRoot) => nodeDerivativePretty.evaluate({ x: nodeXNonRoot.evaluate() }) > 0 ? +1 : -1);
+    return { arrNodeX, arrNodeValueFunction, arrSignOutsideRoots };
+};
+const getAnswerTable = (identifiers) => {
+    const { arrNodeX, arrNodeValueFunction, arrSignOutsideRoots } = getAnswerStuff(identifiers);
+    // return [
+    //   ["$x$", "-\\infty", "\\ ", root.toTex(), "\\ ", "+\\infty"],
+    //   ["$f'(x)$", "\\ ", a > 0 ? "-" : "+", "0", a > 0 ? "+" : "-", "\\ "],
+    //   ["$\\ $", "\\ ", "\\ ", a < 0 ? img.toTex() : "\\ ", "\\ ", "\\ "],
+    //   [
+    //     "$f(x)$",
+    //     "\\ ",
+    //     a > 0 ? "\\searrow" : "\\nearrow",
+    //     "\\ ",
+    //     a < 0 ? "\\searrow" : "\\nearrow",
+    //     "\\ ",
+    //   ],
+    //   ["$\\ $", "\\ ", "\\ ", a > 0 ? img.toTex() : "\\ ", "\\ ", "\\ "],
+    // ];
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            ...arrNodeX.flatMap((nodeX) => ["\\ ", nodeX.toTex()]),
+            "\\ ",
+            "+\\infty",
+        ],
+        [
+            "$f'(x)$",
+            "\\ ",
+            ...arrSignOutsideRoots.flatMap((sign) => [sign > 0 ? "+" : "-", "\\ "]),
+        ],
+        [
+            "$\\ $",
+            "\\ ",
+            ...zip(arrSignOutsideRoots.slice(0, -1), arrNodeValueFunction).flatMap(([sign, nodeValueFunction]) => [
+                "\\ ",
+                sign > 0 ? nodeValueFunction.toTex() : "\\ ",
+            ]),
+            "\\ ",
+            "\\ ",
+        ],
+        [
+            "$f(x)$",
+            "\\ ",
+            ...arrSignOutsideRoots.flatMap((sign) => [
+                sign > 0 ? "\\nearrow" : "\\searrow",
+                "\\ ",
+            ]),
+        ],
+        [
+            "$\\ $",
+            "\\ ",
+            ...zip(arrSignOutsideRoots.slice(0, -1), arrNodeValueFunction).flatMap(([sign, nodeValueFunction]) => [
+                "\\ ",
+                sign < 0 ? nodeValueFunction.toTex() : "\\ ",
+            ]),
+            "\\ ",
+            "\\ ",
+        ],
+    ];
+};
+const getHint = () => {
+    return `Commence par déterminer la fonction dérivée $f'$ de $f$. Puis, étudie le signe de $f'$ en résolvant l'inéquation $f'(x)\\geq 0$.
+  
+Enfin, sers-toi de la propriété suivante : 
+
+- si $f'$ est positive sur un intervalle $I$, alors $f$ est croissante sur $I$;
+- si $f'$ est négative sur un intervalle $I$, alors $f$ est décroissante sur $I$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const [nodeF] = [nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeFPretty = getPrettyNode(nodeF);
+    const nodeDerivativeRaw = nodeFPretty.derivative().simplify();
+    const nodeDerivativePretty = getPrettyNode(nodeDerivativeRaw);
+    const nodePolynomial = (() => {
+        if (isFractionNode(nodeDerivativePretty)) {
+            return nodeDerivativePretty.leftChild;
+        }
+        else {
+            return nodeDerivativePretty;
+        }
+    })();
+    const { arrNodeX } = getAnswerStuff(identifiers);
+    return `Les abscisses recherchées sont les abscisses $a$ telles que $f'(a)=0$.
+  
+Pour $x$ appartenant à l'ensemble de dérivation de $f$, on calcule :
+
+${alignTex([
+        ...[
+            ...new Set([
+                nodeFPretty.derivative().simplify().toTex(),
+                nodeDerivativePretty.toTex(),
+            ]),
+        ].map((tex) => [`f'(x)`, "=", tex]),
+    ])}
+
+On résout $f'(x)=0$ :
+
+${getTexSolveSecondDegreeEquation(nodePolynomial)}
+
+Les extremums sont donc : 
+
+${alignTex([
+        ...arrNodeX.flatMap((nodeX) => {
+            const nodeExtremum = nodeBySubstitutingVar(nodeFPretty, nodeX, "x".toTree());
+            return [
+                [`f(${nodeX.toTex()})`, "=", nodeExtremum.toTex()],
+                [``, "=", nodeExtremum.simplify().toTex()],
+            ];
+        }),
+    ])}
+
+On remplit le tableau en calculant le signe de $f'(x)$ pour $x$ qui n'est pas l'abscisse d'un extremum.
+
+`;
+};
+const getKeys = () => {
+    return ["infty"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return varSignTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (typeF, typeRoots) => {
+    const nodeF = getNodeFForTypeF(typeF, typeRoots);
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        typeF,
+        typeRoots,
+    };
+    return identifiers;
+};
+const getSignVarTableFromFunctionExpressionQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    const typeRoots = random(arrayedOptions.typeRoots);
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers(typeF, typeRoots);
+        const isSolutionPrettyAndNotExploding = (identifiers) => {
+            try {
+                const { arrNodeX } = getAnswerStuff(identifiers);
+                return arrNodeX.every((node) => NodeUtils.getDepth(node) < 2);
+            }
+            catch (_) {
+                return false;
+            }
+        };
+        isValid = isSolutionPrettyAndNotExploding(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            nodeIdsF: {
+                id: 3,
+                leftChild: {
+                    id: 0,
+                    leftChild: {
+                        id: 2,
+                        leftChild: {
+                            id: 7,
+                            value: 30,
+                        },
+                        rightChild: {
+                            id: 10,
+                            name: "x",
+                        },
+                    },
+                    rightChild: {
+                        id: 7,
+                        value: 10,
+                    },
+                },
+                rightChild: {
+                    id: 0,
+                    leftChild: {
+                        id: 0,
+                        leftChild: {
+                            id: 2,
+                            leftChild: {
+                                id: 7,
+                                value: 6,
+                            },
+                            rightChild: {
+                                id: 5,
+                                leftChild: {
+                                    id: 10,
+                                    name: "x",
+                                },
+                                rightChild: {
+                                    id: 7,
+                                    value: 2,
+                                },
+                            },
+                        },
+                        rightChild: {
+                            id: 2,
+                            leftChild: {
+                                id: 7,
+                                value: 3,
+                            },
+                            rightChild: {
+                                id: 10,
+                                name: "x",
+                            },
+                        },
+                    },
+                    rightChild: {
+                        id: 7,
+                        value: 1,
+                    },
+                },
+            },
+            typeF: "$\\frac{dx+m}{ax^2+bx+c}$",
+            typeRoots: "entières",
+        };
+        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: getInitTable(identifiers),
+    };
+};
+const arrayedOptsDefault = {
+    typeF: [
+        "polynôme (degré $2$)",
+        // "polynôme (degré $3$)",
+        // "$\\frac{ax^2+bx+c}{dx+m}$",
+        "$\\frac{dx+m}{ax^2+bx+c}$",
+    ],
+    typeRoots: ["entières", "rationnelles"],
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "polynôme (degré $2$)",
+            // "polynôme (degré $3$)",      //sometimes it does  f'(x) :  + 0 + (unhandled for now)
+            // "$\\frac{ax^2+bx+c}{dx+m}$", //forbidden value                   (unhandled for now)
+            "$\\frac{dx+m}{ax^2+bx+c}$",
+        ],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+    {
+        id: "typeRoots",
+        label: "Type d'abscisses",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["entières", "rationnelles"],
+        defaultValue: arrayedOptsDefault.typeRoots,
+    },
+];
+export const signVarTableFromFunctionExpression = {
+    id: "signVarTableFromFunctionExpression",
+    label: "Dresser le tableau de signes de $f'$ et de variations de $f$ à partir de l'expression de $f$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSignVarTableFromFunctionExpressionQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "signVarTable",
+};

package/lib/exercises/math/derivation/variations/signVarTableProductFExp.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    coeffsF: number[];
+};
+type Options = {
+    typeF: string;
+};
+export declare const signVarTableProductFExp: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=signVarTableProductFExp.d.ts.map

package/lib/exercises/math/derivation/variations/signVarTableProductFExp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signVarTableProductFExp.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/signVarTableProductFExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AA4HrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAmXF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAiBF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBlE,CAAC"}