math-exercises 3.0.89 → 3.0.90

package/lib/exercises/math/functions/sign/affineSignTable.js

@@ -0,0 +1,111 @@
+import { addValidProp, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { firstDegreeInequationResolutionTex } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        throw Error("QCM not implemented");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswerTable = (identifiers) => {
+    const affine = AffineConstructor.fromCoeffs(identifiers.affineCoeffs);
+    const root = affine.getRoot().toTree();
+    const signs = affine.a > 0 ? ["-", "+"] : ["+", "-"];
+    return [
+        ["$x$", "-\\infty", "\\ ", root.toTex(), "\\ ", "+\\infty"],
+        ["$f(x)$", "\\ ", signs[0], "0", signs[1], "\\ "],
+    ];
+};
+const getInstruction = (identifiers) => {
+    const affine = AffineConstructor.fromCoeffs(identifiers.affineCoeffs);
+    const arr = [["a", "b", "c"], "d", "ef", "f"];
+    return `Dresser le tableau de signes de la fonction $f$ définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${affine.toTree().toTex()}
+$$
+
+
+<svg id="signTable">${JSON.stringify(arr)}</svg>`;
+};
+const getHint = (identifiers) => {
+    return `Résout l'inéquation $f(x)>0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { affineCoeffs, initTable } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(affineCoeffs);
+    const root = affine.getRoot().toTree();
+    const signs = affine.a > 0 ? ["-", "+"] : ["+", "-"];
+    return `On résout l'inéquation $f(x)>0$ : 
+  
+$$
+${firstDegreeInequationResolutionTex(affine, ">", new NumberNode(0))}
+$$
+
+On en déduit que $f(x)$ est ${affine.a > 0 ? "négative" : "positive"} sur $]-\\infty; ${root.toTex()}]$ et ${affine.a > 0 ? "positive" : "négative"} sur $[${root.toTex()}; +\\infty[$.
+`;
+};
+const getKeys = (identifiers) => {
+    return ["infty"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return ans.every((row, i) => row.every((cell, j) => i === 0 && j === 3
+            ? parseAlgebraic(cell)
+                .simplify({ decimalToFractions: true })
+                .simplify()
+                .toTex() === answerTable[i][j]
+            : cell === answerTable[i][j]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTestSignTableQuestion = (ops) => {
+    const aff = AffineConstructor.random();
+    const initTable = [
+        ["$x$", "", "\\ ", "", "\\ ", ""],
+        ["$f(x)$", "\\ ", "", "", "", "\\ "],
+    ];
+    const identifiers = {
+        affineCoeffs: aff.coefficients,
+        initTable,
+    };
+    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: identifiers.initTable,
+    };
+};
+export const affineSignTable = {
+    id: "affineSignTable",
+    label: "Dresser le tableau de signes d'une fonction affine",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTestSignTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "signTable",
+};

package/lib/exercises/math/functions/sign/index.d.ts

@@ -1,2 +1,6 @@
 export * from "./affineProductSign.js";
+export * from "./affineSignTable.js";
+export * from "./affineProductSignTable.js";
+export * from "./readSignTable.js";
+export * from "./signTableFromGraph.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/sign/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC"}

package/lib/exercises/math/functions/sign/index.js

@@ -1 +1,5 @@
 export * from "./affineProductSign.js";
+export * from "./affineSignTable.js";
+export * from "./affineProductSignTable.js";
+export * from "./readSignTable.js";
+export * from "./signTableFromGraph.js";

package/lib/exercises/math/functions/sign/readSignTable.d.ts

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

package/lib/exercises/math/functions/sign/readSignTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readSignTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/readSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,EAAE,EAAE,eAAe,EAAE,CAAC;IACtB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AA4GF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}

package/lib/exercises/math/functions/sign/readSignTable.js

@@ -0,0 +1,124 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Positif", "raw");
+    tryToAddWrongProp(propositions, "Négatif", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { xs, signs, x } = identifiers;
+    const xEv = reifyAlgebraic(x).evaluate();
+    const evals = xs.map((e) => reifyAlgebraic(e).evaluate());
+    for (let i = 0; i < evals.length - 1; i++) {
+        const a = evals[i];
+        const b = evals[i + 1];
+        if (a < xEv && b > xEv) {
+            const ans = signs[2 * i];
+            if (ans === "+")
+                return "Positif";
+            if (ans === "-")
+                return "Négatif";
+        }
+    }
+    return "";
+};
+const getInstruction = (identifiers) => {
+    const { xs, signs, x } = identifiers;
+    const firstRow = [];
+    for (let i = 0; i < xs.length; i++) {
+        firstRow.push(`${reifyAlgebraic(xs[i]).toTex()}`);
+        i < xs.length - 1 && firstRow.push(`\\ `);
+    }
+    const secondRow = ["\\ ", ...signs, "\\ "];
+    const table = [
+        [`x`, ...firstRow],
+        [`f(x)`, ...secondRow],
+    ];
+    return `On considère le tableau de signes suivant d'une fonction $f$ : 
+  
+<svg id="signTable">${JSON.stringify(table)}</svg>
+
+Quel est le signe de $f(${reifyAlgebraic(x).toTex()})$ ?`;
+};
+const getHint = (identifiers) => {
+    const { xs, signs, x } = identifiers;
+    const xEv = reifyAlgebraic(x);
+    return `Repère où se situe $${xEv.toTex()}$ dans la première ligne. 
+  
+Puis, utilise la deuxième ligne pour déterminer le signe de $f(${xEv.toTex()})$.`;
+};
+const getCorrection = (identifiers) => {
+    const { xs, signs, x } = identifiers;
+    const xNode = reifyAlgebraic(x);
+    const xEv = xNode.evaluate();
+    const evals = xs.map((e) => reifyAlgebraic(e).evaluate());
+    let aNode;
+    let bNode;
+    let ans;
+    for (let i = 0; i < evals.length - 1; i++) {
+        const a = evals[i];
+        const b = evals[i + 1];
+        if (a < xEv && b > xEv) {
+            aNode = reifyAlgebraic(xs[i]);
+            bNode = reifyAlgebraic(xs[i + 1]);
+            const sign = signs[2 * i];
+            if (sign === "+")
+                ans = "positif";
+            if (sign === "-")
+                ans = "négatif";
+            break;
+        }
+    }
+    return `On remarque que $${xNode.toTex()}$ est compris entre $${aNode.toTex()}$ et $${bNode.toTex()}$. 
+  
+D'après le tableau de signes, $f(${xNode.toTex()})$ est donc ${ans}.`;
+};
+const getReadSignTableQuestion = (ops) => {
+    const a = randint(-10, 0);
+    const b = randint(0, 10);
+    const xs = [MinusInfinityNode, a.toTree(), b.toTree(), PlusInfinityNode];
+    const signs = coinFlip()
+        ? ["+", "0", "-", "0", "+"]
+        : ["-", "0", "+", "0", "-"];
+    const x = randint(-20, 20, [a, b]).toTree();
+    const identifiers = {
+        x: x.toIdentifiers(),
+        xs: xs.map((e) => e.toIdentifiers()),
+        signs,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const readSignTable = {
+    id: "readSignTable",
+    label: "Lire le tableau de signes d'une fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getReadSignTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/sign/signTableFromGraph.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    initTable: string[][];
+    a: number;
+    x1: number;
+    x2: number;
+    x3: number;
+};
+export declare const signTableFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=signTableFromGraph.d.ts.map

package/lib/exercises/math/functions/sign/signTableFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signTableFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/signTableFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA0IF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAoBpD,CAAC"}

package/lib/exercises/math/functions/sign/signTableFromGraph.js

@@ -0,0 +1,141 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    return `On donne la représentation graphique d'une fonction $f$ définie sur $\\mathbb{R}$. 
+    
+  Dresser le tableau de signes de $f$.`;
+};
+const getHint = (identifiers) => {
+    return `La fonction est définie sur $\\mathbb{R}$, donc les valeurs de $x$ vont de $-\\infty$ à $+\\infty$.
+  
+Repère ensuite les points de la courbe à l'intersection de l'axe des abscisses. Dans la première ligne du tableau, il faut mettre les abscisses de ces points, et dans la deuxième ligne, le signe de $f(x)$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, x1, x2, x3 } = identifiers;
+    const signs = a > 0
+        ? ["négatif", "positif", "négatif", "positif"]
+        : ["positif", "négatif", "positif", "négatif"];
+    return `On lit graphiquement que $f(x)$ s'annule pour les valeurs de $x$ suivantes : $${x1}$, $${x2}$ et $${x3}$. 
+  
+De plus, $f(x)$ est ${signs[0]} pour $x \\in ]-\\infty;${x1}]$, puis ${signs[1]} pour $x \\in [${x1}, ${x2}]$, puis ${signs[2]} pour $x \\in [${x2}, ${x3}]$, et enfin ${signs[3]} pour $x \\in [${x3}, +\\infty[$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, x1, x2, x3 } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [`f(x) = ${a}*(x-${x1})*(x-${x2})*(x-${x3})`],
+        lockedAxesRatio: false,
+        gridDistance: false,
+        xAxis: {
+            steps: 1,
+        },
+    });
+    const func = (x) => a * (x - x1) * (x - x2) * (x - x3);
+    const xMin = Math.min(x1, x2, x3);
+    const xMax = Math.max(x1, x2, x3);
+    const root1 = (2 * (x1 + x2 + x3) -
+        Math.sqrt(4 * (x1 + x2 + x3) ** 2 - 12 * (x1 * x2 + x1 * x3 + x2 * x3))) /
+        6;
+    const root2 = (2 * (x1 + x2 + x3) +
+        Math.sqrt(4 * (x1 + x2 + x3) ** 2 - 12 * (x1 * x2 + x1 * x3 + x2 * x3))) /
+        6;
+    const [fx1, fx2] = [func(root1), func(root2)];
+    const yMin = Math.min(fx1, fx2);
+    const yMax = Math.max(fx1, fx2);
+    return ggb.getOptions({
+        coords: [xMin - 2, xMax + 2, yMin - 2, yMax + 2],
+    });
+};
+const getKeys = (identifiers) => {
+    return ["infty"];
+};
+const getAnswerTable = (identifiers) => {
+    const { a, x1, x2, x3 } = identifiers;
+    const signs = a > 0 ? ["-", "+", "-", "+"] : ["+", "-", "+", "-"];
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            x1.frenchify(),
+            "\\ ",
+            x2.frenchify(),
+            "\\ ",
+            x3.frenchify(),
+            "\\ ",
+            "+\\infty",
+        ],
+        [
+            "$f(x)$",
+            "\\ ",
+            signs[0],
+            "0",
+            signs[1],
+            "0",
+            signs[2],
+            "0",
+            signs[3],
+            "\\ ",
+        ],
+    ];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return ans.every((row, i) => row.every((cell, j) => cell === answerTable[i][j]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSignTableFromGraphQuestion = (opts) => {
+    let x1 = randint(-9, 10);
+    let x2 = randint(-9, 10, [x1]);
+    let x3 = randint(-9, 10, [x1, x2]);
+    const sorted = [x1, x2, x3].sort((a, b) => a - b);
+    const a = randfloat(-1, 1, 4, [0]);
+    const identifiers = {
+        a,
+        x1: sorted[0],
+        x2: sorted[1],
+        x3: sorted[2],
+        initTable: [
+            ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+            ["$f(x)$", "\\ ", "", "", "", "", "", "", "", "\\ "],
+        ],
+    };
+    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),
+        ggbOptions: getGGBOptions(identifiers),
+        initTable: identifiers.initTable,
+    };
+};
+export const signTableFromGraph = {
+    id: "signTableFromGraph",
+    label: "Dresser le tableau de signes d'une fonction à partir de sa représentation graphique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSignTableFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswerTable,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    answerType: "signTable",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/variations/compareImagesInVarTable.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    xs: number[];
+    ys: number[];
+    vars: string[];
+    a: number;
+    b: number;
+};
+export declare const compareImagesInVarTable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareImagesInVarTable.d.ts.map

