math-exercises 2.1.25 → 2.1.26-beta.2

package/lib/exercises/functions/trinoms/factorizedFormFromRoots.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factorizedFormFromRoots = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const substractNode_1 = require("../../../tree/nodes/operators/substractNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const probaFlip_1 = require("../../../utils/probaFlip");
+const getAnswer = (roots, a) => {
+    const isSingleRoot = roots.length === 1;
+    return isSingleRoot
+        ? new multiplyNode_1.MultiplyNode(a.toTree(), new powerNode_1.SquareNode(new substractNode_1.SubstractNode(new variableNode_1.VariableNode("x"), roots[0].toTree()))).simplify({ keepPowers: true })
+        : new multiplyNode_1.MultiplyNode(new multiplyNode_1.MultiplyNode(a.toTree(), new substractNode_1.SubstractNode(new variableNode_1.VariableNode("x"), roots[0].toTree())), new substractNode_1.SubstractNode(new variableNode_1.VariableNode("x"), roots[1].toTree())).simplify();
+};
+const getFactorizedFormFromRootsQuestion = () => {
+    const a = (0, randint_1.randint)(-10, 10, [0]);
+    const firstRoot = (0, randint_1.randint)(-10, 10);
+    const secondRoot = (0, randint_1.randint)(-10, 10, [firstRoot]);
+    const isSingleRoot = (0, probaFlip_1.probaFlip)(0.3);
+    const roots = isSingleRoot
+        ? [firstRoot]
+        : [firstRoot, secondRoot].sort((a, b) => a - b);
+    const answer = getAnswer(roots, a);
+    const answerTex = answer.toTex();
+    const question = {
+        answer: answerTex,
+        instruction: `Soit $f(x) = ax^2 + bx + c$ un polynôme du second degré avec $a = ${a}$ et qui a ${roots.length === 1
+            ? `une racine : $${roots[0]}$`
+            : `deux racines : $${roots[0]}$ et $${roots[1]}$`}. Déterminer la forme factorisée de $f$.`,
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers: { a, roots },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, roots }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer(roots.map((r) => -r), a).toTex());
+    while (propositions.length < n) {
+        const x1 = (0, randint_1.randint)(-10, 10);
+        const x2 = (0, randint_1.randint)(-10, 10, [x1]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer([x1, x2].sort((a, b) => a - b), (0, randint_1.randint)(-10, 10, [0])).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, roots }) => {
+    const answerNode = getAnswer(roots, a);
+    const texs = answerNode.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.factorizedFormFromRoots = {
+    id: "factorizedFormFromRoots",
+    connector: "=",
+    label: "Déterminer la forme factorisée en connaissant les racines",
+    levels: ["1rePro", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFactorizedFormFromRootsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./alphaBetaFromDevForm";
+export * from "./alphaBetaInCanonicalForm";
+export * from "./canonicalFromDevForm";
+export * from "./deltaTrinom";
+export * from "./extremumFromCanonicalForm";
+export * from "./extremumTypeFromAlgebricForm";
+export * from "./niceRootsFromDevForm";
+export * from "./rootsFromDevForm";
+export * from "./rootsFromFactorizedForm";
+export * from "./variationsFromAlgebricForm";
+export * from "./secondDegreeInequation";
+export * from "./rootsReading";
+export * from "./factorizedFormFromRoots";
+export * from "./summitReading";
+export * from "./summitAbscissFromRoots";
+export * from "./summitAbscissFromDevForm";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/functions/trinoms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC"}

package/lib/exercises/functions/trinoms/index.js

@@ -0,0 +1,32 @@
+"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("./alphaBetaFromDevForm"), exports);
+__exportStar(require("./alphaBetaInCanonicalForm"), exports);
+__exportStar(require("./canonicalFromDevForm"), exports);
+__exportStar(require("./deltaTrinom"), exports);
+__exportStar(require("./extremumFromCanonicalForm"), exports);
+__exportStar(require("./extremumTypeFromAlgebricForm"), exports);
+__exportStar(require("./niceRootsFromDevForm"), exports);
+__exportStar(require("./rootsFromDevForm"), exports);
+__exportStar(require("./rootsFromFactorizedForm"), exports);
+__exportStar(require("./variationsFromAlgebricForm"), exports);
+__exportStar(require("./secondDegreeInequation"), exports);
+__exportStar(require("./rootsReading"), exports);
+__exportStar(require("./factorizedFormFromRoots"), exports);
+__exportStar(require("./summitReading"), exports);
+__exportStar(require("./summitAbscissFromRoots"), exports);
+__exportStar(require("./summitAbscissFromDevForm"), exports);

package/lib/exercises/functions/trinoms/niceRootsFromDevForm.d.ts

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

package/lib/exercises/functions/trinoms/niceRootsFromDevForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"niceRootsFromDevForm.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/niceRootsFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0CF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/functions/trinoms/niceRootsFromDevForm.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.niceRootsFromDevForm = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const equationSolutionNode_1 = require("../../../tree/nodes/equations/equationSolutionNode");
+const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getRootsFromDevFormQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.randomFactorized();
+    const answer = trinom.getRootsEquationSolutionTex();
+    const question = {
+        answer: answer,
+        instruction: `Soit $f(x) = ${trinom
+            .toTree()
+            .toTex()}$. Résoudre l'équation $f(x) = 0$.`,
+        keys: ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"],
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+        answerFormat: "tex",
+    };
+    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) {
+        let wrongX1 = (0, randint_1.randint)(-19, 0);
+        let wrongX2 = (0, randint_1.randint)(0, 20);
+        const wrongAnswer = `S=\\left\\{${wrongX1};${wrongX2}\\right\\}`;
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const trinom = new trinom_1.Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(roots));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.niceRootsFromDevForm = {
+    id: "niceRootsFromDevForm",
+    connector: "\\iff",
+    getPropositions,
+    isAnswerValid,
+    label: "Résoudre une équation du second degré (solutions entières)",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRootsFromDevFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+};

package/lib/exercises/functions/trinoms/rootsFromDevForm.d.ts

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

package/lib/exercises/functions/trinoms/rootsFromDevForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rootsFromDevForm.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/rootsFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2CF,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/functions/trinoms/rootsFromDevForm.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootsFromDevForm = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const equationSolutionNode_1 = require("../../../tree/nodes/equations/equationSolutionNode");
+const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getRootsFromDevFormQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.random();
+    const answer = trinom.getRootsEquationSolutionTex();
+    const question = {
+        answer: answer,
+        instruction: `Soit $f(x) = ${trinom
+            .toTree()
+            .toTex()}$. Résoudre l'équation $f(x) = 0$.`,
+        keys: ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"],
+        answerFormat: "tex",
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    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) {
+        let wrongX1 = (0, randint_1.randint)(-19, 0);
+        let wrongX2 = (0, randint_1.randint)(0, 20);
+        const wrongAnswer = `S=\\left\\{${wrongX1};${wrongX2}\\right\\}`;
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const trinom = new trinom_1.Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(roots));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.rootsFromDevForm = {
+    id: "rootsFromDevForm",
+    connector: "\\iff",
+    getPropositions,
+    label: "Résoudre une équation du second degré",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRootsFromDevFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/rootsFromFactorizedForm.d.ts

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

package/lib/exercises/functions/trinoms/rootsFromFactorizedForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rootsFromFactorizedForm.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/rootsFromFactorizedForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+EF,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAAC,WAAW,CAa7D,CAAC"}

package/lib/exercises/functions/trinoms/rootsFromFactorizedForm.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootsFromFactorizedForm = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const equationSolutionNode_1 = require("../../../tree/nodes/equations/equationSolutionNode");
+const oppositeNode_1 = require("../../../tree/nodes/functions/oppositeNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getRootsFromFactorizedFormQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.randomFactorized();
+    const answer = trinom.getRootsEquationSolutionTex();
+    const question = {
+        answer: answer,
+        instruction: `Soit $f(x) = ${trinom
+            .getFactorizedForm()
+            .toTex()}$. Résoudre l'équation $f(x) = 0$.`,
+        keys: ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"],
+        answerFormat: "tex",
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const trinom = new trinom_1.Trinom(a, b, c);
+    const roots = trinom.getRoots();
+    if (roots.length === 1 && roots[0] !== 0) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\left\\{${new oppositeNode_1.OppositeNode(new numberNode_1.NumberNode(roots[0])).toTex()}\\right\\}`);
+    }
+    if (roots.length === 2 && roots[0] !== 0) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\left\\{${new oppositeNode_1.OppositeNode(new numberNode_1.NumberNode(roots[0])).toTex()};${roots[1]}\\right\\}`);
+    }
+    if (roots.length === 2 && roots[1] !== 0) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\left\\{${roots[0]};${new oppositeNode_1.OppositeNode(new numberNode_1.NumberNode(roots[1])).toTex()}\\right\\}`);
+    }
+    if (roots.length === 2 && roots[0] !== 0 && roots[1] !== 0) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S=\\left\\{${new oppositeNode_1.OppositeNode(new numberNode_1.NumberNode(roots[0])).toTex()};${new oppositeNode_1.OppositeNode(new numberNode_1.NumberNode(roots[1])).toTex()}\\right\\}`);
+    }
+    while (propositions.length < n) {
+        const wrongAnswer = `S=\\left\\{${(0, randint_1.randint)(-10, 11)};${(0, randint_1.randint)(-10, 11)}\\right\\}`;
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const trinom = new trinom_1.Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode(roots));
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.rootsFromFactorizedForm = {
+    id: "rootsFromFactorizedForm",
+    connector: "=",
+    label: "Déterminer les racines d'un trinôme à partir de sa forme factorisée",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRootsFromFactorizedFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/rootsReading.d.ts

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

package/lib/exercises/functions/trinoms/rootsReading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuDF,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,WAAW,CAYlD,CAAC"}

package/lib/exercises/functions/trinoms/rootsReading.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rootsReading = 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 trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const getRootsReadingQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.randomNiceRoots((0, randint_1.randint)(1, 3));
+    const roots = trinom.getRoots();
+    const commands = [
+        `f(x) = ${trinom.toString()}`,
+        `SetColor(f, "${(0, colors_1.randomColor)()}")`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+        isAxesRatioFixed: false,
+        gridDistance: false,
+    });
+    const answer = roots.length === 1 ? roots[0].toString() : roots.join("\\text{ et }");
+    const question = {
+        answer,
+        instruction: `Déterminer graphiquement le ou les racine(s) du polynôme du second degré représenté ci-dessous : `,
+        keys: ["et", "aucun"],
+        answerFormat: "tex",
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: trinom.getCoords(),
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const x1 = (0, randint_1.randint)(-10, 10);
+        const x2 = (0, randint_1.randint)(-10, 10, [x1]);
+        const fakeRoots = x1 > x2 ? [x2, x1] : [x1, x2];
+        (0, exercise_1.tryToAddWrongProp)(propositions, fakeRoots.join("\\text{ et }"));
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, b, c }) => {
+    const roots = new trinom_1.Trinom(a, b, c).getRoots();
+    const studentNumbers = ans
+        .split("\\text{ et }")
+        .map((n) => Number(n.replace(",", ".")))
+        .filter((n) => !isNaN(n))
+        .sort((a, b) => a - b);
+    return (!!studentNumbers.length &&
+        studentNumbers.every((nb, index) => Math.abs(nb - roots[index]) < 0.2));
+};
+exports.rootsReading = {
+    id: "rootsReading",
+    label: "Lire graphiquement les racines d'un trinôme",
+    levels: ["1reSpé", "1rePro"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRootsReadingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

package/lib/exercises/functions/trinoms/secondDegreeInequation.d.ts

@@ -0,0 +1,11 @@
+import { MathExercise } from "../../../exercises/exercise";
+import { InegalitySymbols } from "../../../math/inequations/inequation";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    ineqType: InegalitySymbols;
+};
+export declare const secondDegreeInequation: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=secondDegreeInequation.d.ts.map

package/lib/exercises/functions/trinoms/secondDegreeInequation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secondDegreeInequation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/secondDegreeInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAuHF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/functions/trinoms/secondDegreeInequation.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secondDegreeInequation = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const inequation_1 = require("../../../math/inequations/inequation");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const inequationSolutionNode_1 = require("../../../tree/nodes/inequations/inequationSolutionNode");
+const infiniteNode_1 = require("../../../tree/nodes/numbers/infiniteNode");
+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 getAnswer = ({ a, roots, ineqType }) => {
+    const aPositive = a > 0;
+    const insideInterval = new intervalNode_1.IntervalNode(roots[0], roots[1], ineqType.isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.FF);
+    const outsideUnion = new unionIntervalNode_1.UnionIntervalNode([
+        new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, roots[0], ineqType.isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.OF),
+        new intervalNode_1.IntervalNode(roots[1], infiniteNode_1.PlusInfinityNode, ineqType.isStrict ? closure_1.ClosureType.OO : closure_1.ClosureType.FO),
+    ]);
+    const tree = ineqType.isSup
+        ? aPositive
+            ? outsideUnion
+            : insideInterval
+        : aPositive
+            ? insideInterval
+            : outsideUnion;
+    return new inequationSolutionNode_1.InequationSolutionNode(tree);
+};
+const getSecondDegreeInequationQuestion = () => {
+    const a = (0, randint_1.randint)(-5, 6, [0]);
+    const x1 = (0, randint_1.randint)(-5, 6);
+    const x2 = (0, randint_1.randint)(-5, 6, [x1]);
+    const roots = x1 < x2
+        ? [new numberNode_1.NumberNode(x1), new numberNode_1.NumberNode(x2)]
+        : [new numberNode_1.NumberNode(x2), new numberNode_1.NumberNode(x1)];
+    const c = a * x1 * x2;
+    const b = -a * x2 - a * x1;
+    const trinom = new trinom_1.Trinom(a, b, c);
+    const ineqType = inequation_1.InequationSymbolConstructor.random();
+    const answer = getAnswer({ a: trinom.a, roots, ineqType }).toTex();
+    const question = {
+        answer,
+        instruction: `Soit $f(x) = ${trinom
+            .toTree()
+            .toTex()}$. Résoudre l'inéquation $f(x) ${ineqType.symbol} 0$.`,
+        keys: [
+            "S",
+            "equal",
+            "lbracket",
+            "semicolon",
+            "rbracket",
+            "cup",
+            "infty",
+            "varnothing",
+        ],
+        answerFormat: "tex",
+        identifiers: {
+            a: trinom.a,
+            b: trinom.b,
+            c: trinom.c,
+            ineqType: ineqType.symbol,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c, ineqType }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const roots = new trinom_1.Trinom(a, b, c).getRootsNode();
+    console.log("prop", roots.length);
+    const ineq = new inequation_1.InequationSymbol(ineqType);
+    (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer({ a: -a, ineqType: ineq, roots }).toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer({ a, ineqType: ineq.toStrictnessToggled(), roots }).toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer({ a: -a, ineqType: ineq.toStrictnessToggled(), roots }).toTex());
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, b, c, ineqType }) => {
+    const trinom = new trinom_1.Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const ineq = new inequation_1.InequationSymbol(ineqType);
+    const tree = getAnswer({ a, ineqType: ineq, roots });
+    const texs = tree.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.secondDegreeInequation = {
+    id: "secondDegreeInequation",
+    connector: "\\iff",
+    label: "Résoudre une inéquation du second degré",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Inéquations", "Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSecondDegreeInequationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/summitAbscissFromDevForm.d.ts

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

package/lib/exercises/functions/trinoms/summitAbscissFromDevForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summitAbscissFromDevForm.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/summitAbscissFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8CF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAc9D,CAAC"}

package/lib/exercises/functions/trinoms/summitAbscissFromDevForm.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summitAbscissFromDevForm = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const getSummitAbscissFromDevFormQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.random();
+    const alpha = trinom.getAlphaNode();
+    const answer = alpha.toTex();
+    const question = {
+        answer,
+        instruction: `Soit $f(x) = ${trinom
+            .toTree()
+            .toTex()}$ une fonction polynôme du second degré. Quelle est l'abscisse du sommet de la parabole représentant $f$ ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational(-b, a).simplify().toTree().toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational(b, a).simplify().toTree().toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const node = new rational_1.Rational(-b, 2 * a).simplify().toTree();
+    const texs = node.toAllValidTexs({
+        allowFractionToDecimal: true,
+        allowMinusAnywhereInFraction: true,
+    });
+    return texs.includes(ans);
+};
+exports.summitAbscissFromDevForm = {
+    id: "summitAbscissFromDevForm",
+    connector: "=",
+    label: "Déterminer l'abscisse du sommet d'une parabole en connaissant la forme développée",
+    levels: ["1rePro", "1reSpé", "1reTech"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSummitAbscissFromDevFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/summitAbscissFromRoots.d.ts

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

package/lib/exercises/functions/trinoms/summitAbscissFromRoots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summitAbscissFromRoots.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/summitAbscissFromRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgDF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAc5D,CAAC"}