math-exercises 2.0.43 → 2.1.0

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leadingCoefficient = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../../../geogebra/colors");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const integer_1 = require("../../../../math/numbers/integer/integer");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../../math/utils/random/randint");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getLeadingCoefficientQuestion = () => {
+    let xA, yA, xB, yB;
+    [xA, yA] = [1, 2].map((el) => (0, randint_1.randint)(-5, 6));
+    xB = xA > 0 ? (0, randint_1.randint)(xA - 4, 6, [xA]) : (0, randint_1.randint)(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
+    yB = yA > 0 ? (0, randint_1.randint)(yA - 4, 6) : (0, randint_1.randint)(-4, yA + 5);
+    const a = new rational_1.Rational(yB - yA, xB - xA).simplify();
+    const b = a.opposite().multiply(new integer_1.Integer(xA)).add(new integer_1.Integer(yA));
+    const aTree = a.toTree();
+    const bTree = b.toTree();
+    const aString = aTree.toMathString();
+    const bString = bTree.toMathString();
+    const xMin = Math.min(xA, xB);
+    const xMax = Math.max(xA, xB);
+    const yMin = Math.min(yA, yB);
+    const yMax = Math.max(yA, yB);
+    const commands = [
+        `f(x) = (${aString}) * x + (${bString})`,
+        `SetColor(f, "${(0, colors_1.randomColor)()}")`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+    });
+    const answer = aTree.toTex();
+    const question = {
+        instruction: "Déterminer le coefficient directeur de la droite représentée ci-dessous : ",
+        answer,
+        keys: [],
+        commands: ggb.commands,
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+        options: ggb.getOptions(),
+        answerFormat: "tex",
+        identifiers: { xA, xB, yA, yB },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    if (yB - yA !== 0)
+        (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational(xB - xA, yB - yA).simplify().toTree().toTex());
+    while (propositions.length < n) {
+        const wrongAnswer = new numberNode_1.NumberNode((0, randint_1.randint)(-4, 5, [0]));
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { xA, xB, yA, yB }) => {
+    const leadingCoeff = new rational_1.Rational(yB - yA, xB - xA)
+        .simplify()
+        .toTree({ allowFractionToDecimal: true });
+    const texs = leadingCoeff.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.leadingCoefficient = {
+    id: "leadingCoefficient",
+    connector: "=",
+    label: "Lire le coefficient directeur",
+    levels: ["3ème", "2nde", "1reESM", "2ndPro", "1rePro", "1reTech"],
+    isSingleStep: false,
+    sections: ["Droites", "Fonctions affines"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLeadingCoefficientQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    yA: number;
+    yB: number;
+};
+export declare const leadingCoefficientCalculV1: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=leadingCoefficientCalculV1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"leadingCoefficientCalculV1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoefficientCalculV1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAgDF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leadingCoefficientCalculV1 = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../../math/utils/random/randint");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getLeadingCoefficientCalculV1Question = () => {
+    const [xA, yA] = [1, 2].map((el) => (0, randint_1.randint)(-9, 10));
+    const xB = (0, randint_1.randint)(-9, 10, [xA]);
+    const yB = (0, randint_1.randint)(-9, 10);
+    const answer = new rational_1.Rational(yB - yA, xB - xA).simplify().toTree().toTex();
+    const question = {
+        instruction: `Soit $f$ une fonction affine telle que $f(${xA})$ = $${yA}$ et $f(${xB})$ = $${yB}$.$\\\\$Quel est le coefficient directeur de $f$ ?`,
+        startStatement: "a",
+        answer,
+        answerFormat: "tex",
+        keys: [],
+        identifiers: { xA, xB, yA, yB },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongAnswer = new rational_1.Rational(yB - yA + (0, randint_1.randint)(-3, 4, [0]), xB - xA + (0, randint_1.randint)(-3, 4, [xA - xB]))
+            .simplify()
+            .toTree()
+            .toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { xA, xB, yA, yB }) => {
+    const answer = new rational_1.Rational(yB - yA, xB - xA)
+        .simplify()
+        .toTree({ allowFractionToDecimal: true });
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.leadingCoefficientCalculV1 = {
+    id: "leadingCoefficientCalculV1",
+    connector: "=",
+    label: "Calculer le coefficient directeur d'une fonction affine",
+    levels: ["3ème", "2nde", "2ndPro", "1rePro", "1reTech"],
+    isSingleStep: true,
+    sections: ["Fonctions affines", "Droites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLeadingCoefficientCalculV1Question, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    yA: number;
+    yB: number;
+};
+export declare const leadingCoefficientCalculV2: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=leadingCoefficientCalculV2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"leadingCoefficientCalculV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoefficientCalculV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAgDF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leadingCoefficientCalculV2 = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../../math/utils/random/randint");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getLeadingCoefficientCalculV1Question = () => {
+    const [xA, yA] = [1, 2].map((el) => (0, randint_1.randint)(-9, 10));
+    const xB = (0, randint_1.randint)(-9, 10, [xA]);
+    const yB = (0, randint_1.randint)(-9, 10);
+    const answer = new rational_1.Rational(yB - yA, xB - xA).simplify().toTree().toTex();
+    const question = {
+        instruction: `Soit $d$ une droite passant par les points $A(${xA};${yA})$ et $B(${xB};${yB})$.$\\\\$Déterminer le coefficient directeur de $d$.`,
+        answer: answer,
+        answerFormat: "tex",
+        keys: [],
+        identifiers: { xA, xB, yA, yB },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongAnswer = new rational_1.Rational(yB - yA + (0, randint_1.randint)(-3, 4, [0]), xB - xA + (0, randint_1.randint)(-3, 4, [xA - xB]))
+            .simplify()
+            .toTree()
+            .toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { xA, xB, yA, yB }) => {
+    const answer = new rational_1.Rational(yB - yA, xB - xA)
+        .simplify()
+        .toTree({ allowFractionToDecimal: true });
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.leadingCoefficientCalculV2 = {
+    id: "leadingCoefficientCalculV2",
+    connector: "=",
+    label: "Coefficient directeur à l'aide de deux points",
+    levels: ["3ème", "2nde", "2ndPro", "1rePro", "1reTech"],
+    isSingleStep: false,
+    sections: ["Droites", "Fonctions affines"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLeadingCoefficientCalculV1Question, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+    askingPositive: boolean;
+};
+export declare const signFunction: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=signFunction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/signFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAyFF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signFunction = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const polynomial_1 = require("../../../../math/polynomials/polynomial");
+const randint_1 = require("../../../../math/utils/random/randint");
+const infiniteNode_1 = require("../../../../tree/nodes/numbers/infiniteNode");
+const closure_1 = require("../../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getSignFunction = () => {
+    const a = (0, randint_1.randint)(-9, 10, [0]);
+    const b = (0, randint_1.randint)(-9, 10);
+    const affine = new polynomial_1.Polynomial([b, a]);
+    let instruction = `Soit $f$ la fonction définie par : $f(x) = ${affine.toTex()}$. Sur quel intervalle $f$ est-elle `;
+    let answer = "";
+    const askingPositive = (0, coinFlip_1.coinFlip)();
+    const root = new rational_1.Rational(-b, a).simplify().toTree();
+    const toRightInfInterval = new intervalNode_1.IntervalNode(root, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.FO).toTex();
+    const toLeftInfInteral = new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, root, closure_1.ClosureType.OF).toTex();
+    if (askingPositive) {
+        instruction += "positive ?";
+        answer = a > 0 ? toRightInfInterval : toLeftInfInteral;
+    }
+    else {
+        instruction += "négative ?";
+        answer = a > 0 ? toLeftInfInteral : toRightInfInterval;
+    }
+    const question = {
+        instruction,
+        startStatement: "S",
+        answer,
+        keys: ["S", "equal", "lbracket", "rbracket", "semicolon", "infty"],
+        answerFormat: "tex",
+        identifiers: { a, askingPositive, b },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const a = (0, randint_1.randint)(-9, 10, [0]);
+        const b = (0, randint_1.randint)(-9, 10);
+        const root = new rational_1.Rational(-b, a).simplify().toTree();
+        const leftInf = new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, root, closure_1.ClosureType.OF).toTex();
+        const rightInf = new intervalNode_1.IntervalNode(root, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.FO).toTex();
+        const wrongAnswer = (0, coinFlip_1.coinFlip)() ? rightInf : leftInf;
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, askingPositive }) => {
+    const root = new rational_1.Rational(-b, a)
+        .simplify()
+        .toTree({ allowFractionToDecimal: true });
+    const toRightInfInterval = new intervalNode_1.IntervalNode(root, infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.FO);
+    const toLeftInfInteral = new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, root, closure_1.ClosureType.OF);
+    let answer;
+    if (askingPositive) {
+        answer = a > 0 ? toRightInfInterval : toLeftInfInteral;
+    }
+    else {
+        answer = a > 0 ? toLeftInfInteral : toRightInfInterval;
+    }
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.signFunction = {
+    id: "signFunction",
+    connector: "=",
+    label: "Signe d'une fonction affine",
+    levels: ["3ème", "2nde", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Fonctions affines"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSignFunction, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/functions/basics/graphicEquation.d.ts

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

package/lib/exercises/math/functions/basics/graphicEquation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphicEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/graphicEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;CAClC,CAAC;AAkGF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}

package/lib/exercises/math/functions/basics/graphicEquation.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphicEquation = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const discreteSetKeys_1 = require("../../../../exercises/utils/keys/discreteSetKeys");
+const colors_1 = require("../../../../geogebra/colors");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const randint_1 = require("../../../../math/utils/random/randint");
+const equationSolutionNode_1 = require("../../../../tree/nodes/equations/equationSolutionNode");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const discreteSetNode_1 = require("../../../../tree/nodes/sets/discreteSetNode");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const getGraphicEquationQuestion = () => {
+    let xSolutions = [];
+    const nb = (0, randint_1.randint)(2, 4);
+    // const nb = 2;
+    for (let i = 0; i < nb; i++) {
+        xSolutions.push((0, randint_1.randint)(-9, 10, xSolutions));
+    }
+    xSolutions.sort((a, b) => a - b);
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(xSolutions.map((sol) => new numberNode_1.NumberNode(sol)))).toTex();
+    const yValue = (0, randint_1.randint)(-5, 6);
+    const splinePoints = [];
+    let prevYWasAbove = (0, coinFlip_1.coinFlip)();
+    if ((0, coinFlip_1.coinFlip)()) {
+        const y = prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3);
+        prevYWasAbove = y > 0;
+        splinePoints.push([xSolutions[0] - (1 + Math.random() * 3), yValue + y]);
+    }
+    for (let i = 0; i < xSolutions.length; i++) {
+        splinePoints.push([xSolutions[i], yValue]);
+        if (i < xSolutions.length - 1) {
+            const mid = (xSolutions[i] + xSolutions[i + 1]) / 2;
+            const distance = xSolutions[i + 1] - xSolutions[i];
+            const x = mid + ((Math.random() * 2) / 5) * (distance / 2);
+            const y = prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3);
+            prevYWasAbove = y > 0;
+            splinePoints.push([x, yValue + y]);
+        }
+    }
+    if ((0, coinFlip_1.coinFlip)() || splinePoints.length < 4) {
+        const y = prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3);
+        prevYWasAbove = y > 0;
+        splinePoints.push([
+            xSolutions[xSolutions.length - 1] + (1 + Math.random() * 3),
+            yValue + y,
+        ]);
+    }
+    const xMin = Math.min(...splinePoints.map((point) => point[0]));
+    const yMin = Math.min(...splinePoints.map((point) => point[1]));
+    const xMax = Math.max(...splinePoints.map((point) => point[0]));
+    const yMax = Math.max(...splinePoints.map((point) => point[1]));
+    const commands = [
+        `S = Spline(${splinePoints
+            .map((point) => `(${point[0]},${point[1]})`)
+            .join(",")})`,
+        "SetFixed(S, true)",
+        `SetColor(S, "${(0, colors_1.randomColor)()}")`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+    });
+    const question = {
+        answer,
+        instruction: `Déterminer graphiquement les solutions de l'équation $f(x) = ${yValue}$ où $f$ est la fonction représentée ci-dessous.`,
+        keys: discreteSetKeys_1.discreteSetKeys,
+        answerFormat: "tex",
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+        identifiers: { yValue, splinePoints },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\varnothing`);
+    while (propositions.length < n) {
+        const nbs = [];
+        const nbSol = (0, randint_1.randint)(2, 4);
+        for (let i = 0; i < nbSol; i++) {
+            nbs.push((0, randint_1.randint)(-9, 10, nbs));
+        }
+        nbs.sort((a, b) => a - b);
+        const sol = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(nbs.map((nb) => new numberNode_1.NumberNode(nb))));
+        (0, exercise_1.tryToAddWrongProp)(propositions, sol.toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { yValue, splinePoints }) => {
+    const xSolutions = splinePoints
+        .filter((p) => p[1] === yValue)
+        .map((p) => p[0]);
+    const answerTree = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(xSolutions.map((sol) => new numberNode_1.NumberNode(sol))));
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.graphicEquation = {
+    id: "graphicEquation",
+    connector: "\\iff",
+    label: "Résoudre graphiquement une équation",
+    levels: ["2ndPro", "2nde", "1rePro", "1reESM", "1reTech"],
+    isSingleStep: true,
+    sections: ["Équations", "Fonctions"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGraphicEquationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/functions/basics/graphicInequation.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { ClosureType } from "../../../../tree/nodes/sets/closure";
+type Identifiers = {
+    yValue: number;
+    splinePoints: [number, number][];
+    isStrict: boolean;
+    isAskingSup: boolean;
+    intervals: {
+        a: number;
+        b: number;
+        closure: ClosureType;
+    }[];
+};
+export declare const graphicInequation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=graphicInequation.d.ts.map

package/lib/exercises/math/functions/basics/graphicInequation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphicInequation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/graphicInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAM5D,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IACjC,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,WAAW,CAAA;KAAE,EAAE,CAAC;CAC7D,CAAC;AAiKF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}

package/lib/exercises/math/functions/basics/graphicInequation.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphicInequation = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../../../geogebra/colors");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const randint_1 = require("../../../../math/utils/random/randint");
+const inequationSolutionNode_1 = require("../../../../tree/nodes/inequations/inequationSolutionNode");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const closure_1 = require("../../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
+const unionIntervalNode_1 = require("../../../../tree/nodes/sets/unionIntervalNode");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const getGraphicInequationQuestion = () => {
+    let xSolutions = [];
+    const nb = (0, randint_1.randint)(2, 4);
+    for (let i = 0; i < nb; i++) {
+        xSolutions.push((0, randint_1.randint)(-9, 10, xSolutions));
+    }
+    xSolutions.sort((a, b) => a - b);
+    const isAskingSup = (0, coinFlip_1.coinFlip)();
+    const isStrict = (0, coinFlip_1.coinFlip)();
+    const intervals = [];
+    const yValue = (0, randint_1.randint)(-5, 6);
+    const splinePoints = [];
+    let prevYWasAbove = (0, coinFlip_1.coinFlip)();
+    if (!isStrict || (0, coinFlip_1.coinFlip)()) {
+        //le !isStrict sert à empcher les points uniques solution
+        const x = xSolutions[0] - (0, randint_1.randint)(1, 3);
+        const y = prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3);
+        if ((y > 0 && isAskingSup) || (y < 0 && !isAskingSup)) {
+            intervals.push({
+                a: x,
+                b: xSolutions[0],
+                closure: isStrict ? closure_1.ClosureType.FO : closure_1.ClosureType.FF,
+            });
+        }
+        prevYWasAbove = y > 0;
+        splinePoints.push([x, yValue + y]);
+    }
+    for (let i = 0; i < xSolutions.length; i++) {
+        splinePoints.push([xSolutions[i], yValue]);
+        if (i < xSolutions.length - 1) {
+            const mid = (xSolutions[i] + xSolutions[i + 1]) / 2;
+            const distance = xSolutions[i + 1] - xSolutions[i];
+            const x = mid + ((Math.random() * 2) / 5) * (distance / 2);
+            const y = prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3);
+            if ((y > 0 && isAskingSup) || (y < 0 && !isAskingSup)) {
+                intervals.push({
+                    a: xSolutions[i],
+                    b: xSolutions[i + 1],
+                    closure: isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.FF,
+                });
+            }
+            prevYWasAbove = y > 0;
+            splinePoints.push([x, yValue + y]);
+        }
+    }
+    if (!isStrict || (0, coinFlip_1.coinFlip)() || splinePoints.length < 4) {
+        const x = xSolutions[xSolutions.length - 1] + (0, randint_1.randint)(1, 3);
+        const y = prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3);
+        if ((y > 0 && isAskingSup) || (y < 0 && !isAskingSup)) {
+            intervals.push({
+                a: xSolutions[xSolutions.length - 1],
+                b: x,
+                closure: isStrict ? closure_1.ClosureType.OF : closure_1.ClosureType.FF,
+            });
+        }
+        prevYWasAbove = y > 0;
+        splinePoints.push([x, yValue + y]);
+    }
+    const xMin = Math.min(...splinePoints.map((point) => point[0]));
+    const yMin = Math.min(...splinePoints.map((point) => point[1]));
+    const xMax = Math.max(...splinePoints.map((point) => point[0]));
+    const yMax = Math.max(...splinePoints.map((point) => point[1]));
+    const intervalsNodes = intervals.map((i) => new intervalNode_1.IntervalNode(new numberNode_1.NumberNode(i.a), new numberNode_1.NumberNode(i.b), i.closure));
+    const answer = intervalsNodes.length === 1
+        ? `S=\\ ${intervalsNodes[0].toTex()}`
+        : `S=\\ ${new unionIntervalNode_1.UnionIntervalNode(intervalsNodes).toTex()}`;
+    const commands = [
+        `S =Spline(${splinePoints
+            .map((point) => `(${point[0]},${point[1]})`)
+            .join(",")})`,
+        "SetFixed(S, true)",
+        `SetColor(S, "${(0, colors_1.randomColor)()}")`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+    });
+    const question = {
+        answer,
+        instruction: `Déterminer graphiquement les solutions de l'inéquation $f(x)${isAskingSup ? (isStrict ? ">" : "\\geq") : isStrict ? "<" : "\\leq"}${yValue}$ où $f$ est la fonction représentée ci-dessous.`,
+        keys: [
+            "S",
+            "equal",
+            "lbracket",
+            "semicolon",
+            "rbracket",
+            "cup",
+            "lbrace",
+            "rbrace",
+            "varnothing",
+        ],
+        answerFormat: "tex",
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+        identifiers: {
+            yValue,
+            splinePoints,
+            isAskingSup,
+            isStrict,
+            intervals,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, intervals, splinePoints, yValue }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\varnothing`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${new intervalNode_1.IntervalNode(new numberNode_1.NumberNode(splinePoints[0][0]), new numberNode_1.NumberNode(yValue), closure_1.ClosureType.FF).toTex()}`);
+    while (propositions.length < n) {
+        const a = (0, randint_1.randint)(-9, 3);
+        const b = (0, randint_1.randint)(3, 10, [a]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\ ${new intervalNode_1.IntervalNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b), closure_1.ClosureType.FF).toTex()}`);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { intervals }) => {
+    const intervalsNodes = intervals.map((n) => new intervalNode_1.IntervalNode(new numberNode_1.NumberNode(n.a), new numberNode_1.NumberNode(n.b), n.closure));
+    const intervalsTree = intervalsNodes.length === 1
+        ? intervalsNodes[0]
+        : new unionIntervalNode_1.UnionIntervalNode(intervalsNodes);
+    const answerTree = new inequationSolutionNode_1.InequationSolutionNode(intervalsTree);
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.graphicInequation = {
+    id: "graphicInequation",
+    connector: "\\iff",
+    label: "Résoudre graphiquement une inéquation",
+    levels: ["2ndPro", "2nde", "1rePro", "1reESM", "1reTech"],
+    isSingleStep: true,
+    sections: ["Inéquations", "Fonctions"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGraphicInequationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/functions/basics/imageFunction.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    rand: boolean;
+    poly1: number[];
+    poly2: number[];
+    xValue: number;
+};
+export declare const imageFunction: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=imageFunction.d.ts.map

package/lib/exercises/math/functions/basics/imageFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmDF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAa/C,CAAC"}