math-exercises 2.0.43 → 2.1.0

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imageFunction = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../../../math/polynomials/polynomial");
+const randint_1 = require("../../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getImageFunction = () => {
+    const rand = (0, coinFlip_1.coinFlip)();
+    const polynome1 = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
+    const polynome2 = new polynomial_1.Polynomial([
+        (0, randint_1.randint)(-9, 10),
+        (0, randint_1.randint)(-9, 10),
+        (0, randint_1.randint)(-4, 5, [0]),
+    ]);
+    const xValue = (0, randint_1.randint)(-9, 10);
+    const statement = rand
+        ? `Soit $f(x) = ${polynome1.toTree().toTex()}$. Calculer $f(${xValue})$.`
+        : `Soit $f(x) = ${polynome2.toTree().toTex()}$. Calculer $f(${xValue})$.`;
+    const answer = rand
+        ? polynome1.calculate(xValue) + ""
+        : polynome2.calculate(xValue) + "";
+    const question = {
+        instruction: statement,
+        startStatement: `f(${xValue})`,
+        answer: answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            poly1: polynome1.coefficients,
+            poly2: polynome2.coefficients,
+            rand,
+            xValue,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongAnswer = Number(answer) + (0, randint_1.randint)(-10, 11, [0]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return answer === ans;
+};
+exports.imageFunction = {
+    id: "imageFunction",
+    connector: "=",
+    label: "Calcul d'image par une fonction",
+    levels: ["3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Fonctions"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getImageFunction, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"imageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,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;AA2EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imageFunctionGeogebra = 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 polynomial_1 = require("../../../../math/polynomials/polynomial");
+const randint_1 = require("../../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getImageFunctionGeogebra = () => {
+    const rand = (0, coinFlip_1.coinFlip)();
+    const xValue = (0, randint_1.randint)(-5, 6);
+    let polynome1;
+    do {
+        polynome1 = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
+    } while (polynome1.calculate(xValue) > 10 ||
+        polynome1.calculate(xValue) < -10);
+    let polynome2;
+    do {
+        polynome2 = new polynomial_1.Polynomial([
+            (0, randint_1.randint)(-9, 10),
+            (0, randint_1.randint)(-9, 10),
+            (0, randint_1.randint)(-4, 5, [0]),
+        ]);
+    } while (polynome2.calculate(xValue) > 10 ||
+        polynome2.calculate(xValue) < -10);
+    const statement = `Quelle est l'image de $${xValue}$ par la fonction $f$ représentée ci dessous ?`;
+    const answer = rand
+        ? polynome1.calculate(xValue)
+        : polynome2.calculate(xValue);
+    const xMin = xValue;
+    const xMax = xValue;
+    const yMin = answer;
+    const yMax = answer;
+    const commands = [
+        `f(x) = ${rand ? polynome1.toString() : polynome2.toString()}`,
+        `SetColor(f, "${(0, colors_1.randomColor)()}")`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, { isGridSimple: true });
+    const answerTex = answer + "";
+    const question = {
+        instruction: statement,
+        startStatement: `f(${xValue})`,
+        answer: answerTex,
+        keys: [],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: [-10, 10, -10, 10],
+        answerFormat: "tex",
+        identifiers: {
+            poly1: polynome1.coefficients,
+            poly2: polynome2.coefficients,
+            rand,
+            xValue,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongAnswer = Number(answer) + (0, randint_1.randint)(-10, 11, [0]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.imageFunctionGeogebra = {
+    id: "imageFunctionGeogebra",
+    connector: "=",
+    label: "Lecture d'une image",
+    levels: ["3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Fonctions"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getImageFunctionGeogebra, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,9 @@
+export * from "./imageFunction";
+export * from "./imageFunctionGeogebra";
+export * from "./inverseImageFunction";
+export * from "./inverseImageFunctionGeogebra";
+export * from "./graphicEquation";
+export * from "./graphicInequation";
+export * from "./twoFunctionsEquation";
+export * from "./twoFunctionsInequation";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC"}

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

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./imageFunction"), exports);
+__exportStar(require("./imageFunctionGeogebra"), exports);
+__exportStar(require("./inverseImageFunction"), exports);
+__exportStar(require("./inverseImageFunctionGeogebra"), exports);
+__exportStar(require("./graphicEquation"), exports);
+__exportStar(require("./graphicInequation"), exports);
+__exportStar(require("./twoFunctionsEquation"), exports);
+__exportStar(require("./twoFunctionsInequation"), exports);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"inverseImageFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAoCF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inverseImageFunction = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../../../math/polynomials/polynomial");
+const randint_1 = require("../../../../math/utils/random/randint");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getInverseImageFunction = () => {
+    const polynome1 = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
+    const xValue = (0, randint_1.randint)(-9, 10);
+    let image = polynome1.calculate(xValue) + "";
+    const statement = `Soit $f(x) = ${polynome1
+        .toTree()
+        .toTex()}$. Déterminer le ou les antécédents de $${image}$ par $f$.`;
+    const answer = "x=" + xValue;
+    const question = {
+        instruction: statement,
+        startStatement: `f(x) = ${image}`,
+        answer,
+        keys: ["x", "equal"],
+        answerFormat: "tex",
+        identifiers: { poly1: polynome1.coefficients, xValue },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const xValue = Number(answer.split("=")[1]);
+    while (propositions.length < n) {
+        const wrongAnswer = xValue + (0, randint_1.randint)(-10, 11, [0]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [answer, answer.split("=")[1]].includes(ans);
+};
+exports.inverseImageFunction = {
+    id: "inverseImageFunction",
+    connector: "\\iff",
+    getPropositions,
+    label: "Calculer des antécédents",
+    levels: ["3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Fonctions"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getInverseImageFunction, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    xValue: number;
+    yValue: number;
+    affineCoeffs?: number[];
+    trinomCoeffs?: number[];
+    isAffine: boolean;
+};
+export declare const inverseImageFunctionGeogebra: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=inverseImageFunctionGeogebra.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA4IF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inverseImageFunctionGeogebra = 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 affine_1 = require("../../../../math/polynomials/affine");
+const polynomial_1 = require("../../../../math/polynomials/polynomial");
+const trinom_1 = require("../../../../math/polynomials/trinom");
+const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getInverseImageFunctionGeogebra = () => {
+    const isAffine = (0, coinFlip_1.coinFlip)();
+    const xValue = (0, randint_1.randint)(-5, 6);
+    // const yValue = randint(-5, 6);
+    let yValue;
+    let affine;
+    let trinom;
+    let answer = "";
+    let xMin = -1;
+    let xMax = 1;
+    let yMin = -1;
+    let yMax = 1;
+    let commands;
+    if (isAffine) {
+        do {
+            affine = new affine_1.Affine((0, randint_1.randint)(-5, 6, [0]), (0, randint_1.randint)(-9, 10));
+            yValue = affine.calculate(xValue);
+        } while (Math.abs(yValue) > 10);
+        answer = xValue.toString().replace(".", ",");
+        yMin = yValue;
+        yMax = yValue;
+        xMin = xValue;
+        xMax = xValue;
+        commands = [affine.toString()];
+    }
+    else {
+        let roots;
+        yValue = (0, randint_1.randint)(-5, 6);
+        do {
+            trinom = new trinom_1.Trinom((0, randint_1.randint)(-4, 5, [0]), (0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-9, 10) - yValue);
+            roots = trinom.getRoots();
+        } while (roots.some((root) => Math.abs(root) > 10));
+        answer = !roots.length
+            ? "\\text{Aucun}"
+            : roots
+                .map((r) => (0, round_1.round)(r, 1).toString().replace(".", ","))
+                .join("\\text{ et }");
+        const beta = trinom.getBeta() + yValue;
+        yMin = trinom.a > 0 ? beta : roots.length ? yValue : beta - 5;
+        yMax = trinom.a < 0 ? beta : roots.length ? yValue : beta + 5;
+        xMax = roots.length ? Math.max(...roots) : -10;
+        xMin = roots.length ? Math.min(...roots) : 10;
+        commands = [
+            `f(x) = ${yValue !== 0
+                ? trinom.add(new polynomial_1.Polynomial([yValue])).toString()
+                : trinom.toString()}`,
+            `SetColor(f, "${(0, colors_1.randomColor)()}")`,
+        ];
+    }
+    const statement = `Lire graphiquement le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.`;
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+    });
+    const question = {
+        instruction: statement,
+        answer,
+        keys: ["et", "aucun"],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+        answerFormat: "tex",
+        identifiers: {
+            xValue,
+            affineCoeffs: isAffine ? affine.coefficients : undefined,
+            trinomCoeffs: isAffine ? undefined : trinom.coefficients,
+            yValue,
+            isAffine,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xValue, affineCoeffs, trinomCoeffs, yValue, isAffine }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "\\text{Aucun}");
+    if (isAffine) {
+        const affine = new polynomial_1.Polynomial(affineCoeffs);
+        (0, exercise_1.tryToAddWrongProp)(propositions, affine.calculate(yValue).toString().replace(".", ","));
+    }
+    else {
+        const trinom = new polynomial_1.Polynomial(trinomCoeffs);
+        (0, exercise_1.tryToAddWrongProp)(propositions, trinom.calculate(yValue).toString().replace(".", ","));
+    }
+    while (propositions.length < n) {
+        const wrongAnswer = (0, coinFlip_1.coinFlip)()
+            ? `${(0, randint_1.randint)(-9, 10)}`
+            : `${(0, randint_1.randint)(-9, 10)}\\text{ et }${(0, randint_1.randint)(-9, 10)}`;
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer, xValue, affineCoeffs, trinomCoeffs, yValue, isAffine }) => {
+    const antecedents = [];
+    if (isAffine) {
+        antecedents.push(xValue);
+    }
+    else {
+        const trinom = new polynomial_1.Polynomial(trinomCoeffs);
+        const roots = trinom.getRoots();
+        antecedents.push(...roots);
+    }
+    if (!antecedents.length)
+        return ans === `\\text{Aucun}`;
+    const studentNumbers = ans
+        .split("\\text{ et }")
+        .map((n) => Number(n.replace(",", ".")))
+        .filter((n) => !isNaN(n))
+        .sort((a, b) => a - b);
+    antecedents.sort((a, b) => a - b);
+    return (!!studentNumbers.length &&
+        studentNumbers.every((nb, index) => Math.abs(nb - antecedents[index]) < 0.2));
+};
+exports.inverseImageFunctionGeogebra = {
+    id: "inverseImageFunctionGeogebra",
+    connector: "\\iff",
+    label: "Lecture d'antécédents",
+    levels: ["3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Fonctions"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getInverseImageFunctionGeogebra, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"twoFunctionsEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/twoFunctionsEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;CAC3B,CAAC;AA2IF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.twoFunctionsEquation = 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 random_1 = require("../../../../utils/random");
+const getTwoFunctionsEquationQuestion = () => {
+    const yValue = (0, randint_1.randint)(-5, 5);
+    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 answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(xSolutions.map((sol) => new numberNode_1.NumberNode(sol)))).toTex();
+    const fSplinePoints = [];
+    const gSplinePoints = [];
+    let prevYWasAbove = (0, coinFlip_1.coinFlip)();
+    fSplinePoints.push([
+        xSolutions[0] - (1 + Math.random() * 3),
+        yValue + (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    gSplinePoints.push([
+        xSolutions[0] - (1 + Math.random() * 3),
+        yValue - (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    prevYWasAbove = !prevYWasAbove;
+    for (let i = 0; i < xSolutions.length; i++) {
+        fSplinePoints.push([xSolutions[i], yValue]);
+        gSplinePoints.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);
+            fSplinePoints.push([
+                x,
+                yValue + (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+            ]);
+            gSplinePoints.push([
+                x,
+                yValue - (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+            ]);
+            prevYWasAbove = !prevYWasAbove;
+        }
+    }
+    fSplinePoints.push([
+        xSolutions[xSolutions.length - 1] + (1 + Math.random() * 3),
+        yValue + (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    gSplinePoints.push([
+        xSolutions[xSolutions.length - 1] + (1 + Math.random() * 3),
+        yValue - (prevYWasAbove ? (0, randint_1.randint)(-2, 0) : (0, randint_1.randint)(1, 3)),
+    ]);
+    const xMin = Math.min(...[...fSplinePoints, ...gSplinePoints].map((point) => point[0]));
+    const yMin = Math.min(...[...fSplinePoints, ...gSplinePoints].map((point) => point[1]));
+    const xMax = Math.max(...[...fSplinePoints, ...gSplinePoints].map((point) => point[0]));
+    const yMax = Math.max(...[...fSplinePoints, ...gSplinePoints].map((point) => point[1]));
+    const fColor = (0, random_1.random)(colors_1.blues);
+    const gColor = (0, random_1.random)(colors_1.oranges);
+    const commands = [
+        `S = Spline(${fSplinePoints
+            .map((point) => `(${point[0]},${point[1]})`)
+            .join(",")})`,
+        "SetFixed(S, true)",
+        `SetColor(S, "${fColor}")`,
+        `SetCaption(S, "$f$")`,
+        `ShowLabel(S, true)`,
+        `T = Spline(${gSplinePoints
+            .map((point) => `(${point[0]},${point[1]})`)
+            .join(",")})`,
+        "SetFixed(T, true)",
+        `SetColor(T, "${gColor}")`,
+        `SetCaption(T, "$g$")`,
+        `ShowLabel(T, true)`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+    });
+    const question = {
+        answer,
+        instruction: `Déterminer graphiquement les solutions de l'équation $f(x) = g(x)$ où $f$ et $g$ sont les fonctions représentées ci-dessous.`,
+        keys: discreteSetKeys_1.discreteSetKeys,
+        answerFormat: "tex",
+        identifiers: { yValue, fSplinePoints, gSplinePoints },
+        commands: ggb.commands,
+        coords: ggb.getAdaptedCoords({ xMax, xMin, yMax, yMin }),
+        options: ggb.getOptions(),
+    };
+    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, { answer, fSplinePoints, yValue }) => {
+    const xSolutions = fSplinePoints
+        .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.twoFunctionsEquation = {
+    id: "twoFunctionsEquation",
+    label: "Résoudre graphiquement une équation du type $f(x)=g(x)$",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Fonctions"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTwoFunctionsEquationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,17 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { InegalitySymbols } from "../../../../math/inequations/inequation";
+import { ClosureType } from "../../../../tree/nodes/sets/closure";
+type Identifiers = {
+    yValue: number;
+    fSplinePoints: number[][];
+    gSplinePoints: number[][];
+    ineqSymbol: InegalitySymbols;
+    intervals: {
+        a: number;
+        b: number;
+        closure: ClosureType;
+    }[];
+};
+export declare const twoFunctionsInequation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=twoFunctionsInequation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"twoFunctionsInequation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/twoFunctionsInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAQ5D,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,SAAS,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,WAAW,CAAA;KAAE,EAAE,CAAC;CAC7D,CAAC;AA0MF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}