math-exercises 3.0.178 → 3.0.179

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

@@ -0,0 +1,499 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SetVEA } from "../../../../exercises/vea/setVEA.js";
+import { blueMain, greenMain, orange, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { createIntegratedPolynomialNode, createNodeFPolynomialFromRoots, getArrNodeCoeffOfPolynomialNode, } 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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+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,
+    };
+}
+function getNodeYIntercept(nodeF, nodeXAsked, nodeDerivative = nodeF.derivative()) {
+    const nodeValueImage = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+    const nodeX = "x".toTree();
+    const nodeT = add(multiply(nodeValueDerivative, substract(nodeX, nodeXAsked)), nodeValueImage);
+    const [nodeYIntercept] = getArrNodeCoeffOfPolynomialNode(nodeT);
+    return nodeYIntercept;
+}
+const getInstruction = (identifiers) => {
+    const { nodeIdsSlope } = identifiers;
+    const nodeSlope = NodeConstructor.fromIdentifiers(nodeIdsSlope);
+    return `Ci-dessous est tracée la courbe $\\mathcal C_f$ de la fonction $f$.
+  
+En manipulant le point $A$ et le point $B$
+on peut changer l'ordonnée à l'origine et la pente de la droite $(AB)$.
+
+Résoudre l'équation $f'(x) = ${nodeSlope.toTex()}$ sur l'intervalle visible.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsAbscissa } = identifiers;
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeSet = new DiscreteSetNode(arrNodeX);
+    return nodeSet;
+};
+const getAnswer = (identifiers) => {
+    return `S=${getAnswerNode(identifiers).toTex()}`;
+};
+const getHint = (identifiers) => {
+    const { nodeIdsSlope } = identifiers;
+    const nodeSlope = NodeConstructor.fromIdentifiers(nodeIdsSlope);
+    return `Le nombre dérivé de $f$ en $x$, aussi noté $f'(x)$, est le coefficient directeur la tangente à la courbe représentative de $f$ au point d'abscisse $x$.
+  
+Résoudre l'équation $f'(x) = k$, 
+c'est trouver toutes les abscisses $x$ 
+pour lesquelles le coefficient directeur la tangente à la courbe représentative de $f$ vaut $k$.
+
+Ici, on a $k = ${nodeSlope.toTex()}$.
+
+La première étape consiste à faire en sorte que la pente de la droite $(AB)$ soit égale à $${nodeSlope.toTex()}$ : 
+monte ou descend le point $B$ jusqu'à ce que la valeur de la pente affichée corresponde à $${nodeSlope.toTex()}$.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsSlope } = identifiers;
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeSlope = NodeConstructor.fromIdentifiers(nodeIdsSlope);
+    return `Le nombre dérivé de $f$ en $x$, aussi noté $f'(x)$, est le coefficient directeur la tangente à la courbe représentative de $f$ au point d'abscisse $x$.
+
+La première étape consiste à faire en sorte que la pente de la droite $(AB)$ soit égale à $${nodeSlope.toTex()}$ : 
+on monte ou descend le point $B$ jusqu'à ce que la valeur de la pente affichée corresponde à $${nodeSlope.toTex()}$.
+
+En manipulant le point $A$, on observe que :
+
+${alignTex(arrNodeX.map((nodeX) => {
+        return [`f'(${nodeX.toTex()})`, "=", `${nodeSlope.toTex()}`];
+    }))}
+
+La solution de l'équation est donc :
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsSlope, nodeIdsF } = identifiers;
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeSlope, nodeF] = [nodeIdsSlope, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const slope = nodeSlope.evaluate();
+    const arrX = arrNodeX.map((node) => node.evaluate());
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        //solution
+        ...arrX.flatMap((x, i) => {
+            const image = nodeF.evaluate({
+                x,
+            });
+            return [
+                //tangent
+                `t${i}(x) = ${image} + (x-${x}) (${slope})`,
+                `SetColor(t${i}, "${orange}")`,
+                //curve point
+                `B${i} = (${x},${image})`,
+                `SetPointStyle(B${i}, 1)`,
+                //arrow
+                `v${i} = Vector(B${i}, Point({${x},0}))`,
+                `SetColor(v${i}, "${greenMain}")`,
+                //point
+                `C${i} = (${x},0)`,
+                `SetPointStyle(C${i}, 1)`,
+                `SetColor(C${i}, "${greenMain}")`,
+                `SetCaption(C${i}, "$${x.frenchify()}$")`,
+                `ShowLabel(C${i}, true)`,
+            ];
+        }),
+    ];
+    const xMin = Math.min(...arrX) - 2;
+    const xMax = Math.max(...arrX) + 2;
+    const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin: Math.min(yMin, -2),
+            yMax,
+        }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsSlope, nodeIdsF } = identifiers;
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeSlope, nodeF] = [nodeIdsSlope, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrX = arrNodeX.map((node) => node.evaluate());
+    const nodeDerivative = nodeF.derivative();
+    const arrNodeYIntercept = arrNodeX.map((nodeXAsked) => getNodeYIntercept(nodeF, nodeXAsked, nodeDerivative));
+    const xMin = Math.min(...arrX) - 2;
+    const xMax = Math.max(...arrX) + 2;
+    const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+    const [minSliderA, maxSliderA] = [-50, 50];
+    const stepSliderA = 0.01;
+    const valueSliderAInitial = randfloat(yMin, yMax, 1, [
+        ...arrNodeYIntercept.map((nodeY) => nodeY.evaluate()),
+    ]);
+    const [minSliderB, maxSliderB] = [-50, 50];
+    const stepSliderB = 0.1;
+    const valueSliderBInitial = randfloat(yMin, yMax, 1, [nodeSlope.evaluate()]);
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        `SetColor(f, "${blueMain}")`,
+        //moving point A
+        `a = Slider(${minSliderA}, ${maxSliderA}, ${stepSliderA})`,
+        `SetValue(a, ${valueSliderAInitial})`,
+        `SetVisibleInView(a, 1, false)`,
+        `A = (0,a)`,
+        "SetPointStyle(A, 0)",
+        "SetPointSize(A,5)",
+        `ShowLabel(A,true)`,
+        //moving point B
+        `b = Slider(${minSliderB}, ${maxSliderB}, ${stepSliderB})`,
+        `SetValue(b, ${valueSliderBInitial})`,
+        `SetVisibleInView(b, 1, false)`,
+        `B = (1,b+a)`, //order matters here: in ggb, the slider which is first found is the one that is modified when moving point
+        "SetPointStyle(B, 0)",
+        "SetPointSize(B,5)",
+        `ShowLabel(B,true)`,
+        //"tangent"
+        `lineAB = Line(A,B)`,
+        `SetColor(lineAB, "${red}")`,
+        `s = Slope(lineAB)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin: Math.min(yMin, -2),
+            yMax,
+        }),
+    });
+};
+const getPropositions = (n, { answer, ..._identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, _optsIn) => {
+    const answerNode = getAnswerNode(identifiers);
+    const arrNodeAnswer = answerNode.elements;
+    const parsed = discreteSetParser(ans);
+    if (!parsed) {
+        return false;
+    }
+    const arrAns = parsed.elements;
+    return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+};
+const createRandomIdentifiers = () => {
+    const nbX = randint(2, 4);
+    const arrX = (() => {
+        function createRandomArrX() {
+            const poolX = [...Array(11).keys()].map((i) => i - 5);
+            return randomMany(poolX, nbX).toSorted((v1, v2) => v1 - v2);
+        }
+        let arrX = [];
+        let isValid = false;
+        let counter = -1;
+        while (!isValid && counter < 100) {
+            counter++;
+            const arrXCandidate = createRandomArrX();
+            const isSeparatedNicely = () => zip(arrXCandidate.slice(0, -1), arrXCandidate.slice(1))
+                .map(([x1, x2]) => x2 - x1)
+                .find((elt) => elt === 1) === undefined;
+            isValid = isSeparatedNicely();
+            if (isValid) {
+                arrX = arrXCandidate;
+            }
+        }
+        if (!isValid) {
+            switch (nbX) {
+                case 0:
+                    return [-3];
+                case 1:
+                    return [-2, 3];
+                case 2:
+                    return [-4, 2, 5];
+            }
+        }
+        return arrX;
+    })();
+    const arrNodeX = arrX.map((x) => x.toTree());
+    //f'(x) = a(x-x1)...(x-xn) + k
+    //=> f'(x1) = ... = f'(xn) = k
+    const nodeA = frac(coinFlip() ? -1 : +1, 5 * nbX);
+    const maxSlopeAbs = 1.5;
+    const nodeK = randfloat(-maxSlopeAbs, maxSlopeAbs, 1, [0]).toTree();
+    const nodeDerivative = add(createNodeFPolynomialFromRoots(nodeA, arrNodeX), nodeK);
+    const nodeC = randint(-3, 3).toTree();
+    const nodeF = createIntegratedPolynomialNode(nodeDerivative, nodeC);
+    const identifiers = {
+        nodeIdsSlope: nodeK.toIdentifiers(),
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsAbscissa: arrNodeX.map((node) => node.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getDerivativeEquationSolvingByManipulatingLineYAndSlopeQuestion = (opts) => {
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        const isReadable = (identifiers) => {
+            const { nodeIdsAbscissa, nodeIdsF } = identifiers;
+            const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+            const arrX = arrNodeX.map((node) => node.evaluate());
+            const xMin = Math.min(...arrX) - 2;
+            const xMax = Math.max(...arrX) + 2;
+            const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+            return frac(yMax - yMin, xMax - xMin).evaluate() <= 0.888;
+        };
+        const isDerivativeOk = (identifiers) => {
+            const { nodeIdsAbscissa, nodeIdsSlope, nodeIdsF } = identifiers;
+            const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const [nodeSlope, nodeF] = [nodeIdsSlope, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const nodeDerivative = nodeF.derivative().simplify();
+            return arrNodeX.every((nodeX) => nodeDerivative.evaluate({ x: nodeX.evaluate() }) ===
+                nodeSlope.evaluate());
+        };
+        const isYInterceptsOk = (identifiers) => {
+            const { nodeIdsAbscissa, nodeIdsSlope, nodeIdsF } = identifiers;
+            const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const [nodeSlope, nodeF] = [nodeIdsSlope, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const slope = nodeSlope.evaluate();
+            const nodeDerivative = nodeF.derivative().simplify();
+            const arrNodeYIntercept = arrNodeX.map((nodeX) => getNodeYIntercept(nodeF, nodeX, nodeDerivative));
+            const arrYInterceptSorted = arrNodeYIntercept
+                .map((node) => node.evaluate())
+                .toSorted((y1, y2) => y1 - y2);
+            const isReachableYIntercepts = () => {
+                const arrX = arrNodeX.map((node) => node.evaluate());
+                const xMin = Math.min(...arrX) - 1;
+                const xMax = Math.max(...arrX) + 1;
+                const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+                return arrYInterceptSorted.every((yIntercept) => yMin < yIntercept && yIntercept < yMax);
+            };
+            const isDistinctYIntercepts = () => {
+                return zip(arrYInterceptSorted.slice(0, -1), arrYInterceptSorted.slice(1)).every(([y1, y2]) => y2 - y1 > 0.666 * Math.abs(slope));
+            };
+            return isReachableYIntercepts() && isDistinctYIntercepts();
+        };
+        isValid =
+            isReadable(identifiersCandidate) &&
+                isDerivativeOk(identifiersCandidate) &&
+                isYInterceptsOk(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        //copié-collé depuis le dashboard::viewer
+        const identifiersDefault = {
+            nodeIdsSlope: {
+                id: 7,
+                value: -0.2,
+            },
+            nodeIdsF: {
+                id: 3,
+                leftChild: {
+                    id: 0,
+                    leftChild: {
+                        id: 2,
+                        leftChild: {
+                            id: 7,
+                            value: 2025,
+                        },
+                        rightChild: {
+                            id: 5,
+                            leftChild: {
+                                id: 10,
+                                name: "x",
+                            },
+                            rightChild: {
+                                id: 7,
+                                value: 4,
+                            },
+                        },
+                    },
+                    rightChild: {
+                        id: 2,
+                        leftChild: {
+                            id: 7,
+                            value: 60,
+                        },
+                        rightChild: {
+                            id: 0,
+                            leftChild: {
+                                id: 2,
+                                leftChild: {
+                                    id: 7,
+                                    value: -225,
+                                },
+                                rightChild: {
+                                    id: 5,
+                                    leftChild: {
+                                        id: 10,
+                                        name: "x",
+                                    },
+                                    rightChild: {
+                                        id: 7,
+                                        value: 3,
+                                    },
+                                },
+                            },
+                            rightChild: {
+                                id: 2,
+                                leftChild: {
+                                    id: 7,
+                                    value: 9,
+                                },
+                                rightChild: {
+                                    id: 0,
+                                    leftChild: {
+                                        id: 2,
+                                        leftChild: {
+                                            id: 7,
+                                            value: -30,
+                                        },
+                                        rightChild: {
+                                            id: 5,
+                                            leftChild: {
+                                                id: 10,
+                                                name: "x",
+                                            },
+                                            rightChild: {
+                                                id: 7,
+                                                value: 2,
+                                            },
+                                        },
+                                    },
+                                    rightChild: {
+                                        id: 2,
+                                        leftChild: {
+                                            id: 7,
+                                            value: 15,
+                                        },
+                                        rightChild: {
+                                            id: 0,
+                                            leftChild: {
+                                                id: 2,
+                                                leftChild: {
+                                                    id: 7,
+                                                    value: 17,
+                                                },
+                                                rightChild: {
+                                                    id: 10,
+                                                    name: "x",
+                                                },
+                                            },
+                                            rightChild: {
+                                                id: 7,
+                                                value: -30,
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                rightChild: {
+                    id: 7,
+                    value: 121500,
+                },
+            },
+            nodeIdsAbscissa: [
+                {
+                    id: 7,
+                    value: -2,
+                },
+                {
+                    id: 7,
+                    value: 2,
+                },
+                {
+                    id: 7,
+                    value: 5,
+                },
+            ],
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        answerFormat: "tex",
+        keys: ["S", "equal", "lbrace", "semicolon", "rbrace"],
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        identifiers,
+    };
+};
+export const derivativeEquationSolvingByManipulatingLineYAndSlope = {
+    id: "derivativeEquationSolvingByManipulatingLineYAndSlope",
+    connector: "=",
+    label: `Résoudre une équation du type "$f'(x) = k$" par la manipulation d'une droite de coefficient directeur réglable`,
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getDerivativeEquationSolvingByManipulatingLineYAndSlopeQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    x: number;
+    k: number;
+    nodeIds: NodeIdentifiers[];
+};
+export declare const derivativeEquationSolvingByManipulatingPoint: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=derivativeEquationSolvingByManipulatingPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeEquationSolvingByManipulatingPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeEquationSolvingByManipulatingPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AA+QF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAmB5E,CAAC"}