math-exercises 3.0.177 → 3.0.179

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

@@ -0,0 +1,439 @@
+import { addValidProp, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.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 { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { createNodeFPolynomialFromCoeffs, getAnswerStuffSolveSecondDegreePolynomial, getTexSolveSecondDegreeEquation, } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { SetVEA } from "../../../../exercises/vea/setVEA.js";
+import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+const tryToSimplify = (node, simplifyOptions) => {
+    try {
+        return node.simplify(simplifyOptions);
+    }
+    catch (_) {
+        return node;
+    }
+};
+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{ax^2+bx+c}{dx+m}$": {
+            //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, 30);
+                    m = randint(1, 30);
+                    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]);
+                    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(nodeH);
+                    isValid = arrNodeRootH.every((node) => Number.isInteger(node.evaluate()));
+                    nodeF = frac(nodeG, nodeH);
+                }
+                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(nodeG, nodeH);
+                }
+                return nodeF;
+            })();
+            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, 30);
+                    m = randint(1, 30);
+                    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]);
+                    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 = tryToSimplify(node.leftChild, {
+            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);
+    const arrNodeXForbidden = (() => {
+        if (isFractionNode(nodeF)) {
+            const nodeDenum = nodeF.rightChild;
+            const { arrNodeX } = getAnswerStuffSolveSecondDegreePolynomial(nodeDenum);
+            return arrNodeX;
+        }
+        else {
+            return [];
+        }
+    })();
+    return `Soit $f$ une fonction telle que, pour tout $x$ réel${(() => {
+        if (arrNodeXForbidden.length > 0) {
+            return `, différent de ${arrNodeXForbidden
+                .map((node) => `$${node.toTex()}$`)
+                .join(" et de ")}`;
+        }
+        else {
+            return "";
+        }
+    })()} :
+
+$$
+f(x) = ${nodeFPretty.toTex()}
+$$
+  
+Déterminer les abscisses des extremums locaux de $f$.`;
+};
+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;
+        }
+    })();
+    return getAnswerStuffSolveSecondDegreePolynomial(nodePolynomial);
+};
+const getAnswerNode = (identifiers) => {
+    const { arrNodeX } = getAnswerStuff(identifiers);
+    return new EquationSolutionNode(new DiscreteSetNode(arrNodeX));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { typeF } = identifiers;
+    const strHintDerivative = (() => {
+        switch (typeF) {
+            case "polynôme (degré $2$)":
+                return `Soient $a$, $b$ et $c$ trois réels. La dérivée de $x \\mapsto ax^2+bx+c$ est $x \\mapsto 2ax+b$.`;
+            case "polynôme (degré $3$)":
+                return `Soient $a$, $b$, $c$ et $d$ quatre réels. La dérivée de $x \\mapsto ax^3+bx^2+cx+d$ est $x \\mapsto 3ax^2+2bx+c$.`;
+            case "$\\frac{ax^2+bx+c}{dx+m}$":
+                return `Soient $a$, $b$, $c$, $d$ et $m$ cinq réels. La dérivée de $x \\mapsto \\frac{ax^2+bx+c}{dx+m}$ est $x \\mapsto \\frac{(2ax+b)(dx+m)-(ax^2+bx+c)d}{(dx+m)^2}$.`;
+            case "$\\frac{dx+m}{ax^2+bx+c}$":
+                return `Soient $a$, $b$, $c$, $d$ et $m$ cinq réels. La dérivée de $x \\mapsto \\frac{dx+m}{ax^2+bx+c}$ est $x \\mapsto \\frac{d(ax^2+bx+c)-(dx+m)(2ax+b)}{(ax^2+bx+c)^2}$.`;
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    return `Si $f$ est une fonction dérivable en $a$, alors l'équation de la tangente à la courbe de $f$ au point d'abscisse $a$ est donné par: 
+  
+$$
+y = f'(a)(x-a)+f(a)
+$$
+
+${strHintDerivative}
+`;
+};
+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;
+        }
+    })();
+    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([
+                tryToSimplify(nodeFPretty.derivative(), {}).toTex(),
+                nodeDerivativePretty.toTex(),
+            ]),
+        ].map((tex) => [`f'(x)`, "=", tex]),
+    ])}
+
+On résout $f'(x)=0$ :
+
+${getTexSolveSecondDegreeEquation(nodePolynomial)}
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { typeF, typeRoots } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers(typeF, typeRoots);
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["S", "equal", "varnothing", "lbrace", "semicolon", "rbrace"];
+};
+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 = (typeF, typeRoots) => {
+    const nodeF = getNodeFForTypeF(typeF, typeRoots);
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        typeF,
+        typeRoots,
+    };
+    return identifiers;
+};
+const getFindAbscissaOfExtremaFromFunctionExpressionQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    const typeRoots = random(arrayedOptions.typeRoots);
+    const identifiers = createRandomIdentifiers(typeF, typeRoots);
+    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),
+    };
+};
+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$)",
+            "$\\frac{ax^2+bx+c}{dx+m}$",
+            "$\\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 findAbscissaOfExtremaFromFunctionExpression = {
+    id: "findAbscissaOfExtremaFromFunctionExpression",
+    connector: "=",
+    label: "Déterminer les abscisses des extremums locaux à partir de l'expression d'une fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindAbscissaOfExtremaFromFunctionExpressionQuestion(opts), nb),
+    options,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    isAnswerValid,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsF: NodeIdentifiers;
+    typeF: string;
+    typeRoots: string;
+};
+type Options = {
+    typeF: string;
+    typeRoots: string;
+};
+export declare const findExtremaFromFunctionExpression: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=findExtremaFromFunctionExpression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findExtremaFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/findExtremaFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA+R7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAwUF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyCF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqB1E,CAAC"}