math-exercises 3.0.178 → 3.0.179

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

@@ -0,0 +1,537 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.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 { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.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";
+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 {
+            return { xMin: Math.min(...arrX) - 2, xMax: Math.max(...arrX) + 2 };
+        }
+    }
+}
+function getArrXControl(arrX, typeF) {
+    if (typeF === "degré $3$ monotone") {
+        const [x] = arrX;
+        return [x - 2, x, x + 2];
+    }
+    else {
+        if (arrX.length === 0) {
+            return [-3, 0, 3];
+        }
+        else if (arrX.length === 1) {
+            const [x] = arrX;
+            return [x - 2, x, x + 2];
+        }
+        else {
+            return [
+                ...arrX,
+                ...zip(arrX.slice(0, -1), arrX.slice(1)).map(([x1, x2]) => average([x1, x2])),
+            ].toSorted((x1, x2) => x1 - x2);
+        }
+    }
+}
+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 };
+            }
+            case "degré $4$": {
+                const arrX = createRandomArrX(3);
+                const nodeF = createRandomNodeFFromZerosOfDerivative(arrX);
+                return { arrX, nodeF };
+            }
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    return { arrX, nodeF };
+};
+const getInstruction = (identifiers) => {
+    const { pointIds } = identifiers;
+    return `Ci-dessous est tracée en bleu la courbe $\\mathcal C_f$ de la fonction $f$.
+  
+En manipulant les points ${joinanded(pointIds.map((pointIds) => `$${pointIds.name}$`), ", ", " et ")},
+construire une courbe plausible pour $f'$.`;
+};
+const getAnswerPoints = (identifiers) => {
+    const { nodeIdsF, nodeIdsAbscissa, typeF, pointIds } = 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);
+    const pointCoordsAnswer = zip(pointIds, arrXControl).map(([pointIds, x]) => {
+        const y = nodeDerivative.evaluate({ x });
+        return new Point(pointIds.name, x, y);
+    });
+    return pointCoordsAnswer;
+};
+const getGGBAnswer = (identifiers) => {
+    return getAnswerPoints(identifiers).flatMap((point) => {
+        return point.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: true,
+            showLabel: true,
+            style: 0,
+            size: 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) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        `f'(x) = ${nodeDerivative.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 commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        //control points
+        ...arrPoint.flatMap((point) => point.toGGBCommand({
+            isFixed: false,
+            isSelectionnable: true,
+            showLabel: true,
+            style: 0,
+            size: 5,
+        })),
+        //Polynomial
+        `pol = Polynomial({${arrPoint.map((point) => point.name).join(",")}})`,
+    ];
+    const studentGGB = new GeogebraConstructor({
+        commands,
+        yAxis: {
+            hideNumbers: true,
+        },
+        interactiveObjects: arrPoint.map((point) => point.name),
+        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 { typeF } = identifiers;
+    const pointCoordsAns = parseGGBPoints(ggbAns)
+        .map((p) => ggbPointToCoords(p))
+        .toSorted(({ x: x1 }, { x: x2 }) => x1 - x2);
+    const pointCoordsAnswer = getAnswerPoints(identifiers).map((point) => {
+        return { x: point.x.evaluate(), y: point.y.evaluate() };
+    });
+    switch (typeF) {
+        case "constante": {
+            return pointCoordsAns.every(({ y: yAns }) => yAns === 0);
+        }
+        case "affine": {
+            const yAnswer = pointCoordsAnswer[0].y;
+            const yAns0 = pointCoordsAns[0].y;
+            return pointCoordsAns.every(({ y: yAns }) => yAns === yAns0 && yAns * yAnswer > 0);
+        }
+        case "degré $3$ monotone":
+        case "degré $2$": {
+            return zip(pointCoordsAns, pointCoordsAnswer).every(([{ x: xAns, y: yAns }, { x: xAnswer, y: yAnswer }], i) => {
+                if (i % 2 === 1) {
+                    const isZeroMatching = xAns === xAnswer && yAns === yAnswer; /*=== 0*/
+                    return isZeroMatching;
+                }
+                else {
+                    //x between zeros of f (guaranteed by sortingXAsc) and y with same sign
+                    const isSignMatching = yAns * yAnswer > 0;
+                    return isSignMatching;
+                }
+            });
+        }
+        case "degré $3$ non-monotone":
+        case "degré $4$": {
+            return zip(pointCoordsAns, pointCoordsAnswer).every(([{ x: xAns, y: yAns }, { x: xAnswer, y: yAnswer }], i) => {
+                if (i % 2 === 0) {
+                    const isZeroMatching = xAns === xAnswer && yAns === yAnswer; /*=== 0*/
+                    return isZeroMatching;
+                }
+                else {
+                    //x between zeros of f (guaranteed by sortingXAsc) and y with same sign
+                    const isSignMatching = yAns * yAnswer > 0;
+                    return isSignMatching;
+                }
+            });
+        }
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+const getPlausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomialQuestion = (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",
+        "degré $4$",
+    ],
+};
+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",
+            "degré $4$",
+        ],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+];
+export const plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial = {
+    id: "plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial",
+    connector: "=",
+    label: "À partir de la courbe d'une fonction, construire une courbe plausible pour sa dérivée",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomialQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "GGB",
+};

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

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsF: NodeIdentifiers;
+    pointIds: PointIdentifiers[];
+    nodeIdsAbscissa: NodeIdentifiers[];
+    typeF: string;
+};
+type Options = {
+    typeF: string;
+};
+export declare const plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/plausibleFunctionGraphFromDerivativeGraphByManipulatingPolynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAYtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkK7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAokBF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkCF,eAAO,MAAM,iEAAiE,EAAE,QAAQ,CACtF,WAAW,EACX,OAAO,CAuBR,CAAC"}