package/lib/exercises/math/functions/variations/compareImagesInVarTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareImagesInVarTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/compareImagesInVarTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgJF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAiBzD,CAAC"}

package/lib/exercises/math/functions/variations/compareImagesInVarTable.js

@@ -0,0 +1,153 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "\\le");
+    tryToAddWrongProp(propositions, "\\ge");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, vars, xs, ys } = identifiers;
+    const index = a < xs[0] ? 0 : a > xs[1] ? 2 : 1;
+    if (vars[index] === "\\nearrow") {
+        return "\\le";
+    }
+    else {
+        return "\\ge";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { a, b, vars, xs, ys } = identifiers;
+    const firstIncr = vars[0] === "\\nearrow";
+    const table = [
+        ["x", "-\\infty", "\\ ", xs[0], "\\ ", xs[1], "\\ ", "+\\infty"],
+        [
+            "",
+            "\\ ",
+            "\\ ",
+            firstIncr ? ys[0] : "\\ ",
+            "\\ ",
+            firstIncr ? "\\ " : ys[1],
+            "\\ ",
+            "\\ ",
+        ],
+        ["f(x)", "\\ ", vars[0], "\\ ", vars[1], "\\ ", vars[2], "\\ "],
+        [
+            "",
+            "\\ ",
+            "\\ ",
+            firstIncr ? "\\ " : ys[0],
+            "\\ ",
+            firstIncr ? ys[1] : "\\ ",
+            "\\ ",
+            "\\ ",
+        ],
+    ];
+    return `On donne le tableau de variations d'une fonction $f$ définie sur $\\mathbb{R}$ :
+  
+  
+<svg id='varTable'>${JSON.stringify(table)}</svg>
+
+Compléter par le bon symbole : 
+
+$$
+f(${a}) \\ \\ldots \\ f(${b}) 
+$$`;
+};
+const getHint = (identifiers) => {
+    const { a, b, vars, xs, ys } = identifiers;
+    return `Si $a$ et $b$ sont deux nombres d'un intervalle $I$ sur lequel une fonction $f$ est croissante, alors $f(a)\\leq f(b)$.
+  
+Si sur cet intervalle, $f$ est décroissante, alors $f(a)\\geq f(b)$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, vars, xs, ys } = identifiers;
+    const index = a < xs[0] ? 0 : a > xs[1] ? 2 : 1;
+    const intervals = [
+        new IntervalNode(MinusInfinityNode, xs[0].toTree(), ClosureType.OF),
+        new IntervalNode(xs[0].toTree(), xs[1].toTree(), ClosureType.FF),
+        new IntervalNode(xs[1].toTree(), PlusInfinityNode, ClosureType.FO),
+    ];
+    return `Les nombres $${a}$ et $${b}$ appartiennent à l'intervalle $${intervals[index].toTex()}$.
+  
+Or, sur cet intervalle, la fonction $f$ est ${vars[index] === "\\nearrow" ? "croissante" : "décroissante"} d'après le tableau de variations. 
+
+On en déduit que :
+
+$$
+f(${a}) \\ ${vars[index] === "\\nearrow" ? "\\le" : "\\ge"} f(${b})
+$$
+`;
+};
+const getCompareImagesInVarTableQuestion = (ops) => {
+    const x1 = randint(-10, 0);
+    const x2 = randint(x1 + 6, 16);
+    const y1 = randint(-10, 10);
+    const y2 = randint(-10, 10, [y1]);
+    const flip = randint(0, 3);
+    let a;
+    let b;
+    if (flip === 0) {
+        //left side
+        a = randint(-20, x1 + 1);
+        b = randint(-20, x1 + 1, [a]);
+        if (a > b)
+            [a, b] = [b, a];
+    }
+    else if (flip === 1) {
+        //middle side
+        a = randint(x1, x2);
+        b = randint(x1, x2, [a]);
+        if (a > b)
+            [a, b] = [b, a];
+    }
+    else {
+        //right side
+        a = randint(x2, 20);
+        b = randint(x2, 20, [a]);
+        if (a > b)
+            [a, b] = [b, a];
+    }
+    const identifiers = {
+        a,
+        b,
+        vars: y2 < y1
+            ? ["\\nearrow", "\\searrow", "\\nearrow"]
+            : ["\\searrow", "\\nearrow", "\\searrow"],
+        xs: [x1, x2],
+        ys: [y1, y2],
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const compareImagesInVarTable = {
+    id: "compareImagesInVarTable",
+    label: "Comparer deux images dans le tableau de variations d'une fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareImagesInVarTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/variations/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./varTableExtremaReading.js";
+export * from "./varTableFromGraph.js";
+export * from "./compareImagesInVarTable.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/variations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC"}

package/lib/exercises/math/functions/variations/index.js

@@ -1 +1,3 @@
 export * from "./varTableExtremaReading.js";
+export * from "./varTableFromGraph.js";
+export * from "./compareImagesInVarTable.js";

package/lib/exercises/math/functions/variations/varTableFromGraph.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    type: number;
+    coeffs: number[];
+    initTable: string[][];
+};
+export declare const varTableFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=varTableFromGraph.d.ts.map

package/lib/exercises/math/functions/variations/varTableFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varTableFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/varTableFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AAgLF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAmBnD,CAAC"}