math-exercises 3.0.178 → 3.0.179

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

@@ -0,0 +1,328 @@
+import { addValidProp, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { blueMain, orange, red } 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 { createArrNodeCoeffCubic, PointOfFunction, PointOfFunctionConstructor, } from "../../../../math/utils/polynomial/polynomialInterpolationUtils.js";
+import { createNodeFPolynomialFromCoeffs, createNodeFPolynomialFromRoots, getAnswerStuffSolveSecondDegreePolynomial, getArrNodeCoeffOfPolynomialNode, getTexSolveSecondDegreeEquation, } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { nodeIdsF, boundPHigh } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    return `On note $b(p)$ le bénéfice journalier (en $\\textrm{€}$) d'une entreprise en fonction du nombre d'objets $p$ qu'elle produit ce même jour.
+L'entreprise peut produire au maximum $${boundPHigh.frenchify()}$ produits par jour. 
+
+On a :
+
+$$
+b(p) = ${nodeBySubstitutingVar(nodeF, "p".toTree(), "x".toTree()).toTex()}
+$$
+  
+Déterminer pour quelle production $p$ elle réalise son bénéfice maximal.`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsF, boundPHigh } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative();
+    const { nodePolynomial, arrNodeX } = getAnswerStuffSolveSecondDegreePolynomial(nodeDerivative);
+    const points = (() => {
+        const arrX = arrNodeX.map((node) => node.evaluate());
+        return [...arrX, boundPHigh].map((x, i) => new Point(`P${i}`, x, nodeF.evaluate({ x })));
+    })();
+    return { nodePolynomial, arrNodeX, points };
+};
+const getAnswerNode = (identifiers) => {
+    const { boundPHigh } = identifiers;
+    const { points } = getAnswerStuff(identifiers);
+    const pointsWithPossibleX = points.filter((point) => point.x.evaluate() <= boundPHigh);
+    const pointsWithPossibleXSortedYDesc = pointsWithPossibleX.toSorted(({ y: nodeY1 }, { y: nodeY2 }) => nodeY2.evaluate() - nodeY1.evaluate());
+    const nodeInteger = round(pointsWithPossibleXSortedYDesc[0].x.evaluate(), 0).toTree();
+    return nodeInteger;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Recherche les extrémums de la fonction $b$. Déduis-en la production pour laquelle le bénéfice est maximal. Attention, la production est limitée.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsF, typeF, boundPHigh } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative();
+    switch (typeF) {
+        case "polynôme (degré $2$)": {
+            return `Le maximum théorique est atteint à l'abscisse $p_M$ telle que $b'(p_M) = 0$.
+
+$b$ est continue et dérivable. On calcule :
+
+$$
+b'(p) = ${nodeBySubstitutingVar(nodeDerivative.simplify(), "p".toTree(), "x".toTree()).toTex()}
+$$
+
+On résout $b'(p)=0$ :
+
+${getTexSolveSecondDegreeEquation(nodeDerivative, {
+                nodeVar: "p".toTree(),
+                isShouldApprox: true,
+            })}
+
+On a trouvé un extrémum.
+C'est un maximum car le signe du coefficient de $p^2$ est négatif.
+
+Il faut faire attention à ce que $p$ est, en réalité, compris entre $0$ et $${boundPHigh}$.
+
+Le maximum est donc atteint à l'abscisse $${getAnswer(identifiers)}$.`;
+        }
+        case "polynôme (degré $3$)": {
+            const [_nodeD, _nodeC, _nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodeF);
+            const isX3CoeffPositive = nodeA.evaluate() > 0;
+            return `Le maximum théorique est atteint à l'abscisse $p_M$ telle que $b'(p_M) = 0$.
+
+$b$ est continue et dérivable. On calcule :
+
+$$
+b'(p) = ${nodeBySubstitutingVar(nodeDerivative.simplify(), "p".toTree(), "x".toTree()).toTex()}
+$$
+
+On résout $b'(p)=0$ :
+
+${getTexSolveSecondDegreeEquation(nodeDerivative, {
+                nodeVar: "p".toTree(),
+                isShouldApprox: true,
+            })}
+
+Dans $b(p)$, le coefficient en $p^3$ est ${isX3CoeffPositive ? "positif" : "négatif"}.
+Donc les extrémums seront rangés dans cet ordre sur l'axe des abscisses :
+${isX3CoeffPositive
+                ? `maximum local puis minimum local`
+                : `minimum local puis maximum local`}
+
+Il faut faire attention à ce que $p$ est, en réalité, compris entre $0$ et $${boundPHigh}$.
+
+Le maximum est donc atteint à l'abscisse $${getAnswer(identifiers)}$.`;
+        }
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIdsF, pofIds, boundPHigh } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const arrPOF = pofIds.map((pofIds) => PointOfFunctionConstructor.fromIdentifiers(pofIds));
+    const pointBoundPHigh = new Point("P", boundPHigh, nodeF.evaluate({ x: boundPHigh }));
+    const { points } = getAnswerStuff(identifiers);
+    const maxX = Math.max(...points.map((point) => point.x.evaluate()));
+    const maxY = Math.max(...points.map((point) => point.y.evaluate()));
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //function
+            `f(x) = ${nodeF.toMathString()}`,
+            `SetColor(f, "${blueMain}")`,
+            `SetCaption(f, "$\\mathcal C_b$")`,
+            `ShowLabel(f, true)`,
+            //points with tangents
+            ...arrPOF.flatMap((pof, i) => {
+                const a = pof.nodeAbscissa.evaluate();
+                const u = pof.nodeValue.evaluate();
+                const v = pof.nodeDerivative.evaluate();
+                return [
+                    `t${i}(x) = Function(${u} + ${v}(x-${a}), ${a} - 2, ${a} + 2)`,
+                    `SetColor(t${i}, "${orange}")`,
+                    `P${i} = Point({${a}, ${u}})`,
+                    `SetFixed(P${i}, false, false)`,
+                    `SetColor(P${i}, "${orange}")`,
+                ];
+            }),
+            //maxP
+            `lMax = Line((${boundPHigh}, 0), (${boundPHigh}, 1))`,
+            `SetColor(lMax, "${red}")`,
+            `SetCaption(lMax, "$x = ${boundPHigh}$")`,
+            `ShowLabel(lMax, true)`,
+            //maxP
+            ...pointBoundPHigh.toGGBCommand({
+                isFixed: true,
+                isSelectionnable: true,
+                showLabel: false,
+                style: 1,
+                size: 5,
+                color: orange,
+            }),
+        ],
+        lockedAxesRatio: maxX / maxY,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([
+            ...arrPOF.map((pof, i) => new Point(`P${i}`, pof.nodeAbscissa, pof.nodeValue)),
+            pointBoundPHigh,
+        ]),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { typeF } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers(typeF);
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (typeF) => {
+    const baseP = randint(100, 500);
+    // const height = randint(200, 5000);
+    const basePOver3 = Math.floor(baseP / 3);
+    const isXForMaxGreaterThanBoundPHigh = probaFlip(0.24);
+    const [nodeF, boundPHigh, arrPOF] = (() => {
+        switch (typeF) {
+            case "polynôme (degré $2$)": {
+                //roots
+                const a = basePOver3;
+                const b = (() => {
+                    const bCandidate = Math.floor(2 * basePOver3);
+                    //ensure b-a %2 === 0
+                    return (bCandidate - a) % 2 === 0 ? bCandidate : bCandidate + 1;
+                })();
+                const xForMax = (a + b) / 2;
+                const arrNodeX = [a, b].map((v) => v.toTree());
+                // const nodeU = opposite(frac(multiply(4, height), power(b - a, 2)));
+                const nodeU = (-1).toTree();
+                const nodeF = createNodeFPolynomialFromRoots(nodeU, arrNodeX);
+                const boundPHigh = isXForMaxGreaterThanBoundPHigh
+                    ? randint(a + 1, xForMax)
+                    : randint(xForMax + 1, 2 * xForMax);
+                const pof1 = new PointOfFunction(xForMax.toTree(), nodeF.evaluate({ x: xForMax }).toTree(), (0).toTree());
+                return [nodeF, boundPHigh, [pof1]];
+            }
+            case "polynôme (degré $3$)": {
+                //hermite
+                const [pof1, pof2, maxP] = (() => {
+                    const isX3CoeffPositive = coinFlip();
+                    if (isX3CoeffPositive) {
+                        const x1 = basePOver3;
+                        const x2 = (() => {
+                            const x2Candidate = x1 + basePOver3;
+                            //ensure x2-x1 %2 === 0
+                            return (x2Candidate - x1) % 2 === 0
+                                ? x2Candidate
+                                : x2Candidate + 1;
+                        })();
+                        const height = (((x2 - x1) ^ 2) / 4) * 1000;
+                        const low = -height * randfloat(0.8, 1.2, 3);
+                        const pof1 = new PointOfFunction(x1.toTree(), height.toTree(), (0).toTree());
+                        const pof2 = new PointOfFunction(x2.toTree(), low.toTree(), (0).toTree());
+                        const xForMax = x1;
+                        const xForMin = x2;
+                        const boundPHigh = isXForMaxGreaterThanBoundPHigh
+                            ? randint(xForMax - 20, xForMax)
+                            : randint(Math.floor((xForMax + xForMin) / 2), xForMin + 30);
+                        return [pof1, pof2, boundPHigh];
+                    }
+                    else {
+                        //ensure p(0) < pMax
+                        const x1 = randint(-basePOver3, basePOver3);
+                        const x2 = (() => {
+                            const x2Candidate = x1 + basePOver3;
+                            //ensure x2-x1 %2 === 0
+                            return (x2Candidate - x1) % 2 === 0
+                                ? x2Candidate
+                                : x2Candidate + 1;
+                        })();
+                        const height = (((x2 - x1) ^ 2) / 4) * 1000;
+                        const low = -height * randfloat(0.8, 1.2, 3);
+                        const pof1 = new PointOfFunction(x1.toTree(), low.toTree(), (0).toTree());
+                        const pof2 = new PointOfFunction(x2.toTree(), height.toTree(), (0).toTree());
+                        const _xForMin = x1;
+                        const xForMax = x2;
+                        const boundPHigh = isXForMaxGreaterThanBoundPHigh
+                            ? randint(xForMax - 20, xForMax)
+                            : randint(Math.floor((xForMax + baseP) / 2), baseP);
+                        return [pof1, pof2, boundPHigh];
+                    }
+                })();
+                const arrNodeCoeff = createArrNodeCoeffCubic(pof1, pof2);
+                const nodeF = createNodeFPolynomialFromCoeffs(arrNodeCoeff);
+                return [nodeF, maxP, [pof1, pof2]];
+            }
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    //rounding
+    const arrNodeCoeffRounded = getArrNodeCoeffOfPolynomialNode(nodeF).map((node) => round(node.evaluate(), 2).toTree());
+    const nodeFRoundedExpanded = createNodeFPolynomialFromCoeffs(arrNodeCoeffRounded);
+    const identifiers = {
+        nodeIdsF: nodeFRoundedExpanded.toIdentifiers(),
+        pofIds: arrPOF.map((pof) => pof.toIdentifiers()),
+        boundPHigh,
+        typeF,
+    };
+    return identifiers;
+};
+const getProblemMaximizeProfitFindProductionQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    const identifiers = createRandomIdentifiers(typeF);
+    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),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+};
+const arrayedOptsDefault = {
+    typeF: ["polynôme (degré $2$)", "polynôme (degré $3$)"],
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["polynôme (degré $2$)", "polynôme (degré $3$)"],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+];
+export const problemMaximizeProfitFindProduction = {
+    id: "problemMaximizeProfitFindProduction",
+    connector: "=",
+    label: "Déterminer la production qui maximise le bénéfice",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getProblemMaximizeProfitFindProductionQuestion(opts), nb),
+    options,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    isAnswerValid,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"problemMovementOnLineFindSpeedAtPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/problemMovementOnLineFindSpeedAtPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA0E7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,oBAAoB,EAAE,eAAe,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwOF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAqBR,CAAC"}

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

