math-exercises 3.0.178 → 3.0.179

package/lib/exercises/math/derivation/tangent/tangentEquationFromGraph.js

@@ -0,0 +1,308 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, orange, pinkMain, } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.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 { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+function createNodeFPolynomial(nodeA, arrNodeRoot) {
+    const nodeX = "x".toTree();
+    const nodePolynomial = arrNodeRoot.reduce((acc, nodeCoeff) => {
+        return multiply(acc, substract(nodeX, nodeCoeff));
+    }, nodeA);
+    return nodePolynomial;
+}
+const getInstruction = (identifiers) => {
+    const { nodeIdsXAsked } = identifiers;
+    const nodeXAsked = NodeConstructor.fromIdentifiers(nodeIdsXAsked);
+    return `Les courbes représentatives d'une fonction $f$ (en bleu) et de sa dérivée (en rose) sont tracées ci-dessous. 
+
+Déterminer l'équation de la tangente à la courbe de $f$ au point d'abscisse $${nodeXAsked.toTex()}$.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const nodeXAsked = NodeConstructor.fromIdentifiers(nodeIdsXAsked);
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative().simplify();
+    const nodeValueImage = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+    const nodeX = "x".toTree();
+    const nodeT = add(multiply(nodeValueDerivative, substract(nodeX, nodeXAsked)), nodeValueImage);
+    return nodeT;
+};
+const getAnswer = (identifiers) => {
+    return `y = ${getAnswerNode(identifiers)
+        .simplify({ towardsDistribute: true, forbidFactorize: true })
+        .toTex()}`;
+};
+const getHint = () => {
+    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)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const nodeXAsked = NodeConstructor.fromIdentifiers(nodeIdsXAsked);
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative().simplify();
+    const nodeValueImage = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+    const nodeT = getAnswerNode(identifiers);
+    return `L'équation de la tangente à la courbe de $f$ au point d'abscisse $a$ est donné par: 
+  
+$$
+y = f'(a)(x-a)+f(a)
+$$
+
+Ici, pour $a=${nodeXAsked.toTex()}$, on lit graphiquement :
+
+$$
+f'(${nodeXAsked.toTex()}) = ${nodeValueDerivative.toTex()}
+$$
+
+$$
+f(${nodeXAsked.toTex()}) = ${nodeValueImage.toTex()}
+$$
+
+
+L'équation de la tangente en $${nodeXAsked.toTex()}$ est donc : 
+
+${alignTex([
+        ["y", "=", nodeT.toTex()],
+        [
+            "",
+            "=",
+            nodeT.simplify({ towardsDistribute: true, forbidFactorize: true }).toTex(),
+        ],
+    ])}
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const nodeXAsked = NodeConstructor.fromIdentifiers(nodeIdsXAsked);
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative().simplify();
+    const nodeValueImage = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+    const nodeTangent = getAnswerNode(identifiers).simplify();
+    const pointPAbscissa = new Point("Pab", nodeXAsked.evaluate(), 0);
+    const pointPf = new Point("Pf", nodeXAsked.evaluate(), nodeValueImage.evaluate());
+    const pointPfPrime = new Point("PfPrime", nodeXAsked.evaluate(), nodeValueDerivative.evaluate());
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //function
+            `f(x) = ${nodeF.toMathString()}`,
+            `SetColor(f, "${blueMain}")`,
+            //derivative (chunks)
+            `fPrime(x) = ${nodeDerivative.toMathString()}`,
+            `SetColor(fPrime, "${pinkMain}")`,
+            //point on function
+            ...pointPf.toGGBCommand({ showLabel: false, color: orange }),
+            //point on derivative
+            ...pointPfPrime.toGGBCommand({ showLabel: false, color: orange }),
+            //tangent
+            `t(x) = ${nodeTangent.toMathString()}`,
+            `SetColor(t, "${greenMain}")`,
+        ],
+    });
+    const points = [pointPAbscissa, pointPf, pointPfPrime];
+    const xAsked = nodeXAsked.evaluate();
+    const xMin = xAsked - 3;
+    const xMax = xAsked + 3;
+    const yMin = Math.min(...points.map((p) => p.y.evaluate())) - 1;
+    const yMax = Math.max(...points.map((p) => p.y.evaluate())) + 1;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const nodeXAsked = NodeConstructor.fromIdentifiers(nodeIdsXAsked);
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative().simplify();
+    const nodeValueImage = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+    const pointPAbscissa = new Point("Pab", nodeXAsked.evaluate(), 0);
+    const pointPf = new Point("Pf", nodeXAsked.evaluate(), nodeValueImage.evaluate());
+    const pointPfPrime = new Point("PfPrime", nodeXAsked.evaluate(), nodeValueDerivative.evaluate());
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //function
+            `f(x) = ${nodeF.toMathString()}`,
+            `SetColor(f, "${blueMain}")`,
+            //derivative (chunks)
+            `fPrime(x) = ${nodeDerivative.toMathString()}`,
+            `SetColor(fPrime, "${pinkMain}")`,
+        ],
+    });
+    const points = [pointPAbscissa, pointPf, pointPfPrime];
+    const xAsked = nodeXAsked.evaluate();
+    const xMin = xAsked - 3;
+    const xMax = xAsked + 3;
+    const yMin = Math.min(...points.map((p) => p.y.evaluate())) - 1;
+    const yMax = Math.max(...points.map((p) => p.y.evaluate())) + 1;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const nodeXAsked = NodeConstructor.fromIdentifiers(nodeIdsXAsked);
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative().simplify();
+    const nodeValueImage = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+    //mandatory
+    const propositionsMandatory = [];
+    addValidProp(propositionsMandatory, answer);
+    //student: y=f'(a)x + f(a)
+    {
+        const nodeX = "x".toTree();
+        const nodeTWrong = add(multiply(nodeValueDerivative, nodeX), nodeValueImage);
+        const texWrong = `y = ${nodeTWrong
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex()}`;
+        tryToAddWrongProp(propositionsMandatory, texWrong);
+    }
+    //filler
+    const propositionsFiller = [];
+    //student: y=f(a)(x-a) + f'(a)
+    //student: y=f'(a)(x-f(a)) + f(a)
+    //student: y=f(a)(x-f'(a)) + f'(a)
+    //etc.
+    {
+        [
+            [nodeXAsked, nodeValueDerivative, nodeValueDerivative],
+            [nodeXAsked, nodeValueImage, nodeValueImage],
+            [nodeXAsked, nodeValueDerivative, nodeValueImage],
+            [nodeXAsked, nodeValueDerivative, nodeXAsked],
+            [nodeXAsked, nodeValueImage, nodeXAsked],
+            [nodeValueImage, nodeValueImage, nodeValueDerivative],
+        ].forEach(([nodeXAskedWrong, nodeValueImageWrong, nodeValueDerivativeWrong]) => {
+            const nodeX = "x".toTree();
+            const nodeTWrong = add(multiply(nodeValueDerivativeWrong, substract(nodeX, nodeXAskedWrong)), nodeValueImageWrong);
+            const texWrong = `y = ${nodeTWrong
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex()}`;
+            tryToAddWrongProp(propositionsFiller, texWrong);
+        });
+    }
+    propWhile(propositionsFiller, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositionsFiller, getAnswer(identifiersWrong));
+    });
+    return shuffle([
+        ...propositionsMandatory,
+        ...shuffleProps(propositionsFiller.filter((propositionFiller) => !propositionsMandatory
+            .map((proposition) => proposition.statement)
+            .includes(propositionFiller.statement)), n - propositionsMandatory.length),
+    ]);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const ansRefined = (() => {
+            const arrComponents = ans.split("=");
+            if (arrComponents.length === 1) {
+                return arrComponents[0];
+            }
+            else {
+                return arrComponents[1];
+            }
+        })();
+        const nodeAns = parseAlgebraic(ansRefined);
+        const nodeAnswer = getAnswerNode(identifiers).simplify();
+        return substract(nodeAns, nodeAnswer).evaluate({ x: 1 }) === 0;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    //q(x) = a(x-x1)(x-x2)(x-x3)(x-x4)(x-x5)
+    //q'(x)= a(1)(x-x2)(x-x3)(x-x4)(x-x5) + a(x-x1)(1)(x-x3)(x-x4)(x-x5) + a(x-x1)(x-x2)(1)(x-x4)(x-x5) + a(x-x1)(x-x2)(x-x3)(1)(x-x5) + a(x-x1)(x-x2)(x-x3)(x-x4)(1)
+    //we need to have roots "really close" to xAsked so that q(xAsked) and q'(xAsked) are "easy numbers"
+    //expl: around 4
+    //q(x) = a(x-3)(x-3)(x-5)(x-5)(x-6)
+    //q(4) = -2a
+    //q'(x)= a(1)(x-3)(x-5)(x-5)(x-6) + a(x-3)(1)(x-5)(x-5)(x-6) + a(x-3)(x-3)(1)(x-5)(x-6) + a(x-3)(x-3)(x-5)(1)(x-6) + a(x-3)(x-3)(x-5)(x-5)(1)
+    //q'(4)= (-2a) + (-2a) + (2a) + (2a) + a
+    //q'(4)= a
+    const xAsked = randint(-5, 6);
+    const nodeA = randint(-4, 5, [0]).toTree();
+    // const [x1, x2, x3, x4, x5] = [
+    //   xAsked - 1,
+    //   xAsked - 1,
+    //   xAsked + 1,
+    //   xAsked + 1,
+    //   xAsked + 2,
+    // ];
+    const [x1, x2, x3, x4, x5] = (() => {
+        const rand = randint(0, 6);
+        switch (rand) {
+            case 0:
+                return [xAsked - 0.5, xAsked + 0.5, xAsked - 1, xAsked + 1, xAsked + 1];
+            case 1:
+                return [xAsked - 0.5, xAsked + 0.5, xAsked - 1, xAsked + 1, xAsked - 1];
+            case 2:
+                return [xAsked - 0.5, xAsked + 0.5, xAsked - 1, xAsked + 1, xAsked + 2];
+            case 3:
+                return [xAsked - 0.5, xAsked + 0.5, xAsked - 1, xAsked + 1, xAsked - 2];
+            case 4:
+                return [xAsked - 1, xAsked + 1, xAsked - 1, xAsked + 1, xAsked - 0.5];
+            case 5:
+                return [xAsked - 1, xAsked + 1, xAsked - 1, xAsked + 1, xAsked + 0.5];
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    })();
+    const arrNodeRoot = [x1, x2, x3, x4, x5].map((x) => x.toTree());
+    const nodeQuintic = createNodeFPolynomial(nodeA, arrNodeRoot);
+    // const nodeQuadratic = nodeQuintic.derivative();
+    const identifiers = {
+        nodeIdsXAsked: xAsked.toTree().toIdentifiers(),
+        nodeIdsF: nodeQuintic.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getTangentEquationFromGraphQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["y", "x", "equal"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const tangentEquationFromGraph = {
+    id: "tangentEquationFromGraph",
+    label: "Déterminer l'équation d'une tangente en un point donné, à partir de la courbe d'une fonction et de celle de sa dérivée",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getTangentEquationFromGraphQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    hasGeogebra: true,
+};

package/lib/exercises/math/derivation/variations/findAbscissaOfExtremaFromFunctionExpression.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 findAbscissaOfExtremaFromFunctionExpression: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=findAbscissaOfExtremaFromFunctionExpression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findAbscissaOfExtremaFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/findAbscissaOfExtremaFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4R7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAiNF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyCF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAChE,WAAW,EACX,OAAO,CAqBR,CAAC"}