math-exercises 3.0.10 → 3.0.11

package/lib/exercises/math/calcul/fractions/fractionsOperations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionsOperations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AA4FF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}
+{"version":3,"file":"fractionsOperations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,eAAe,CAAC;CACvC,CAAC;AA2FF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

package/lib/exercises/math/calcul/fractions/fractionsOperations.js

@@ -17,7 +17,6 @@ const getPropositions = (n, { answer }) => {
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    console.log("ans", identifiers);
     const statement = NodeConstructor.fromIdentifiers(identifiers.statementIdentifiers, true);
     return statement.simplify().toTex();
 };

package/lib/exercises/math/calculLitteral/equation/firstDegreeEquationIntType1.js

@@ -45,7 +45,7 @@ const getHint = (identifiers) => {
     return `Il faut isoler $x$ à gauche. Pour cela, effectue l'opération des deux côtés de l'équation qui permet de supprimer la multiplication par $${a}$.`;
 };
 const getFirstDegreeEquationIntQuestion = () => {
-    const a = randint(-15, 15, [0]);
+    const a = randint(-15, 15, [0, 1]);
     const x = randint(-15, 15, [0]);
     const b = a * x;
     const identifiers = { a: a, x: x, b: b };

package/lib/exercises/math/calculLitteral/factorisation/factoType1Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoType1Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType1Exercise.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAmBrC;;;GAGG;AACH,KAAK,WAAW,GAAG;IAEjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAIlB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA8JF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}
+{"version":3,"file":"factoType1Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType1Exercise.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAuBrC;;;GAGG;AACH,KAAK,WAAW,GAAG;IAEjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAIlB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAoKF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoType1Exercise.js

@@ -7,6 +7,7 @@ import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.j
 import { randint } from "../../../../math/utils/random/randint.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { MultiplyNode, isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isPowerNode, isSquareNode, } from "../../../../tree/nodes/operators/powerNode.js";
 import { substract, } from "../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { random } from "../../../../utils/alea/random.js";
@@ -48,7 +49,7 @@ const getAnswer = (identifiers) => {
 const getFactoType1Question = () => {
     const a = randint(-9, 10, [0]);
     const b = randint(-9, 10, [0]);
-    const operation = random(["add", "substract"]);
+    let operation = random(["add", "substract"]);
     let c, d;
     let e, f;
     do {
@@ -104,7 +105,10 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
         const parsed = parseAlgebraic(ans);
         if (!parsed)
             return false;
-        if (answer !== "0" && !isMultiplyNode(parsed))
+        if (answer !== "0" &&
+            !isMultiplyNode(parsed) &&
+            !isSquareNode(parsed) &&
+            !isPowerNode(parsed))
             return false;
         const simp = parsed.simplify({
             forbidFactorize: true,

package/lib/exercises/math/functions/trinoms/devForm/coefficientsIdentification.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIdentifiers: NodeIdentifiers;
+    bIdentifiers: NodeIdentifiers;
+    cIdentifiers: NodeIdentifiers;
+    isAsking: string;
+};
+export declare const coefficientsIdentification: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=coefficientsIdentification.d.ts.map

package/lib/exercises/math/functions/trinoms/devForm/coefficientsIdentification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coefficientsIdentification.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/devForm/coefficientsIdentification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAuIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAgB5D,CAAC"}

package/lib/exercises/math/functions/trinoms/devForm/coefficientsIdentification.js

@@ -0,0 +1,134 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../../math/numbers/rationals/rational.js";
+import { TrinomNode } from "../../../../../tree/nodes/polynomials/trinomNode.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { isFractionNode } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, aIdentifiers, bIdentifiers, cIdentifiers, isAsking }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const trinom = new TrinomNode(NodeConstructor.fromIdentifiers(aIdentifiers), NodeConstructor.fromIdentifiers(bIdentifiers), NodeConstructor.fromIdentifiers(cIdentifiers));
+    if (answer === "1") {
+        tryToAddWrongProp(propositions, "0");
+    }
+    if (answer === "0") {
+        tryToAddWrongProp(propositions, "1");
+    }
+    if (answer === "-1") {
+        tryToAddWrongProp(propositions, "-");
+    }
+    const askedNode = isAsking === "a" ? trinom.a : isAsking === "b" ? trinom.b : trinom.c;
+    if (isFractionNode(askedNode)) {
+        tryToAddWrongProp(propositions, askedNode.leftChild.toTex());
+    }
+    // si frac ajouter que le num
+    const monom = isAsking === "a"
+        ? multiply(trinom.a, square("x")).simplify()
+        : isAsking === "b"
+            ? multiply(trinom.b, "x").simplify()
+            : trinom.c;
+    tryToAddWrongProp(propositions, monom.toTex());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(-10, 10) + "");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIdentifiers, bIdentifiers, cIdentifiers, isAsking } = identifiers;
+    return isAsking === "a"
+        ? NodeConstructor.fromIdentifiers(aIdentifiers).toTex()
+        : isAsking === "b"
+            ? NodeConstructor.fromIdentifiers(bIdentifiers).toTex()
+            : NodeConstructor.fromIdentifiers(cIdentifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const trinom = new TrinomNode(NodeConstructor.fromIdentifiers(identifiers.aIdentifiers), NodeConstructor.fromIdentifiers(identifiers.bIdentifiers), NodeConstructor.fromIdentifiers(identifiers.cIdentifiers));
+    return `Soit $f$ la fonction polynôme de degré $2$ définie sur $\\mathbb{R}$ par :
+  
+$$
+f(x)=${trinom
+        .toTree()
+        .simplify({
+        // forceDistributeFractions: true,
+        forbidFactorize: true,
+        towardsDistribute: true,
+    })
+        .toTex()}
+$$
+  
+Quelle est la valeur du coefficient $${identifiers.isAsking}$ de $f$ ?`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCoefficientsIdentificationQuestion = () => {
+    const a = random([
+        (-1).toTree(),
+        (1).toTree(),
+        randint(-10, 11, [-1, 0, 1]).toTree(),
+        RationalConstructor.randomIrreductible().toTree(),
+    ]);
+    const b = random([
+        (-1).toTree(),
+        (1).toTree(),
+        (0).toTree(),
+        randint(-10, 10, [-1, 1, 0]).toTree(),
+        RationalConstructor.randomIrreductible().toTree(),
+    ]);
+    const c = random([
+        (0).toTree(),
+        randint(-10, 11, [0]).toTree(),
+        RationalConstructor.randomIrreductible().toTree(),
+    ]);
+    const isAsking = random(["a", "b", "c"]);
+    const identifiers = {
+        aIdentifiers: a.toIdentifiers(),
+        bIdentifiers: b.toIdentifiers(),
+        cIdentifiers: c.toIdentifiers(),
+        isAsking,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const coefficientsIdentification = {
+    id: "coefficientsIdentification",
+    connector: "=",
+    label: "Reconnaître les coefficients $a$, $b$ et $c$ d'un trinôme exprimé sous forme développée",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCoefficientsIdentificationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

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

@@ -0,0 +1,3 @@
+export * from "./coefficientsIdentification.js";
+export * from "./variationsFromAlgebricForm.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/devForm/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from "./coefficientsIdentification.js";
+export * from "./variationsFromAlgebricForm.js";

package/lib/exercises/math/functions/trinoms/devForm/variationsFromAlgebricForm.d.ts

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

package/lib/exercises/math/functions/trinoms/devForm/variationsFromAlgebricForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variationsFromAlgebricForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/devForm/variationsFromAlgebricForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAOT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/math/functions/trinoms/devForm/variationsFromAlgebricForm.js

@@ -0,0 +1,42 @@
+import { addValidProp, addWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getVariationsFromAlgebricFormQuestion = () => {
+    const isDevForm = coinFlip();
+    const trinom = isDevForm
+        ? TrinomConstructor.random()
+        : TrinomConstructor.randomCanonical();
+    const answer = trinom.a > 0
+        ? "Décroissante puis croissante"
+        : "Croissante puis décroissante";
+    const question = {
+        answer: answer,
+        instruction: `Quelles sont les variations de la fonction $f$ définie par $f(x) = ${isDevForm ? trinom.toTree().toTex() : trinom.getCanonicalForm().toTex()}$ ?`,
+        answerFormat: "raw",
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    addWrongProp(propositions, a < 0 ? "Décroissante puis croissante" : "Croissante puis décroissante", "raw");
+    addWrongProp(propositions, "Constante", "raw");
+    addWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffle(propositions);
+};
+export const variationsFromAlgebricForm = {
+    id: "variationsFromAlgebricForm",
+    label: "Déterminer les variations d'une fonction du second degré via sa forme algébrique",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => getDistinctQuestions(getVariationsFromAlgebricFormQuestion, nb),
+    answerType: "QCU",
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/functions/trinoms/equation/deltaTrinom.d.ts

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

package/lib/exercises/math/functions/trinoms/equation/deltaTrinom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deltaTrinom.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/equation/deltaTrinom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwCF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAc7C,CAAC"}

package/lib/exercises/math/functions/trinoms/equation/deltaTrinom.js

@@ -0,0 +1,50 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getDeltaTrinomQuestion = () => {
+    const trinom = TrinomConstructor.random();
+    const answer = trinom.getDelta() + "";
+    const question = {
+        answer: answer,
+        instruction: `Soit $f(x) = ${trinom
+            .toTree()
+            .toTex()}$. Calculer le discriminant $\\Delta$.`,
+        keys: [],
+        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 bMinus4ac = b - 4 * a * c;
+    tryToAddWrongProp(propositions, bMinus4ac + "");
+    const bSquarePlus4ac = b ** 2 + a * c;
+    tryToAddWrongProp(propositions, bSquarePlus4ac + "");
+    while (propositions.length < n) {
+        const wrongAnswer = randint(-100, 100) + "";
+        tryToAddWrongProp(propositions, wrongAnswer);
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const delta = b ** 2 - 4 * a * c;
+    return ans === delta.toString();
+};
+export const deltaTrinom = {
+    id: "deltaTrinom",
+    connector: "=",
+    getPropositions,
+    label: "Calculer le discriminant d'un trinôme",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => getDistinctQuestions(getDeltaTrinomQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,5 @@
+export * from "./deltaTrinom.js";
+export * from "./secondDegreeInequation.js";
+export * from "./solveSecondDegreeEquationByFactorisation.js";
+export * from "./solveSecondDegreeEquationFromCano.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+CAA+C,CAAC;AAC9D,cAAc,wCAAwC,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from "./deltaTrinom.js";
+export * from "./secondDegreeInequation.js";
+export * from "./solveSecondDegreeEquationByFactorisation.js";
+export * from "./solveSecondDegreeEquationFromCano.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"secondDegreeInequation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/equation/secondDegreeInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAiB9C,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;AAwHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

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

@@ -0,0 +1,102 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { InequationSymbol, InequationSymbolConstructor, } from "../../../../../math/inequations/inequation.js";
+import { Trinom } from "../../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { InequationSolutionNode } from "../../../../../tree/nodes/inequations/inequationSolutionNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../../tree/nodes/numbers/infiniteNode.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { ClosureType } from "../../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../../tree/nodes/sets/intervalNode.js";
+import { UnionIntervalNode } from "../../../../../tree/nodes/sets/unionIntervalNode.js";
+import { unionIntervalParser } from "../../../../../tree/parsers/unionIntervalParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getAnswer = ({ a, roots, ineqType }) => {
+    const aPositive = a > 0;
+    const insideInterval = new IntervalNode(roots[0], roots[1], ineqType.isStrict ? ClosureType.OO : ClosureType.FF);
+    const outsideUnion = new UnionIntervalNode([
+        new IntervalNode(MinusInfinityNode, roots[0], ineqType.isStrict ? ClosureType.OO : ClosureType.OF),
+        new IntervalNode(roots[1], PlusInfinityNode, ineqType.isStrict ? ClosureType.OO : ClosureType.FO),
+    ]);
+    const tree = ineqType.isSup
+        ? aPositive
+            ? outsideUnion
+            : insideInterval
+        : aPositive
+            ? insideInterval
+            : outsideUnion;
+    return new InequationSolutionNode(tree);
+};
+const getSecondDegreeInequationQuestion = () => {
+    const a = randint(-5, 6, [0]);
+    const x1 = randint(-5, 6);
+    const x2 = randint(-5, 6, [x1]);
+    const roots = x1 < x2
+        ? [new NumberNode(x1), new NumberNode(x2)]
+        : [new NumberNode(x2), new NumberNode(x1)];
+    const c = a * x1 * x2;
+    const b = -a * x2 - a * x1;
+    const trinom = new Trinom(a, b, c);
+    const ineqType = 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 = [];
+    addValidProp(propositions, answer);
+    const roots = new Trinom(a, b, c).getRootsNode();
+    const ineq = new InequationSymbol(ineqType);
+    tryToAddWrongProp(propositions, getAnswer({ a: -a, ineqType: ineq, roots }).toTex());
+    tryToAddWrongProp(propositions, getAnswer({ a, ineqType: ineq.toStrictnessToggled(), roots }).toTex());
+    tryToAddWrongProp(propositions, getAnswer({ a: -a, ineqType: ineq.toStrictnessToggled(), roots }).toTex());
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, b, c, ineqType }) => {
+    try {
+        const parsed = unionIntervalParser(ans.replaceAll("S", "").replaceAll("=", ""));
+        if (!parsed)
+            return false;
+        return "S=\\ " + parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const 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) => getDistinctQuestions(getSecondDegreeInequationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    pdfOptions: { shouldSpreadPropositions: true },
+};

package/lib/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationByFactorisation.d.ts

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

package/lib/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationByFactorisation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solveSecondDegreeEquationByFactorisation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationByFactorisation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAgIF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAiB1E,CAAC"}

package/lib/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationByFactorisation.js

@@ -0,0 +1,131 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { equationKeys } from "../../../../../exercises/utils/keys/equationKeys.js";
+import { Rational } from "../../../../../math/numbers/rationals/rational.js";
+import { Trinom } 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 { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+/**
+ * Equation donnée sous forme ax^2 + bx ou bien forme développée d'une identité remarquable
+ * type 1 ax^2 + bx
+ * type 2 (ax+b)^2
+ * type 3 (ax-b)^2
+ * type 4 (ax+b)(ax-b)
+ */
+const getSolveSecondDegreeEquationByFactorisationQuestion = () => {
+    const type = randint(1, 4);
+    let statement = "";
+    let roots = [];
+    let answer = "";
+    let a;
+    let b;
+    switch (type) {
+        case 1:
+            {
+                //ax^2 + bx
+                const trinom = new Trinom(randint(-9, 10, [0]), randint(-9, 10), 0);
+                a = trinom.a;
+                b = trinom.b;
+                statement = trinom.toTex();
+                roots = trinom.getRootsNode();
+            }
+            break;
+        case 2:
+            {
+                //(ax+b)^2
+                a = randint(-9, 10, [0]);
+                b = randint(1, 10);
+                statement = new Trinom(a ** 2, 2 * a * b, b ** 2).toTex();
+                roots = [new Rational(-b, a).simplify().toTree()];
+            }
+            break;
+        case 3:
+            {
+                //(ax-b)^2
+                a = randint(-9, 10, [0]);
+                b = randint(-9, 0, [0]);
+                statement = new Trinom(a ** 2, -2 * a * b, b ** 2).toTex();
+                roots = [new Rational(b, a).simplify().toTree()];
+            }
+            break;
+        case 4:
+        default:
+            {
+                //(ax+b)(ax-b)
+                a = randint(-9, 10, [0]);
+                b = randint(1, 10);
+                statement = new Trinom(a ** 2, 0, -(b ** 2)).toTex();
+                roots = [b, -b].sort((a, b) => a - b).map((x) => x.toTree());
+            }
+            break;
+    }
+    const instruction = `Soit $f(x) = ${statement}$. Factoriser $f(x)$, puis résoudre l'équation $f(x) = 0$.`;
+    answer = new EquationSolutionNode(new DiscreteSetNode(roots)).toTex();
+    const question = {
+        answer,
+        instruction,
+        keys: [...equationKeys],
+        answerFormat: "tex",
+        identifiers: { a, b, type },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const firstRoot = randint(-10, 10);
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode(coinFlip()
+            ? [firstRoot.toTree()]
+            : [firstRoot, randint(-10, 10, [firstRoot])]
+                .sort((a, b) => a - b)
+                .map((x) => x.toTree()))).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, type, a, b }) => {
+    let roots = [];
+    switch (type) {
+        case 1:
+            {
+                const trinom = new Trinom(a, b, 0);
+                roots = trinom.getRootsNode();
+            }
+            break;
+        case 2:
+            {
+                roots = [new Rational(-b, a).simplify().toTree()];
+            }
+            break;
+        case 3:
+            {
+                roots = [new Rational(b, a).simplify().toTree()];
+            }
+            break;
+        case 4:
+            {
+                roots = [b, -b].sort((a, b) => a - b).map((x) => x.toTree());
+            }
+            break;
+    }
+    const answerTree = new EquationSolutionNode(new DiscreteSetNode(roots), {
+        opts: { allowFractionToDecimal: true, allowRawRightChildAsSolution: true },
+    });
+    return answerTree.toAllValidTexs().includes(ans);
+};
+export const solveSecondDegreeEquationByFactorisation = {
+    id: "solveSecondDegreeEquationByFactorisation",
+    connector: "\\iff",
+    label: "Résoudre une équation du second degré par factorisation",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => getDistinctQuestions(getSolveSecondDegreeEquationByFactorisationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationFromCano.d.ts

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

package/lib/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationFromCano.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solveSecondDegreeEquationFromCano.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/equation/solveSecondDegreeEquationFromCano.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAkEF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAcnE,CAAC"}