math-exercises 3.0.177 → 3.0.179

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

@@ -0,0 +1,639 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, orange } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { ggbPointsToPoints } from "../../../../geogebra/parsers/ggbPointsToPoints.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { createArrNodeCoeffCubic, PointOfFunction, } from "../../../../math/utils/polynomial/polynomialInterpolationUtils.js";
+import { createIntegratedPolynomialNode, createNodeFPolynomialFromRoots, } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.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 } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { average } from "../../../../utils/average.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+//control segments allow controlling f(x_i) and f'(x_i)
+//with 2 control segments, this is Hermite's cubic
+function createNodeFCubic(arrNodesCoeff) {
+    const nodeVarX = "x".toTree();
+    const nodeCubic = arrNodesCoeff.reduce((acc, nodeCoeff, i) => {
+        return add(acc, multiply(nodeCoeff, power(nodeVarX, i)));
+    }, (0).toTree());
+    return nodeCubic;
+}
+function getXMinXMax(arrX, typeF) {
+    if (typeF === "degré $3$ monotone") {
+        const [x] = arrX;
+        return { xMin: x - 4, xMax: x + 4 };
+    }
+    else {
+        if (arrX.length === 0) {
+            return { xMin: -5, xMax: +5 };
+        }
+        else if (arrX.length === 1) {
+            const [x] = arrX;
+            return { xMin: x - 4, xMax: x + 4 };
+        }
+        else {
+            const xLeft = Math.min(...arrX);
+            const xRight = Math.max(...arrX);
+            return { xMin: xLeft - 3, xMax: xRight + 3 };
+        }
+    }
+}
+function getArrXControl(arrX, _typeF) {
+    if (arrX.length === 0) {
+        return [-3, 3];
+    }
+    else if (arrX.length === 1) {
+        const [x] = arrX;
+        return [x - 2, x + 2];
+    }
+    else if (arrX.length === 2) {
+        const [x1, x2] = arrX;
+        return [x1 - 1, x2 + 1];
+    }
+    else {
+        throw new Error("Unsupported arrX.length: " + arrX.length);
+    }
+}
+function getCoordsFrame(nodeF, xMin, xMax) {
+    const stepX = 0.05;
+    const arrX = [...Array(Math.floor((xMax - xMin) / stepX)).keys()].map((i) => xMin + i * stepX);
+    const yForXMin = nodeF.evaluate({ x: xMin });
+    const { yMin, yMax } = arrX.slice(1).reduce((acc, x) => {
+        const { yMin, yMax } = acc;
+        const y = nodeF.evaluate({ x });
+        if (y < yMin) {
+            acc.yMin = y;
+        }
+        else if (y > yMax) {
+            acc.yMax = y;
+        }
+        return acc;
+    }, { yMin: yForXMin, yMax: yForXMin });
+    return {
+        xMin,
+        xMax,
+        yMin,
+        yMax,
+    };
+}
+const createFStuff = (typeF) => {
+    //f'(x) = a(x-x1)...(x-xn)
+    //=> f'(x1) = ... = f'(xn) = 0
+    function createRandomArrX(nbX) {
+        const poolX = [...Array(11).keys()].map((i) => i - 5);
+        return randomMany(poolX, nbX).toSorted((v1, v2) => v1 - v2);
+    }
+    function createRandomNodeFFromDerivative(nodeDerivative) {
+        const nodeC = (randint(-6, 7) / 2.0).toTree();
+        return createIntegratedPolynomialNode(nodeDerivative, nodeC);
+    }
+    function createRandomNodeFFromZerosOfDerivative(arrX) {
+        const arrNodeX = arrX.map((x) => x.toTree());
+        const nodeDerivativeRaw = createNodeFPolynomialFromRoots((1).toTree(), arrNodeX);
+        const nodeFRaw = createRandomNodeFFromDerivative(nodeDerivativeRaw);
+        const maxAmplitude = Math.max(...arrX.map((x) => nodeFRaw.evaluate({ x })), 1);
+        const a = (((coinFlip() ? -1 : 1) * 1.0) / maxAmplitude) * randfloat(1, 3, 1);
+        return multiply(a, nodeFRaw);
+    }
+    const { arrX, nodeF } = (() => {
+        switch (typeF) {
+            case "constante": {
+                const arrX = [];
+                const arrNodeX = arrX.map((x) => x.toTree());
+                const nodeDerivative = createNodeFPolynomialFromRoots((0).toTree(), arrNodeX);
+                const nodeF = createRandomNodeFFromDerivative(nodeDerivative);
+                return { arrX, nodeF };
+            }
+            case "affine": {
+                const arrX = createRandomArrX(0);
+                const arrNodeX = arrX.map((x) => x.toTree());
+                const a = ((coinFlip() ? -1 : 1) * randint(1, 10)) / 2.0;
+                const nodeDerivative = createNodeFPolynomialFromRoots(a.toTree(), arrNodeX);
+                const nodeF = createRandomNodeFFromDerivative(nodeDerivative);
+                return { arrX, nodeF };
+            }
+            case "degré $2$": {
+                const arrX = createRandomArrX(1);
+                const nodeF = createRandomNodeFFromZerosOfDerivative(arrX);
+                return { arrX, nodeF };
+            }
+            case "degré $3$ monotone": {
+                const arrX = (() => {
+                    const [x] = createRandomArrX(1);
+                    return [x, x];
+                })();
+                const nodeF = createRandomNodeFFromZerosOfDerivative(arrX);
+                return { arrX, nodeF };
+            }
+            case "degré $3$ non-monotone": {
+                const arrX = createRandomArrX(2);
+                const nodeF = createRandomNodeFFromZerosOfDerivative(arrX);
+                return { arrX, nodeF };
+            }
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    return { arrX, nodeF };
+};
+const getInstruction = (identifiers) => {
+    const { pointIds } = identifiers;
+    return `Soit $f$ une fonction définie sur $\\mathbb{R}$.
+Ci-dessous est tracée en bleu la courbe $\\mathcal C_{f'}$ de sa dérivée $f'$.
+  
+En manipulant les points ${joinanded(pointIds.map((pointIds) => `$${pointIds.name}$`), ", ", " et ")},
+construire une courbe plausible pour $f$.`;
+};
+const getAnswerArr = (identifiers) => {
+    const { nodeIdsF, nodeIdsAbscissa, pointIds, typeF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative();
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrX = arrNodeX.map((node) => node.evaluate());
+    const arrXControl = getArrXControl(arrX, typeF);
+    switch (typeF) {
+        case "constante":
+        case "affine":
+        case "degré $2$":
+        case "degré $3$ monotone": {
+            return zip(pointIds, arrXControl).map(([pointIds, x]) => {
+                const valueFunction = nodeF.evaluate({ x });
+                const valueDerivative = nodeDerivative.evaluate({ x });
+                return {
+                    point: new Point(pointIds.name, x, valueFunction),
+                    s: valueDerivative,
+                };
+            });
+        }
+        case "degré $3$ non-monotone": {
+            return zip(pointIds, arrX).map(([pointIds, x]) => {
+                const valueFunction = nodeF.evaluate({ x });
+                const valueDerivative = nodeDerivative.evaluate({ x });
+                return {
+                    point: new Point(pointIds.name, x, valueFunction),
+                    s: valueDerivative,
+                };
+            });
+        }
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+const getGGBAnswer = (identifiers) => {
+    return getAnswerArr(identifiers).flatMap(({ point, s }) => [
+        //slopes
+        `s${point.name} = ${s}`,
+        //control points
+        ...point.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: true,
+            showLabel: true,
+            style: 0,
+            size: 5,
+        }),
+        //slope
+        `t${point.name}(x) = Function(y(${point.name}) + (s${point.name})(x-x(${point.name})), x(${point.name}) - 2, x(${point.name}) + 2)`,
+        `SetColor(t${point.name}, "${orange}")`,
+        //point for slope control
+        `${point.name}2 = (s${point.name} * 0 + x(${point.name}) + 1, s${point.name} + y(${point.name}))`,
+        `SetPointStyle(${point.name}2, 0)`,
+        `SetPointSize(${point.name}2, 5)`,
+    ]);
+};
+const getHint = () => {
+    return `Aux abscisses où la fonction $f$ est croissante, sa dérivée $f'$ est positive.
+Aux abscisses où la fonction $f$ est décroissante, sa dérivée $f'$ est négative. 
+Ailleurs, sa dérivée $f'$ est nulle.`;
+};
+const getCorrection = () => {
+    return `Dans un premier temps :
+Soit $S$ l'ensemble des abscisses $x$ où la tangente à $C_f$ est horizontale.
+Pour tout $x$ dans $S$, on a $f'(x)=0$.
+Pour chaque $x$ dans $S$, on peut placer un point de contrôle aux coordonées $(x, 0)$.
+Dans un second temps : 
+Aux abscisses où la fonction $f$ est croissante, sa dérivée $f'$ est positive.
+Aux abscisses où la fonction $f$ est décroissante, sa dérivée $f'$ est négative. 
+On place donc les points de contrôle restants pour garantir cela.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsF, typeF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative();
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrX = arrNodeX.map((node) => node.evaluate());
+    const commands = [
+        `f'(x) = ${nodeDerivative.toMathString()}`,
+        `SetColor(f', "${blueMain}")`,
+        `SetCaption(f', "$\\mathcal C_{f'}$")`,
+        `ShowLabel(f', true)`,
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${greenMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        ...getGGBAnswer(identifiers),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        yAxis: {
+            hideNumbers: true,
+        },
+    });
+    const { xMin, xMax } = getXMinXMax(arrX, typeF);
+    const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin: Math.min(yMin, -2),
+            yMax,
+        }),
+    });
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsF, pointIds, typeF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrX = arrNodeX.map((node) => node.evaluate());
+    const pof1 = new PointOfFunction("x(A)".toTree(), "y(A)".toTree(), "sA".toTree());
+    const pof2 = new PointOfFunction("x(B)".toTree(), "y(B)".toTree(), "sB".toTree());
+    const arrNodeCoeff = createArrNodeCoeffCubic(pof1, pof2);
+    const nodeFCubic = createNodeFCubic(arrNodeCoeff);
+    const commands = [
+        `f'(x) = ${nodeF.derivative().toMathString()}`,
+        `SetColor(f', "${blueMain}")`,
+        `SetCaption(f', "$\\mathcal C_{f'}$")`,
+        `ShowLabel(f', true)`,
+        //sliders
+        //slopeA
+        `sA = Slider(-2, 2, 0.2)`,
+        `SetValue(sA, 1)`,
+        `SetVisibleInView(sA, 1, false)`,
+        //slopeB
+        `sB = Slider(-2, 2, 0.2)`,
+        `SetValue(sB, 1)`,
+        `SetVisibleInView(sB, 1, false)`,
+        //control points
+        ...arrPoint.flatMap((point) => [
+            ...point.toGGBCommand({
+                isFixed: false,
+                isSelectionnable: true,
+                showLabel: true,
+                style: 0,
+                size: 5,
+            }),
+            //slope
+            `t${point.name}(x) = Function(y(${point.name}) + (s${point.name})(x-x(${point.name})), x(${point.name}) - 2, x(${point.name}) + 2)`,
+            `SetColor(t${point.name}, "${orange}")`,
+            //point for slope control
+            `${point.name}2 = (s${point.name} * 0 + x(${point.name}) + 1, s${point.name} + y(${point.name}))`,
+            `SetPointStyle(${point.name}2, 0)`,
+            `SetPointSize(${point.name}2, 5)`,
+        ]),
+        //Polynomial
+        `pol = ${nodeFCubic.toMathString()}`,
+    ];
+    const studentGGB = new GeogebraConstructor({
+        commands,
+        yAxis: {
+            hideNumbers: true,
+        },
+        interactiveObjects: ["A", "B", "sA", "sB"],
+        customToolBar: "0",
+    });
+    const { xMin, xMax } = getXMinXMax(arrX, typeF);
+    const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+    return studentGGB.getOptions({
+        coords: studentGGB.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin: Math.min(yMin, -2),
+            yMax,
+        }),
+    });
+};
+const isGGBAnswerValid = (ggbAns, { ggbAnswer: _ggbAnswer, ...identifiers }) => {
+    const { pointIds, nodeIdsAbscissa } = identifiers;
+    const [pointADefault, pointBDefault] = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    //handle cases like (["A=", s1="])
+    const ggbAnsRefined = ggbAns.map((strAns) => {
+        const [name, value] = strAns.split("=");
+        if (value === "") {
+            switch (name) {
+                case "A":
+                    return `A=${pointADefault.toMathString()}`;
+                case "B":
+                    return `B=${pointBDefault.toMathString()}`;
+                case "sA":
+                    return `sA=1`;
+                case "sB":
+                    return `sB=1`;
+                default:
+                    throw new Error("Unsupported name: " + name);
+            }
+        }
+        else {
+            return strAns;
+        }
+    });
+    const { typeF } = identifiers;
+    //parse points
+    const [pointA, pointB] = ggbPointsToPoints(ggbAnsRefined);
+    //parse slopes
+    function parseSlope(nameSlope) {
+        const strSlope = ggbAnsRefined.find((str) => str.startsWith(nameSlope));
+        const [_name, v] = strSlope.split("=");
+        return Number.parseFloat(v);
+    }
+    const [sA, sB] = [parseSlope("sA"), parseSlope("sB")];
+    const [{ point: point1Ans, s: s1Ans }, { point: point2Ans, s: s2Ans }] = [
+        { point: pointA, s: sA },
+        { point: pointB, s: sB },
+    ].toSorted(({ point: point1 }, { point: point2 }) => point1.x.evaluate() - point2.x.evaluate());
+    const [{ point: point1Answer, s: s1Answer }, { point: point2Answer, s: s2Answer },] = getAnswerArr(identifiers).toSorted(({ point: point1 }, { point: point2 }) => point1.x.evaluate() - point2.x.evaluate());
+    switch (typeF) {
+        case "constante": {
+            return (s1Ans === 0 &&
+                s2Ans === 0 &&
+                point1Ans.y.evaluate() === point2Ans.y.evaluate());
+        }
+        case "affine": {
+            const den = point2Ans.x.evaluate() - point1Ans.x.evaluate();
+            if (den === 0) {
+                return false;
+            }
+            const s12 = (point2Ans.y.evaluate() - point1Ans.y.evaluate()) / den;
+            const isLine = () => s12 === s1Ans && s12 === s2Ans;
+            const isSlopeSignOk = () => s1Ans * s1Answer > 0;
+            return isSlopeSignOk() && isLine();
+        }
+        case "degré $2$": {
+            const [pof1, pof2] = [
+                new PointOfFunction(point1Ans.x, point1Ans.y, s1Ans.toTree()),
+                new PointOfFunction(point2Ans.x, point2Ans.y, s2Ans.toTree()),
+            ];
+            const nodeFAns = createNodeFCubic(createArrNodeCoeffCubic(pof1, pof2));
+            const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const arrX = arrNodeX.map((node) => node.evaluate());
+            const [x] = arrX;
+            const isAlmostZeroAtX = () => Math.abs(nodeFAns.derivative().evaluate({ x })) < 0.1;
+            const isSlopeSignsOk = () => s1Ans * s1Answer >= 0 && s2Ans * s2Answer >= 0;
+            return isAlmostZeroAtX() && isSlopeSignsOk();
+        }
+        case "degré $3$ monotone": {
+            const [pof1, pof2] = [
+                new PointOfFunction(point1Ans.x, point1Ans.y, s1Ans.toTree()),
+                new PointOfFunction(point2Ans.x, point2Ans.y, s2Ans.toTree()),
+            ];
+            const nodeFAns = createNodeFCubic(createArrNodeCoeffCubic(pof1, pof2));
+            const nodeFAnsDerivative = nodeFAns.derivative();
+            const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const arrX = arrNodeX.map((node) => node.evaluate());
+            const [x] = arrX;
+            const isAlmostFlatAtX = () => Math.abs(nodeFAnsDerivative.evaluate({ x })) < 0.1;
+            const isSlopeSignOk = () => s1Ans * s1Answer > 0;
+            return isAlmostFlatAtX() && isSlopeSignOk();
+        }
+        case "degré $3$ non-monotone": {
+            const isBothFlat = () => s1Ans === 0 && s2Ans === 0;
+            const isSameOffsetSign = () => {
+                const offsetAns = point2Ans.y.evaluate() - point1Ans.y.evaluate();
+                const offsetAnswer = point2Answer.y.evaluate() - point1Answer.y.evaluate();
+                return offsetAns * offsetAnswer > 0;
+            };
+            return isBothFlat() && isSameOffsetSign();
+        }
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+const getPlausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomialQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    const [arrX, nodeF] = (() => {
+        let arrX;
+        let nodeF;
+        let isValid = false;
+        let counter = -1;
+        while (!isValid && counter < 100) {
+            counter++;
+            const { arrX: arrXCandidate, nodeF: nodeFCandidate } = createFStuff(typeF);
+            const isReadable = (arrX, nodeF) => {
+                const isInFrame = () => {
+                    const { xMin, xMax } = getXMinXMax(arrX, typeF);
+                    const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+                    return frac(yMax - yMin, xMax - xMin).evaluate() <= 0.666;
+                };
+                const isCurveOk = () => {
+                    switch (typeF) {
+                        case "constante":
+                        case "affine":
+                        case "degré $3$ monotone":
+                            return true;
+                        default: {
+                            const isWavyEnough = () => {
+                                return zip(arrX.slice(0, -1), arrX.slice(1)).every(([x1, x2]) => {
+                                    const [y1, y2] = [x1, x2].map((x) => nodeF.evaluate({ x }));
+                                    return Math.abs(y2 - y1) >= 0.777;
+                                });
+                            };
+                            const isWavyAlternate = () => {
+                                const nodeDerivative = nodeF.derivative();
+                                const arrXMid = zip(arrX.slice(0, -1), arrX.slice(1)).map(([x1, x2]) => average([x1, x2]));
+                                const arrXNonZero = [
+                                    arrX[0] - 2,
+                                    ...arrXMid,
+                                    arrX[arrX.length - 1] + 2,
+                                ];
+                                return zip(arrXNonZero.slice(0, -1), arrXNonZero.slice(1)).every(([x1, x2]) => {
+                                    const [y1, y2] = [x1, x2].map((x) => nodeDerivative.evaluate({ x }));
+                                    return y1 * y2 < 0;
+                                });
+                            };
+                            return isWavyAlternate() && isWavyEnough();
+                        }
+                    }
+                };
+                return isCurveOk() && isInFrame();
+            };
+            isValid = isReadable(arrXCandidate, nodeFCandidate);
+            if (isValid) {
+                arrX = arrXCandidate;
+                nodeF = nodeFCandidate;
+            }
+        }
+        if (!isValid) {
+            const nodeIdsFDefault = {
+                id: 3,
+                leftChild: {
+                    id: 0,
+                    leftChild: {
+                        id: 2,
+                        leftChild: {
+                            id: 7,
+                            value: -20,
+                        },
+                        rightChild: {
+                            id: 5,
+                            leftChild: {
+                                id: 10,
+                                name: "x",
+                            },
+                            rightChild: {
+                                id: 7,
+                                value: 3,
+                            },
+                        },
+                    },
+                    rightChild: {
+                        id: 2,
+                        leftChild: {
+                            id: 7,
+                            value: 30,
+                        },
+                        rightChild: {
+                            id: 0,
+                            leftChild: {
+                                id: 0,
+                                leftChild: {
+                                    id: 2,
+                                    leftChild: {
+                                        id: 7,
+                                        value: 3,
+                                    },
+                                    rightChild: {
+                                        id: 5,
+                                        leftChild: {
+                                            id: 10,
+                                            name: "x",
+                                        },
+                                        rightChild: {
+                                            id: 7,
+                                            value: 2,
+                                        },
+                                    },
+                                },
+                                rightChild: {
+                                    id: 2,
+                                    leftChild: {
+                                        id: 7,
+                                        value: 20,
+                                    },
+                                    rightChild: {
+                                        id: 10,
+                                        name: "x",
+                                    },
+                                },
+                            },
+                            rightChild: {
+                                id: 7,
+                                value: -40,
+                            },
+                        },
+                    },
+                },
+                rightChild: {
+                    id: 7,
+                    value: 600,
+                },
+            };
+            nodeF = NodeConstructor.fromIdentifiers(nodeIdsFDefault);
+            arrX = [-2, 5];
+        }
+        return [arrX, nodeF];
+    })();
+    const arrXControl = getArrXControl(arrX, typeF);
+    const { xMin, xMax } = getXMinXMax(arrX, typeF);
+    const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+    const pointCenter = new Point("O", average([xMin, xMax]), average([yMin, yMax]));
+    const pointNames = "ABCDEFGHIJKLMNO".split("");
+    const arrPoint = arrXControl.map((_, i) => {
+        const sector = i % 4;
+        const distance = 1 + Math.floor(i / 4);
+        const [factorX, factorY] = (() => {
+            switch (sector) {
+                case 0:
+                    return [1, 1];
+                case 1:
+                    return [-1, 1];
+                case 2:
+                    return [-1, -1];
+                case 3:
+                    return [1, -1];
+                default:
+                    throw new Error("Unsupported sector: " + sector);
+            }
+        })();
+        const [x, y] = [factorX, factorY].map((factor) => factor * distance);
+        return new Point(pointNames[i], pointCenter.x.evaluate() + x, pointCenter.y.evaluate() + y);
+    });
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        pointIds: arrPoint.map((point) => point.toIdentifiers()),
+        nodeIdsAbscissa: arrX.map((x) => x.toTree().toIdentifiers()),
+        typeF,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers, opts),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        answerFormat: "tex",
+        keys: [],
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        identifiers,
+    };
+};
+const arrayedOptsDefault = {
+    typeF: [
+        "constante",
+        "affine",
+        "degré $2$",
+        "degré $3$ monotone",
+        "degré $3$ non-monotone",
+    ],
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Type de fonction $f$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "constante",
+            "affine",
+            "degré $2$",
+            "degré $3$ monotone",
+            "degré $3$ non-monotone",
+        ],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+];
+export const plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial = {
+    id: "plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial",
+    connector: "=",
+    label: "Construire une courbe plausible pour une fonction, à partir de la courbe de sa dérivée",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomialQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "GGB",
+};

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

@@ -165,10 +165,10 @@ export const readExtremaAbscissFromDerivativeCurve = {
     subject: "Mathématiques",
     getHint,
     getCorrection,
+    hasHintAndCorrection: true,
     getInstruction,
     getAnswer,
     getGGBOptions,
     hasGeogebra: true,
     getQuestionFromIdentifiers,
-    hasHintAndCorrection: true,
 };

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"signVarTableFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/signVarTableFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgM7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAmXF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyCF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,WAAW,EACX,OAAO,CAuBR,CAAC"}