@@ -0,0 +1,275 @@
+import { addValidProp, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { getArrNodeCoeffOfPolynomialNode } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.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 } 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";
+/*
+What is f'(a) if f(x)=... and f(a)=... ?
+1. compute a
+2. compute f'(x)
+3. compute f'(a)
+*/
+const nodeVarTify = (node) => {
+    const nodeVarX = "x".toTree();
+    const nodeVarT = "t".toTree();
+    return nodeBySubstitutingVar(node, nodeVarT, nodeVarX);
+};
+const getNodeFForTypeF = (typeF) => {
+    const nodeVarX = "x".toTree();
+    switch (typeF) {
+        case "polynôme (degré $1$)":
+            return AffineConstructor.random().toTree();
+        case "$\\frac{k}{t}$": {
+            const k = randint(-10, 11, [0]);
+            return frac(k, nodeVarX);
+        }
+        case "$\\frac{at+b}{ct+d}$": {
+            const [nodeNum, nodeDen] = AffineConstructor.differentRandoms(2).map((affine) => affine.toTree());
+            return frac(nodeNum, nodeDen);
+        }
+        case "$k\\sqrt{t}$": {
+            const k = randint(-10, 11, [0]);
+            return multiply(k, sqrt(nodeVarX));
+        }
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+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 { nodeIdsValueFunction, nodeIdsF } = identifiers;
+    const [nodeValueFunction, nodeF] = [nodeIdsValueFunction, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Un solide a une trajectoire rectiligne. 
+Soit $x$ la fonction qui donne sa position en fonction du temps $t$ :
+
+$$
+x(t) = ${nodeVarTify(nodeF).toTex()}
+$$
+  
+Déterminer la vitesse instantanée du solide à la position $x=${nodeValueFunction.toTex()}$ (donner une valeur approchée à $2$ décimales près)`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsValueFunction, nodeIdsF, typeF } = identifiers;
+    const [nodeValueFunction, nodeF] = [nodeIdsValueFunction, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeAbscissa = (() => {
+        switch (typeF) {
+            case "polynôme (degré $1$)": {
+                const [nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodeF);
+                return frac(substract(nodeValueFunction, nodeB), nodeA);
+            }
+            case "$\\frac{k}{t}$": {
+                const nodeK = nodeF.leftChild;
+                return frac(nodeK, nodeValueFunction);
+            }
+            case "$\\frac{at+b}{ct+d}$": {
+                const [nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodeF.leftChild);
+                const [nodeD, nodeC] = getArrNodeCoeffOfPolynomialNode(nodeF.rightChild);
+                return frac(substract(multiply(nodeValueFunction, nodeD), nodeB), substract(nodeA, multiply(nodeValueFunction, nodeC)));
+            }
+            case "$k\\sqrt{t}$": {
+                const nodeK = nodeF.leftChild;
+                return frac(power(nodeValueFunction, 2), power(nodeK, 2));
+            }
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeAbscissa, "x".toTree()).simplify();
+    return { nodeAbscissa, nodeDerivative, nodeValueDerivative };
+};
+const getAnswerNode = (identifiers) => {
+    return getAnswerStuff(identifiers).nodeValueDerivative;
+};
+const getAnswer = (identifiers) => {
+    return round(getAnswerNode(identifiers).evaluate(), 2).frenchify();
+};
+const getHint = (identifiers) => {
+    const { typeF } = identifiers;
+    switch (typeF) {
+        case "polynôme (degré $1$)":
+            return `Soient $a$ et $b$ deux réels. La dérivée de $t \\mapsto at+b$ est $t \\mapsto a$.`;
+        case "$\\frac{k}{t}$":
+            return `Soit $n$ un entier. La dérivée de $t \\mapsto \\frac{k}{t}$ est $t \\mapsto -\\frac{k}{t^2}$.`;
+        case "$\\frac{at+b}{ct+d}$":
+            return `Soient $a$, $b$, $c$ et $d$ quatre réels. La dérivée de $t \\mapsto \\frac{at+b}{ct+d}$ est $t \\mapsto \\frac{a(ct+d)-(at+b)c}{(ct+d)^2}$.`;
+        case "$k\\sqrt{t}$":
+            return `La dérivée de $t \\mapsto k\\sqrt{t}$ est $t \\mapsto \\frac{k}{2\\sqrt{t}}$.`;
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsValueFunction, nodeIdsF } = identifiers;
+    const [nodeValueFunction, nodeF] = [nodeIdsValueFunction, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const { nodeAbscissa, nodeDerivative, nodeValueDerivative } = getAnswerStuff(identifiers);
+    return `Premièrement, il faut déterminer à quel instant $t_{cible}$ correspond $x=${nodeValueFunction.toTex()}$.
+Il faut donc résoudre : 
+
+$$
+${nodeVarTify(nodeF).toTex()} = ${nodeValueFunction.toTex()}
+$$
+  
+On trouve : 
+
+${alignTex([
+        ...[
+            ...new Set([
+                nodeAbscissa.toTex(),
+                (() => {
+                    try {
+                        return nodeAbscissa.simplify();
+                    }
+                    catch (_) {
+                        return nodeAbscissa;
+                    }
+                })().toTex(),
+            ]),
+        ].map((tex, i) => [i === 0 ? `t_{cible}` : ``, "=", tex]),
+    ])}
+
+Il ne reste plus qu'à calculer la vitesse instantanée au temps $t_{cible}$ :
+
+On calcule la dérivée de $x$ :
+
+${alignTex([
+        [`v(t)`, "=", `\\frac{dx(t)}{dt}`],
+        [``, "=", `x'(t)`],
+        [``, "=", nodeVarTify(nodeDerivative).toTex()],
+    ])}
+
+On a donc :
+
+${alignTex([
+        [`v(t_{cible})`, "=", nodeValueDerivative.toTex()],
+        [``, `\\approx`, round(nodeValueDerivative.evaluate(), 2).frenchify()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { typeF } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers(typeF);
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        const isValid = substract(nodeAns, nodeAnswer).evaluate() === 0;
+        return isValid;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (typeF) => {
+    const nodeF = getNodeFForTypeF(typeF);
+    // const nodeXAsked = getRandomNodeXAskedForTypeF(typeF);
+    const nodeAbscissa = randint(5, 15).toTree();
+    const nodeValueFunctionRaw = nodeBySubstitutingVar(nodeF, nodeAbscissa, "x".toTree());
+    const nodeValueFunction = (() => {
+        try {
+            return nodeValueFunctionRaw.simplify();
+        }
+        catch (_) {
+            return nodeValueFunctionRaw;
+        }
+    })();
+    const identifiers = {
+        nodeIdsValueFunction: nodeValueFunction.toIdentifiers(),
+        nodeIdsF: nodeF.toIdentifiers(),
+        typeF,
+    };
+    return identifiers;
+};
+const getProblemMovementOnLineFindSpeedAtPointQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    const identifiers = createRandomIdentifiers(typeF);
+    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é $1$)",
+        "$\\frac{k}{t}$",
+        "$\\frac{at+b}{ct+d}$",
+        "$k\\sqrt{t}$",
+    ],
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "polynôme (degré $1$)",
+            "$\\frac{k}{t}$",
+            "$\\frac{at+b}{ct+d}$",
+            "$k\\sqrt{t}$",
+        ],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+];
+export const problemMovementOnLineFindSpeedAtPoint = {
+    id: "problemMovementOnLineFindSpeedAtPoint",
+    connector: "=",
+    label: "Lors d'un déplacement rectiligne, $x(t)$ étant donnée, déterminer une vitesse instantanée en un point",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getProblemMovementOnLineFindSpeedAtPointQuestion(opts), nb),
+    options,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    isAnswerValid,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"problemProjectileHeightFindAbscissa.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/problems/problemProjectileHeightFindAbscissa.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAoIF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAmBrE,CAAC"}