math-exercises 3.0.10 → 3.0.11

package/lib/exercises/math/functions/trinoms/parabole/trinomSymetryAxisFromFacto.js

@@ -0,0 +1,112 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { equationSolutionParser } from "../../../../../tree/parsers/equationSolutionParser.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const wrong = coinFlip()
+            ? randint(-10, 10) + ""
+            : RationalConstructor.randomIrreductible().toTree().toTex();
+        tryToAddWrongProp(propositions, `x=${wrong}`);
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, x1, x2 } = identifiers;
+    const alpha = frac(add(x1, x2), 2).simplify().toTex();
+    return `x=${alpha}`;
+};
+const getInstruction = (identifiers) => {
+    const { a, x1, x2 } = identifiers;
+    const node = multiply(a, multiply(substract("x", x1), substract("x", x2))).simplify({ forbidFactorize: true });
+    return `Soit $f$ la fonction polynôme du second degré définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${node.toTex()}
+$$
+
+Déterminer l'équation de l'axe de symétrie de la parabole représentant $f$.
+`;
+};
+const getHint = (identifiers) => {
+    return `Si $x_1$ et $x_2$ sont deux racines distinctes de $f$, alors l'axe de symétrie de la parabole représentant $f$ a pour équation :
+  
+$$
+x=\\frac{x_1+x_2}{2}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, x1, x2 } = identifiers;
+    const fraction = frac(add(x1, x2), 2);
+    return `$f$ admet deux racines distinctes : $${x1}$ et $${x2}$. 
+
+L'axe de symétrie de la parabole représentant $f$ a donc pour équation : 
+
+$$
+x=${fraction.toTex()}=${frac(x1 + x2, 2).toSimplificationString()}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return ["x", "equal"];
+};
+const isAnswerValid = (ans, { answer, a, x1, x2 }) => {
+    try {
+        const solutionTex = frac(add(x1, x2), 2).simplify().toTex();
+        let parsed = equationSolutionParser(ans);
+        if (!parsed)
+            return false;
+        return rationalVEA(parsed.toTex(), solutionTex);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTrinomSymetryAxisFromFactoQuestion = (ops) => {
+    const a = randint(-10, 11, [0]);
+    let x1 = randint(-10, 11);
+    let x2 = randint(-10, 11, [x1]);
+    if (x1 > x2)
+        [x1, x2] = [x2, x1];
+    const identifiers = {
+        a,
+        x1,
+        x2,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const trinomSymetryAxisFromFacto = {
+    id: "trinomSymetryAxisFromFacto",
+    connector: "\\iff",
+    label: "Déterminer l'axe de symétrie d'une parabole en connaissant la forme factorisée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrinomSymetryAxisFromFactoQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/trinoms/roots/findSecondRoot.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { TrinomNodeIdentifiers } from "../../../../../tree/nodes/polynomials/trinomNode.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    trinomIdentifiers: TrinomNodeIdentifiers;
+    firstRootIdentifiers: NodeIdentifiers;
+};
+export declare const findSecondRoot: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findSecondRoot.d.ts.map

package/lib/exercises/math/functions/trinoms/roots/findSecondRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findSecondRoot.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/findSecondRoot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,4CAA4C,CAAC;AAIpD,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,qBAAqB,CAAC;IACzC,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AAiHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAiBhD,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/findSecondRoot.js

@@ -0,0 +1,124 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
+import { TrinomNode, TrinomNodeConstructor, } from "../../../../../tree/nodes/polynomials/trinomNode.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(-10, 10).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { trinomIdentifiers, firstRootIdentifiers } = identifiers;
+    const trinom = TrinomNodeConstructor.fromIdentifiers(trinomIdentifiers);
+    const firstRoot = NodeConstructor.fromIdentifiers(firstRootIdentifiers);
+    const firstRootTex = firstRoot.toTex();
+    const roots = trinom.getRoots().map((e) => e.toTex());
+    return roots.find((r) => r !== firstRootTex);
+};
+const getInstruction = (identifiers) => {
+    const { trinomIdentifiers, firstRootIdentifiers } = identifiers;
+    const trinom = TrinomNodeConstructor.fromIdentifiers(trinomIdentifiers);
+    const firstRoot = NodeConstructor.fromIdentifiers(firstRootIdentifiers);
+    const firstRootTex = firstRoot.toTex();
+    return `Soit $f$ la fonction polynôme du second degré définie sur $\\mathbb{R}$ par :
+  
+$$
+f(x) = ${trinom.toTree().toTex()}
+$$
+  
+On admet que $f$ admet deux racines, dont une vaut $${firstRootTex}$. 
+  
+Sans calculer $\\Delta$, déterminer la deuxième racine de $f$.`;
+};
+const getHint = (identifiers) => {
+    return `Si $f(x) = ax^2 + bx + c$ admet deux racines $x_1$ et $x_2$, alors leur produit vaut : 
+    
+$$
+x_1\\times x_2 = \\frac{c}{a}
+$$
+
+En remplaçant les valeurs par celles données dans l'énoncé, on peut déterminer la deuxième racine de $f$. 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { trinomIdentifiers, firstRootIdentifiers } = identifiers;
+    const trinom = TrinomNodeConstructor.fromIdentifiers(trinomIdentifiers);
+    const firstRoot = NodeConstructor.fromIdentifiers(firstRootIdentifiers);
+    const cOverA = frac(trinom.c, trinom.a).simplify();
+    return `On sait que le produit des racines $x_1$ et $x_2$ de $f$ vaut :
+  
+$$
+x_1\\times x_2 = \\frac{c}{a} = ${cOverA.toTex()}
+$$
+
+Or on sait que $x_1 = ${firstRoot.toTex()}$. On a donc : 
+
+$$
+x_2 = ${frac(cOverA, firstRoot).toSimplificationString()}
+$$
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return rationalVEA(ans, answer);
+};
+const getFindSecondRootQuestion = (ops) => {
+    // const firstRoot = coinFlip()
+    //   ? randint(-10, 10).toTree()
+    //   : RationalConstructor.randomIrreductibleWithSign(5).toTree();
+    const firstRoot = randint(-10, 10, [0]);
+    // const secondRoot = doWhile(
+    //   () =>
+    //     coinFlip()
+    //       ? randint(-10, 10).toTree()
+    //       : RationalConstructor.randomIrreductibleWithSign(5).toTree(),
+    //   (x) => x.equals(firstRoot),
+    // );
+    const secondRoot = randint(-10, 10, [firstRoot]);
+    const a = randint(-10, 10, [0]);
+    const b = opposite(multiply(a, add(firstRoot, secondRoot))).simplify();
+    const c = multiply(a, multiply(firstRoot, secondRoot)).simplify();
+    //first*second = c/a
+    const identifiers = {
+        firstRootIdentifiers: firstRoot.toTree().toIdentifiers(),
+        trinomIdentifiers: new TrinomNode(a, b, c).toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findSecondRoot = {
+    id: "findSecondRoot",
+    connector: "=",
+    label: "Déterminer la deuxième racine d'un trinôme sans utiliser $\\Delta$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindSecondRootQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+export * from "./findSecondRoot.js";
+export * from "./niceRootsFromDevForm.js";
+export * from "./rootsFromDevForm.js";
+export * from "./rootsFromFactorizedForm.js";
+export * from "./rootsProduct.js";
+export * from "./rootsReading.js";
+export * from "./rootsSum.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC"}

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

@@ -0,0 +1,7 @@
+export * from "./findSecondRoot.js";
+export * from "./niceRootsFromDevForm.js";
+export * from "./rootsFromDevForm.js";
+export * from "./rootsFromFactorizedForm.js";
+export * from "./rootsProduct.js";
+export * from "./rootsReading.js";
+export * from "./rootsSum.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"niceRootsFromDevForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/niceRootsFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAQrC,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,QAAQ,CAAC,WAAW,CActD,CAAC"}

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

@@ -0,0 +1,54 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getRootsFromDevFormQuestion = () => {
+    const trinom = 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 = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "S=\\varnothing");
+    while (propositions.length < n) {
+        let wrongX1 = randint(-19, 0);
+        let wrongX2 = randint(0, 20);
+        const wrongAnswer = `S=\\left\\{${wrongX1};${wrongX2}\\right\\}`;
+        tryToAddWrongProp(propositions, wrongAnswer);
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const answer = new EquationSolutionNode(new DiscreteSetNode(roots));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const 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) => getDistinctQuestions(getRootsFromDevFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rootsFromDevForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAQrC,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,QAAQ,CAAC,WAAW,CAgBlD,CAAC"}

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

@@ -0,0 +1,55 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getRootsFromDevFormQuestion = () => {
+    const trinom = 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 = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "S=\\varnothing");
+    while (propositions.length < n) {
+        let wrongX1 = randint(-19, 0);
+        let wrongX2 = randint(0, 20);
+        const wrongAnswer = `S=\\left\\{${wrongX1};${wrongX2}\\right\\}`;
+        tryToAddWrongProp(propositions, wrongAnswer);
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const answer = new EquationSolutionNode(new DiscreteSetNode(roots));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const 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) => getDistinctQuestions(getRootsFromDevFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    pdfOptions: { shouldSpreadPropositions: true },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rootsFromFactorizedForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromFactorizedForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAUrC,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,QAAQ,CAAC,WAAW,CAczD,CAAC"}

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

@@ -0,0 +1,67 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { OppositeNode } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getRootsFromFactorizedFormQuestion = () => {
+    const trinom = 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 = [];
+    addValidProp(propositions, answer);
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRoots();
+    if (roots.length === 1 && roots[0] !== 0) {
+        tryToAddWrongProp(propositions, `S=\\left\\{${new OppositeNode(new NumberNode(roots[0])).toTex()}\\right\\}`);
+    }
+    if (roots.length === 2 && roots[0] !== 0) {
+        tryToAddWrongProp(propositions, `S=\\left\\{${new OppositeNode(new NumberNode(roots[0])).toTex()};${roots[1]}\\right\\}`);
+    }
+    if (roots.length === 2 && roots[1] !== 0) {
+        tryToAddWrongProp(propositions, `S=\\left\\{${roots[0]};${new OppositeNode(new NumberNode(roots[1])).toTex()}\\right\\}`);
+    }
+    if (roots.length === 2 && roots[0] !== 0 && roots[1] !== 0) {
+        tryToAddWrongProp(propositions, `S=\\left\\{${new OppositeNode(new NumberNode(roots[0])).toTex()};${new OppositeNode(new NumberNode(roots[1])).toTex()}\\right\\}`);
+    }
+    while (propositions.length < n) {
+        const wrongAnswer = `S=\\left\\{${randint(-10, 11)};${randint(-10, 11)}\\right\\}`;
+        tryToAddWrongProp(propositions, wrongAnswer);
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const answer = new EquationSolutionNode(new DiscreteSetNode(roots));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const 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) => getDistinctQuestions(getRootsFromFactorizedFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/functions/trinoms/roots/rootsProduct.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { TrinomNodeIdentifiers } from "../../../../../tree/nodes/polynomials/trinomNode.js";
+type Identifiers = {
+    trinomIdentifiers: TrinomNodeIdentifiers;
+};
+export declare const rootsProduct: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=rootsProduct.d.ts.map

package/lib/exercises/math/functions/trinoms/roots/rootsProduct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rootsProduct.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,4CAA4C,CAAC;AAOpD,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,qBAAqB,CAAC;CAC1C,CAAC;AA0GF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAiB9C,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/rootsProduct.js

@@ -0,0 +1,109 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
+import { TrinomNode, TrinomNodeConstructor, } from "../../../../../tree/nodes/polynomials/trinomNode.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+const getPropositions = (n, { answer, trinomIdentifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const trinom = TrinomNodeConstructor.fromIdentifiers(trinomIdentifiers);
+    tryToAddWrongProp(propositions, frac(opposite(trinom.b), trinom.a).simplify().toTex());
+    tryToAddWrongProp(propositions, frac(opposite(trinom.c), trinom.a).simplify().toTex());
+    tryToAddWrongProp(propositions, frac(opposite(trinom.b), multiply(2, trinom.a)).simplify().toTex());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(-10, 10).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { trinomIdentifiers } = identifiers;
+    const trinom = TrinomNodeConstructor.fromIdentifiers(trinomIdentifiers);
+    const ans = frac(trinom.c, trinom.a).simplify().toTex();
+    return ans;
+};
+const getInstruction = (identifiers) => {
+    const { trinomIdentifiers } = identifiers;
+    const trinom = TrinomNodeConstructor.fromIdentifiers(trinomIdentifiers);
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par :
+    
+$$
+f(x) = ${trinom.toTree().toTex()}
+$$
+  
+On admet que $f$ possède deux racines. 
+
+Que vaut le produit des racines de $f$ ?`;
+};
+const getHint = (identifiers) => {
+    return `Si $f(x) = ax^2 + bx + c$ admet deux racines, alors leur produit $P$ vaut : 
+    
+$$
+P = \\frac{c}{a}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { trinomIdentifiers } = identifiers;
+    const trinom = TrinomNodeConstructor.fromIdentifiers(trinomIdentifiers);
+    const aTex = trinom.a.toTex();
+    const cTex = trinom.c.toTex();
+    const ans = frac(trinom.c, trinom.a);
+    return `Si $f(x) = ax^2 + bx + c$ admet deux racines, alors leur produit $P$ vaut : 
+    
+$$
+P = \\frac{c}{a}
+$$
+  
+Ici, on a $a = ${aTex}$ et $c = ${cTex}$, donc :
+
+$$
+P = ${ans.toSimplificationString()}
+$$
+  `;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return rationalVEA(ans, answer);
+};
+const getRootsProductQuestion = (ops) => {
+    //(b,c) != 0
+    //ac <= 0
+    const a = randint(-10, 10, [0]);
+    const b = randint(-10, 10);
+    const c = (a / Math.abs(a)) * randint(-10, 0, !b ? [0] : []);
+    const trinom = new TrinomNode(a, b, c);
+    const identifiers = {
+        trinomIdentifiers: trinom.toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const rootsProduct = {
+    id: "rootsProduct",
+    connector: "=",
+    label: "Produit des racines d'un trinôme",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRootsProductQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqDF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}