math-exercises 3.0.190 → 3.0.191

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"}

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

@@ -0,0 +1,203 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blues, greenMain, oranges, purples, reds, } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { random } from "../../../../utils/alea/random.js";
+const getInstruction = () => {
+    return `Ci-dessous est tracée la courbe représentative $C_f$ d'une fonction affine $f$. 
+Déterminer graphiquement le sens de variation de $f$.`;
+};
+const getAnswer = (identifiers) => {
+    const { b, secondPoint } = identifiers;
+    const point1 = new Point("P1", 0, b);
+    const point2 = new Point("P2", secondPoint[0], secondPoint[1]);
+    if (NodeComparator.isEqualViaSub(point1.y, point2.y)) {
+        return "Constante";
+    }
+    else {
+        const [pointXSmall, pointXBig] = [point1, point2].toSorted((point1, point2) => point1.x.evaluate() - point2.x.evaluate());
+        return NodeComparator.compareViaSub(pointXSmall.y, pointXBig.y) === -1
+            ? "Strictement croissante"
+            : "Strictement décroissante";
+    }
+};
+const getHint = () => {
+    return `On prend deux points distincts sur $C_f$. 
+
+On note $x_{1}$ l'abscisse du point avec l'abscisse la plus petite.
+On note $x_{2}$ l'abscisse du point avec l'abscisse la plus grande.
+
+Les coordonnées des deux points sont donc $(x_{1};f(x_{1}))$ et $(x_{2};f(x_{2}))$.
+
+La fonction $f$ est 
+
+- strictement croissante si :
+
+$$
+f(x_{1})<f(x_{2})
+$$
+
+- strictement décroissante si :
+
+$$
+f(x_{1})>f(x_{2})
+$$
+
+- constante si :
+
+$$
+f(x_{1})=f(x_{2})
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { b, secondPoint } = identifiers;
+    const point1 = new Point("P1", 0, b);
+    const point2 = new Point("P2", secondPoint[0], secondPoint[1]);
+    if (NodeComparator.isEqualViaSub(point1.y, point2.y)) {
+        return `On a :
+    
+$$
+f(${point1.x.toTex()}) = f(${point2.x.toTex()}) = ${point1.y.toTex()}
+$$
+
+La fonction $f$ est donc constante sur $\\mathbb{R}$.`;
+    }
+    else {
+        const [pointXSmall, pointXBig] = [point1, point2].toSorted((point1, point2) => point1.x.evaluate() - point2.x.evaluate());
+        const valueComp = NodeComparator.compareViaSub(pointXSmall.y, pointXBig.y);
+        if (valueComp === -1) {
+            return `On a :
+
+$$
+${pointXSmall.x.toTex()} < ${pointXBig.x.toTex()}
+$$
+
+et
+
+$$
+f(${pointXSmall.x.toTex()}) < f(${pointXBig.x.toTex()})
+$$
+  
+
+La fonction $f$ est donc ${getAnswer(identifiers).toLocaleLowerCase()} sur $\\mathbb{R}$.`;
+        }
+        else {
+            return `On a :
+
+$$
+${pointXSmall.x.toTex()} < ${pointXBig.x.toTex()}
+$$
+
+et
+
+$$
+f(${pointXSmall.x.toTex()}) > f(${pointXBig.x.toTex()})
+$$
+  
+
+La fonction $f$ est donc ${getAnswer(identifiers).toLocaleLowerCase()} sur $\\mathbb{R}$.`;
+        }
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { b, secondPoint } = identifiers;
+    const xMin = Math.min(0, secondPoint[0]);
+    const xMax = Math.max(0, secondPoint[0]);
+    const yMin = Math.min(b, secondPoint[1]);
+    const yMax = Math.max(b, secondPoint[1]);
+    const point1 = new Point("P1", 0, b);
+    const point2 = new Point("P2", secondPoint[0], secondPoint[1]);
+    const [pointXSmall, pointXBig] = [point1, point2].toSorted((point1, point2) => point1.x.evaluate() - point2.x.evaluate());
+    const colorButGreen = (() => {
+        const colors = [...reds, ...oranges, ...blues, ...purples];
+        return random(colors);
+    })();
+    const commands = [
+        `l = Line[(0, ${b}), (${secondPoint[0]}, ${secondPoint[1]})]`,
+        `SetColor(l, "${colorButGreen}")`,
+        "SetFixed(l, true, false)",
+        `v = Vector(${pointXSmall.toMathString()}, ${pointXBig.toMathString()})`,
+        `SetLineThickness(v, 10)`,
+        `SetColor(v, "${greenMain}")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { b, secondPoint } = identifiers;
+    const xMin = Math.min(0, secondPoint[0]);
+    const xMax = Math.max(0, secondPoint[0]);
+    const yMin = Math.min(b, secondPoint[1]);
+    const yMax = Math.max(b, secondPoint[1]);
+    const colorButGreen = (() => {
+        const colors = [...reds, ...oranges, ...blues, ...purples];
+        return random(colors);
+    })();
+    const commands = [
+        `l = Line[(0, ${b}), (${secondPoint[0]}, ${secondPoint[1]})]`,
+        `SetColor(l, "${colorButGreen}")`,
+        "SetFixed(l, true, false)",
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+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 getAffineVariationsFromGraphQuestion = () => {
+    const b = randint(-5, 6);
+    const secondPoint = [randint(-5, 6, [0]), randint(-5, 6)];
+    const identifiers = { b, secondPoint };
+    //[0,b] et [x,y]
+    //a = (y-b)/x
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+export const affineVariationsFromGraph = {
+    id: "affineVariationsFromGraph",
+    connector: "=",
+    label: "Lire graphiquement le sens de variation d'une fonction affine",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getAffineVariationsFromGraphQuestion(), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    pointIds: PointIdentifiers[];
+};
+type Options = {
+    typeX: string;
+    typeY: string;
+};
+export declare const affineVariationsFromTwoImages: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=affineVariationsFromTwoImages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"affineVariationsFromTwoImages.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineVariationsFromTwoImages.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AA+CtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AAyMF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA+BF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkCxE,CAAC"}