math-exercises 3.0.190 → 3.0.192

package/lib/exercises/math/functions/affines/affineCompareTwoImagesFromVariations.js

@@ -0,0 +1,205 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+const strTypeFFromNodeSlope = (nodeSlope) => {
+    const valueSlope = nodeSlope.evaluate();
+    if (valueSlope === 0) {
+        return "Constante";
+    }
+    else if (valueSlope > 0) {
+        return "Strictement croissante";
+    }
+    else {
+        return "Strictement décroissante";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsSlope, typeAbscissa } = identifiers;
+    const [nodeX1, nodeX2] = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeX1Display, nodeX2Display] = typeAbscissa === "Nombres"
+        ? [nodeX1, nodeX2]
+        : ["a", "b"].map((varName) => new VariableNode(varName));
+    const nodeSlope = NodeConstructor.fromIdentifiers(nodeIdsSlope);
+    const strVariationsF = strTypeFFromNodeSlope(nodeSlope);
+    return `Soit $f$ une fonction affine ${strVariationsF.toLocaleLowerCase()}.
+
+${(() => {
+        switch (typeAbscissa) {
+            case "Lettres": {
+                const [nodeXDisplaySmall, nodeXDisplayBig] = zip([nodeX1Display, nodeX2Display], [nodeX1, nodeX2])
+                    .toSorted(([, node1], [_, node2]) => substract(node1, node2).evaluate())
+                    .map(([nodeXDisplay]) => nodeXDisplay);
+                return `Soient deux nombres $${nodeX1Display.toTex()}$ et $${nodeX2Display.toTex()}$ tels que : 
+
+$$
+${nodeXDisplaySmall.toTex()} < ${nodeXDisplayBig.toTex()}
+$$
+
+`;
+            }
+            default:
+                return "";
+        }
+    })()}
+    
+Comparer $f(${nodeX1Display.toTex()})$ et $f(${nodeX2Display.toTex()})$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsSlope, typeAbscissa } = identifiers;
+    const [nodeX1, nodeX2] = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeX1Display, nodeX2Display] = typeAbscissa === "Nombres"
+        ? [nodeX1, nodeX2]
+        : ["a", "b"].map((varName) => new VariableNode(varName));
+    const nodeSlope = NodeConstructor.fromIdentifiers(nodeIdsSlope);
+    const strVariationsF = strTypeFFromNodeSlope(nodeSlope);
+    const [nodeXDisplaySmall, nodeXDisplayBig] = zip([nodeX1Display, nodeX2Display], [nodeX1, nodeX2])
+        .toSorted(([, node1], [_, node2]) => substract(node1, node2).evaluate())
+        .map(([nodeXDisplay]) => nodeXDisplay);
+    switch (strVariationsF) {
+        case "Constante":
+            return `f(${nodeXDisplaySmall.toTex()}) = f(${nodeXDisplayBig.toTex()})`;
+        case "Strictement croissante":
+            return `f(${nodeXDisplaySmall.toTex()}) < f(${nodeXDisplayBig.toTex()})`;
+        case "Strictement décroissante":
+            return `f(${nodeXDisplaySmall.toTex()}) > f(${nodeXDisplayBig.toTex()})`;
+        default:
+            throw new Error("Unsupported strVariationsF: " + strVariationsF);
+    }
+};
+const getHint = () => {
+    return `Soit $f$ une fonction affine et $x_{1}$ et $x_{2}$ deux réels distincts tels que :
+  
+$$
+x_{1}<x_{2}
+$$
+
+Si la fonction $f$ est strictement croissante alors :
+
+$$
+f(x_{1})<f(x_{2})
+$$
+
+Si la fonction $f$ est strictement décroissante alors :
+
+$$
+f(x_{1})>f(x_{2})
+$$
+
+Si la fonction $f$ est constante alors :
+
+$$
+f(x_{1})=f(x_{2})
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsSlope, typeAbscissa } = identifiers;
+    const [nodeX1, nodeX2] = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeX1Display, nodeX2Display] = typeAbscissa === "Nombres"
+        ? [nodeX1, nodeX2]
+        : ["a", "b"].map((varName) => new VariableNode(varName));
+    const nodeSlope = NodeConstructor.fromIdentifiers(nodeIdsSlope);
+    const strVariationsF = strTypeFFromNodeSlope(nodeSlope);
+    const [nodeXDisplaySmall, nodeXDisplayBig] = zip([nodeX1Display, nodeX2Display], [nodeX1, nodeX2])
+        .toSorted(([, node1], [_, node2]) => substract(node1, node2).evaluate())
+        .map(([nodeXDisplay]) => nodeXDisplay);
+    return `$f$ est une fonction affine ${strVariationsF.toLocaleLowerCase()}.
+  
+On a : 
+
+$$
+${nodeXDisplaySmall.toTex()} < ${nodeXDisplayBig.toTex()}
+$$
+
+Par conséquent : 
+
+$$
+${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (_n, { answer, ...identifiers }) => {
+    const { nodeIdsAbscissa, typeAbscissa } = identifiers;
+    const [nodeX1, nodeX2] = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeX1Display, nodeX2Display] = typeAbscissa === "Nombres"
+        ? [nodeX1, nodeX2]
+        : ["a", "b"].map((varName) => new VariableNode(varName));
+    const [nodeXDisplaySmall, nodeXDisplayBig] = zip([nodeX1Display, nodeX2Display], [nodeX1, nodeX2])
+        .toSorted(([, node1], [_, node2]) => substract(node1, node2).evaluate())
+        .map(([nodeXDisplay]) => nodeXDisplay);
+    const propositions = [];
+    ["<", ">", "="].map((strSymbol) => {
+        const tex = `f(${nodeXDisplaySmall.toTex()}) ${strSymbol} f(${nodeXDisplayBig.toTex()})`;
+        if (tex === answer) {
+            addValidProp(propositions, answer);
+        }
+        else {
+            tryToAddWrongProp(propositions, tex);
+        }
+    });
+    return propositions;
+};
+const getAffineCompareTwoImagesFromVariationsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { typeAbscissa } = opts;
+    const xA = randint(-9, 10);
+    const xB = randint(-9, 10, [xA]);
+    const slope = probaLawFlip([
+        [randfloat(0, 3, 2, [0]), 0.45],
+        [randfloat(-3, 0, 2, [0]), 0.45],
+        [0, 0.1],
+    ]);
+    const identifiers = {
+        nodeIdsAbscissa: [xA, xB].map((v) => v.toTree().toIdentifiers()),
+        nodeIdsSlope: slope.toTree().toIdentifiers(),
+        typeAbscissa,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const optsDefault = {
+    typeAbscissa: "Nombres",
+};
+const options = [
+    {
+        id: "typeAbscissa",
+        label: "Type d'abscisses :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Nombres", "Lettres"],
+        defaultValue: optsDefault.typeAbscissa,
+    },
+];
+export const affineCompareTwoImagesFromVariations = {
+    id: "affineCompareTwoImagesFromVariations",
+    connector: "=",
+    label: "Comparer deux images d'une fonction affine dont on connaît le sens de variation",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAffineCompareTwoImagesFromVariationsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/affines/affineVarTableOnBoundedInterval.d.ts

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

package/lib/exercises/math/functions/affines/affineVarTableOnBoundedInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineVarTableOnBoundedInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineVarTableOnBoundedInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AA8KF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAqBjE,CAAC"}

package/lib/exercises/math/functions/affines/affineVarTableOnBoundedInterval.js

@@ -0,0 +1,157 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { varTableVEA } from "../../../../exercises/vea/varTableVEA.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { nodeIdsBounds, nodeIdsF } = identifiers;
+    const [nodeX1, nodeX2] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const strInterval = `[${nodeX1.toTex()};${nodeX2.toTex()}]`;
+    return `Dresser le tableau de variations de la fonction $f$ sur l'intervalle $${strInterval}$.
+  
+On donne, pour tout $x$ dans $${strInterval}$ :
+
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+`;
+};
+const getAnswerTable = (identifiers) => {
+    const { nodeIdsBounds, nodeIdsF } = identifiers;
+    const [nodeX1, nodeX2] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const [nodeImage1, nodeImage2] = [nodeX1, nodeX2].map((nodeX) => nodeBySubstitutingVar(nodeF, nodeX, "x".toTree()));
+    if (nodeImage1.evaluate() < nodeImage2.evaluate()) {
+        return [
+            ["$x$", nodeX1.toTex(), "\\ ", nodeX2.toTex()],
+            [
+                "$\\ $",
+                "\\ ",
+                "\\ ",
+                nodeImage2.simplify({ towardsDistribute: true }).toTex(),
+            ],
+            ["$f(x)$", "\\ ", "\\nearrow", "\\ "],
+            [
+                "$\\ $",
+                nodeImage1.simplify({ towardsDistribute: true }).toTex(),
+                "\\ ",
+                "\\ ",
+            ],
+        ];
+    }
+    else {
+        return [
+            ["$x$", nodeX1.toTex(), "\\ ", nodeX2.toTex()],
+            [
+                "$\\ $",
+                nodeImage1.simplify({ towardsDistribute: true }).toTex(),
+                "\\ ",
+                "\\ ",
+            ],
+            ["$f(x)$", "\\ ", "\\searrow", "\\ "],
+            [
+                "$\\ $",
+                "\\ ",
+                "\\ ",
+                nodeImage2.simplify({ towardsDistribute: true }).toTex(),
+            ],
+        ];
+    }
+};
+const getHint = () => {
+    return `Inscris les bornes de l'intervalle sur la ligne "$x$".
+Détermine le signe du coefficient directeur de la fonction $f$. 
+S'il est strictement positif, $f$ est strictement croissante sur $\\mathbb{R}$.
+S'il est strictement négatif, $f$ est strictement décroissante sur $\\mathbb{R}$.
+Tu peux donc choisir le sens de la flèche sur la ligne "$f(x)$" et monter ou descendre chaque boîte de saisie pour correspondre au sens de la flêche.
+Ensuite, calcule l'image correspondant à chaque borne de l'intervalle pour terminer de remplir le tableau.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsBounds, nodeIdsF } = identifiers;
+    const [nodeX1, nodeX2] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeSlope = nodeF.derivative().simplify({ towardsDistribute: true });
+    const strInterval = `[${nodeX1.toTex()};${nodeX2.toTex()}]`;
+    const [nodeImage1, nodeImage2] = [nodeX1, nodeX2].map((nodeX) => nodeBySubstitutingVar(nodeF, nodeX, "x".toTree()));
+    const a = nodeSlope.evaluate();
+    return `On inscrit les bornes de $${strInterval}$ sur la ligne "$x$".
+D'après l'expression de $f(x)$, le coefficient directeur de la fonction $f$ est $${nodeSlope.toTex()}$. 
+$f$ est donc ${a > 0 ? "strictement croissante" : "strictement décroissante"} sur $\\mathbb{R}$ et a fortiori sur l'intervalle $${strInterval}$.
+On peut donc sélectionner le sens de la flèche (${a > 0 ? "vers le haut" : "vers le bas"}) et positionner les boîtes de saisie des images.
+On calcule enfin l'image de chaque borne de l'intervalle :
+
+$$
+f(${nodeX1.toTex()}) = ${nodeImage1.toTex()} = ${nodeImage1
+        .simplify({ towardsDistribute: true })
+        .toTex()}
+$$
+
+$$
+f(${nodeX2.toTex()}) = ${nodeImage2.toTex()} =  ${nodeImage2
+        .simplify({ towardsDistribute: true })
+        .toTex()}
+$$
+
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return varTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getAffineVarTableOnBoundedIntervalQuestion = () => {
+    const [nodeX1, nodeX2] = randomMany([...Array(21).keys()].map((i) => i - 10), 2)
+        .toSorted((v1, v2) => v1 - v2)
+        .map((v) => v.toTree());
+    const nodeF = AffineConstructor.random({ excludes: [0] }, { excludes: [0] }).toTree();
+    const identifiers = {
+        nodeIdsBounds: [nodeX1, nodeX2].map((nodeX) => nodeX.toIdentifiers()),
+        nodeIdsF: nodeF.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: [
+            ["$x$", "", "\\ ", ""],
+            ["$\\ $", "\\ ", "\\ ", "\\ "],
+            ["$f(x)$", "", "", ""],
+            ["$\\ $", "\\ ", "\\ ", "\\ "],
+        ],
+    };
+};
+export const affineVarTableOnBoundedInterval = {
+    id: "affineVarTableOnBoundedInterval",
+    label: "Dresser le tableau de variations d'une fonction affine sur un intervalle borné",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAffineVarTableOnBoundedIntervalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    isAnswerTableValid,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "varTable",
+};

package/lib/exercises/math/functions/affines/affineVariations.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsCoeff: NodeIdentifiers[];
+    formatExpr: string;
+};
+type Options = {
+    formatExpr: string;
+};
+export declare const affineVariations: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=affineVariations.d.ts.map

package/lib/exercises/math/functions/affines/affineVariations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineVariations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkC7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAuIF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAsBF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyB3D,CAAC"}

package/lib/exercises/math/functions/affines/affineVariations.js

@@ -0,0 +1,176 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.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 { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const createNodeF = (formatExpr, nodeA, nodeB) => {
+    const nodeVarX = "x".toTree();
+    switch (formatExpr) {
+        case "$b+ax$": {
+            const b = nodeB.evaluate();
+            if (b === 0) {
+                return multiply(nodeA, nodeVarX).simplify();
+            }
+            else {
+                return add(nodeB, multiply(nodeA, nodeVarX).simplify());
+            }
+        }
+        case "$ax+b$":
+        default:
+            return add(multiply(nodeA, nodeVarX), nodeB).simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+                forceDistributeFractions: true,
+            });
+    }
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Strictement croissante", "raw");
+    tryToAddWrongProp(propositions, "Strictement décroissante", "raw");
+    tryToAddWrongProp(propositions, "Constante", "raw");
+    tryToAddWrongProp(propositions, "Non monotone", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { nodeIdsCoeff } = identifiers;
+    const nodeA = NodeConstructor.fromIdentifiers(nodeIdsCoeff[1]);
+    const a = nodeA.evaluate();
+    if (a === 0) {
+        return "Constante";
+    }
+    else {
+        return a > 0 ? "Strictement croissante" : "Strictement décroissante";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsCoeff, formatExpr } = identifiers;
+    const [nodeB, nodeA] = nodeIdsCoeff.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = createNodeF(formatExpr, nodeA, nodeB);
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par 
+
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+Quel est le sens de variations de $f$ sur $\\mathbb{R}$ ?`;
+};
+const getHint = () => {
+    return `Sur $\\mathbb{R}$, la fonction $f(x) = ax+b = b+ax$ est : 
+
+- strictement croissante si $a>0$;
+- strictement décroissante si $a<0$;
+- constante si $a=0$.
+
+Le coefficient $b$ n'a aucune influence sur les variations de $f$. 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsCoeff } = identifiers;
+    const [_nodeB, nodeA] = nodeIdsCoeff.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Le coefficient directeur de $f$ est $${nodeA.toTex()}$. 
+  
+La fonction $f$ est donc ${getAnswer(identifiers).toLocaleLowerCase()} sur $\\mathbb{R}$.`;
+};
+const getKeys = () => {
+    return [];
+};
+const getAffineVariationsQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const opts = {
+        formatExpr: random(arrayedOptions.formatExpr),
+    };
+    const { formatExpr } = opts;
+    const createRandomNodeCoeff = ({ isAllowZero }) => {
+        function createRandomNodeNonZero() {
+            return probaLawFlip([
+                //>0
+                [randint(1, 100).toTree(), 0.6],
+                [
+                    RationalConstructor.randomIrreductible(20, {
+                        onlySupOne: true,
+                    }).toTree(),
+                    0.16,
+                ],
+                [RationalConstructor.randomIrreductibleProba(50).toTree(), 0.14],
+            ]);
+        }
+        const nodePos = (() => {
+            if (isAllowZero) {
+                return probaLawFlip([
+                    [createRandomNodeNonZero(), 0.9],
+                    [(0).toTree(), 0.1],
+                ]);
+            }
+            else {
+                return createRandomNodeNonZero();
+            }
+        })();
+        const sign = coinFlip() ? +1 : -1;
+        return multiply(sign, nodePos).simplify();
+    };
+    const nodeA = createRandomNodeCoeff({ isAllowZero: true });
+    const nodeB = createRandomNodeCoeff({
+        isAllowZero: nodeA.evaluate() !== 0,
+    });
+    const identifiers = {
+        nodeIdsCoeff: [nodeB, nodeA].map((node) => node.toIdentifiers()),
+        formatExpr,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const optsDefault = {
+    formatExpr: ["$ax+b$"],
+};
+const options = [
+    {
+        id: "formatExpr",
+        label: "Formats pour $f(x)$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["$ax+b$", "$b+ax$"],
+        defaultValue: optsDefault.formatExpr,
+    },
+];
+export const affineVariations = {
+    id: "affineVariations",
+    label: "Déterminer le sens de variations d'une fonction affine à partir de son expression algébrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAffineVariationsQuestion(opts), nb),
+    options,
+    validateOptions: (opts) => {
+        return {
+            valid: !!(opts?.formatExpr && opts?.formatExpr.length > 0),
+            message: "Veuillez choisir au moins un format pour $f(x)$'.",
+        };
+    },
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/functions/affines/affineVariationsFromGraph.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    b: number;
+    secondPoint: number[];
+};
+export declare const affineVariationsFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=affineVariationsFromGraph.d.ts.map

package/lib/exercises/math/functions/affines/affineVariationsFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineVariationsFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineVariationsFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAsNF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}