math-exercises 3.0.177 → 3.0.179

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

@@ -0,0 +1,295 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, orange, pinkMain, } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { createArrNodeCoeffCubic, PointOfFunction, PointOfFunctionConstructor, } from "../../../../math/utils/polynomial/polynomialInterpolationUtils.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 { zip } from "../../../../utils/arrays/arrayZip.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+//create spline: seam cubics together
+function createNodeFCubic(arrNodesCoeff) {
+    const [d, c, b, a] = arrNodesCoeff.map((node) => node.evaluate());
+    const nodeX = "x".toTree();
+    const nodeCubic = [d, c, b, a].reduce((acc, coeff, i) => {
+        return add(acc, multiply(coeff, power(nodeX, i)));
+    }, (0).toTree());
+    return nodeCubic;
+}
+function createCubicSpline(arrArrPOF) {
+    const arrChunk = arrArrPOF.map(([pof1, pof2]) => {
+        const nodeXStart = pof1.nodeAbscissa;
+        const nodeXEnd = pof2.nodeAbscissa;
+        const nodeFCubic = createNodeFCubic(createArrNodeCoeffCubic(pof1, pof2));
+        const chunk = {
+            nodeFCubic,
+            nodeXStart,
+            nodeXEnd,
+        };
+        return chunk;
+    });
+    const cubicSpline = new CubicSpline(arrChunk);
+    return cubicSpline;
+}
+class CubicSpline {
+    chunks;
+    constructor(chunks) {
+        this.chunks = chunks;
+    }
+    toIdentifiers() {
+        const arrChunkIds = this.chunks.map((chunk) => {
+            const chunkIds = {
+                nodeIdsFCubic: chunk.nodeFCubic.toIdentifiers(),
+                nodeIdsXStart: chunk.nodeXStart.toIdentifiers(),
+                nodeIdsXEnd: chunk.nodeXEnd.toIdentifiers(),
+            };
+            return chunkIds;
+        });
+        return {
+            chunkIds: arrChunkIds,
+        };
+    }
+}
+class CubicSplineConstructor {
+    static fromIdentifiers(cubicSplineIds) {
+        const arrChunk = cubicSplineIds.chunkIds.map((chunkIds) => {
+            const chunk = {
+                nodeFCubic: NodeConstructor.fromIdentifiers(chunkIds.nodeIdsFCubic),
+                nodeXStart: NodeConstructor.fromIdentifiers(chunkIds.nodeIdsXStart),
+                nodeXEnd: NodeConstructor.fromIdentifiers(chunkIds.nodeIdsXEnd),
+            };
+            return chunk;
+        });
+        return new CubicSpline(arrChunk);
+    }
+}
+const getSolutionPoints = (identifiers) => {
+    const { pofIds } = identifiers;
+    const arrPOF = pofIds.map((pofIds) => PointOfFunctionConstructor.fromIdentifiers(pofIds));
+    return arrPOF.map((pof, i) => {
+        const { nodeAbscissa, nodeDerivative } = pof;
+        return new Point(`S${i}`, nodeAbscissa, nodeDerivative);
+    });
+};
+const getInstruction = () => {
+    return `La courbe représentative d'une fonction $f$ (notée $C_f$) est tracée ci-dessous.
+  
+Les tangentes à $C_f$ en différents points sont également tracées. 
+
+Pour chaque tangente tracée, placer sur le même graphique, le point appartenant à la courbe représentative de $f'$. 
+`;
+};
+const getGGBAnswer = (identifiers) => {
+    const solutionPoints = getSolutionPoints(identifiers);
+    return [
+        ...solutionPoints.flatMap((point) => point.toGGBCommand({ color: `${greenMain}`, showLabel: false })),
+    ];
+};
+const getHint = () => {
+    return `Place chaque point de coordonnées $(x;f'(x))$.`;
+};
+const getCorrection = (identifiers) => {
+    const solutionPoints = getSolutionPoints(identifiers);
+    return `On place chaque point de coordonnées $(x;f'(x))$.
+  
+On place donc les points de coordonnées ${joinanded(solutionPoints.map((p) => `$(${p.x.toTex()};${p.y.simplify().toTex()})$`), ", ", " et ")} (ci-dessous en vert).
+  
+On a également représenté ci-dessous la courbe représentative de la fonction dérivée (en rose foncé) pour avoir une vue globale.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { cubicSplineIds, pofIds } = identifiers;
+    const cubicSpline = CubicSplineConstructor.fromIdentifiers(cubicSplineIds);
+    const arrPOF = pofIds.map((pofIds) => PointOfFunctionConstructor.fromIdentifiers(pofIds));
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //function (chunks)
+            ...cubicSpline.chunks.flatMap((chunk, i, arr) => {
+                const isFirst = i === 0;
+                const isLast = i === arr.length - 1;
+                const xStart = isFirst ? -20 : chunk.nodeXStart.evaluate();
+                const xEnd = isLast ? +20 : chunk.nodeXEnd.evaluate();
+                return [
+                    `f${i}(x) = Function(${chunk.nodeFCubic.toMathString()}, ${xStart}, ${xEnd})`,
+                    `SetColor(f${i}, "${blueMain}")`,
+                ];
+            }),
+            //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}")`,
+                ];
+            }),
+            //derivative (chunks)
+            ...cubicSpline.chunks.flatMap((chunk, i, arr) => {
+                const isFirst = i === 0;
+                const isLast = i === arr.length - 1;
+                const xStart = isFirst ? -20 : chunk.nodeXStart.evaluate();
+                const xEnd = isLast ? +20 : chunk.nodeXEnd.evaluate();
+                return [
+                    `d${i}(x) = Function(${chunk.nodeFCubic
+                        .derivative()
+                        .toMathString()}, ${xStart}, ${xEnd})`,
+                    `SetColor(d${i}, "${pinkMain}")`,
+                ];
+            }),
+            //derivative (points)
+            ...arrPOF.flatMap((pof, i) => {
+                const a = pof.nodeAbscissa.evaluate();
+                const v = pof.nodeDerivative.evaluate();
+                return [
+                    `D${i} = Point({${a}, ${v}})`,
+                    `SetFixed(D${i}, true, false)`,
+                    `SetColor(D${i}, "${greenMain}")`,
+                ];
+            }),
+        ],
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([
+            ...arrPOF.map((pof, i) => new Point(`P${i}`, pof.nodeAbscissa, pof.nodeValue)),
+            ...getSolutionPoints(identifiers),
+        ]),
+    });
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { cubicSplineIds, pofIds } = identifiers;
+    const cubicSpline = CubicSplineConstructor.fromIdentifiers(cubicSplineIds);
+    const arrPOF = pofIds.map((pofIds) => PointOfFunctionConstructor.fromIdentifiers(pofIds));
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //function (chunks)
+            ...cubicSpline.chunks.flatMap((chunk, i, arr) => {
+                const isFirst = i === 0;
+                const isLast = i === arr.length - 1;
+                const xStart = isFirst ? -20 : chunk.nodeXStart.evaluate();
+                const xEnd = isLast ? +20 : chunk.nodeXEnd.evaluate();
+                return [
+                    `f${i}(x) = Function(${chunk.nodeFCubic.toMathString()}, ${xStart}, ${xEnd})`,
+                    `SetColor(f${i}, "${blueMain}")`,
+                ];
+            }),
+            //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}, true, false)`,
+                    `SetColor(P${i}, "${orange}")`,
+                ];
+            }),
+        ],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([
+            ...arrPOF.map((pof, i) => new Point(`P${i}`, pof.nodeAbscissa, pof.nodeValue)),
+            ...getSolutionPoints(identifiers),
+        ]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const commands = ans;
+    const ggbParser = new GeogebraParser(commands);
+    const objectDict = ggbParser.objectDict();
+    const pointsCoords = Object.keys(objectDict).map((name) => ggbParser.pointCoords(name));
+    const pointsCoordsSortedByAscX = pointsCoords.toSorted(([x1], [x2]) => {
+        return x1 - x2;
+    });
+    const solutionPointsSortedByAscX = getSolutionPoints(identifiers).toSorted((p1, p2) => {
+        return p1.x.evaluate() - p2.x.evaluate();
+    });
+    return (pointsCoordsSortedByAscX.length === solutionPointsSortedByAscX.length &&
+        pointsCoordsSortedByAscX.every(([x, y], i) => {
+            const studentPoint = new Point("StudentPoint", x, y);
+            const solutionPoint = solutionPointsSortedByAscX[i];
+            const distance = studentPoint.distanceTo(solutionPoint);
+            return distance < 1;
+        }));
+};
+const getPlacePointsOfDerivativeFromGraphQuestion = () => {
+    const arrNodeAbscissa = [
+        randint(-10, -5),
+        randint(-5, 0),
+        randint(0, 5),
+        randint(6, 10),
+    ].map((x) => x.toTree());
+    const arrNodeImage = arrNodeAbscissa
+        .slice(1)
+        .reduce((acc, _, i) => {
+        const yPrev = acc[i];
+        const yNew = yPrev + randint(-5, 6);
+        acc.push(yNew);
+        return acc;
+    }, [randint(-9, 10)])
+        .map((x) => x.toTree());
+    const arrNodeDerivative = arrNodeAbscissa.map(() => {
+        const num = randint(-3, 3);
+        const den = randint(-3, 3, [0]);
+        return frac(num, den);
+    });
+    const arrPOF = zip(arrNodeAbscissa, zip(arrNodeImage, arrNodeDerivative)).map(([nodeAbscissa, [nodeValue, nodeDerivative]]) => {
+        const pof = new PointOfFunction(nodeAbscissa, nodeValue, nodeDerivative);
+        return pof;
+    });
+    const arrArrPOF = zip(arrPOF.slice(0, -1), arrPOF.slice(1));
+    const cubicSpline = createCubicSpline(arrArrPOF);
+    const identifiers = {
+        cubicSplineIds: cubicSpline.toIdentifiers(),
+        pofIds: arrPOF.map((pof) => pof.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        style: {
+            tableOptions: {
+                firstCellIsDivided: false,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+};
+export const placePointsOfDerivativeFromGraph = {
+    id: "placePointsOfDerivativeFromGraph",
+    label: "Placer des points de la dérivée à partir des tangentes à la courbe représentative d'une fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlacePointsOfDerivativeFromGraphQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/tangent/tangentEquationFromFunctionExpression.d.ts

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

package/lib/exercises/math/derivation/tangent/tangentEquationFromFunctionExpression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tangentEquationFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/tangentEquationFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgF7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsWF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgDF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAqBR,CAAC"}