math-exercises 3.0.57 → 3.0.58

package/lib/exercises/math/calcul/operations/operationsPriorities.d.ts

@@ -6,12 +6,14 @@
  * a/b ± c*d
  */
 import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
     type: number;
     a: number;
     b: number;
     c: number;
     d: number | undefined;
+    statementIds: NodeIdentifiers;
 };
 export declare const operationsPriorities: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/calcul/operations/operationsPriorities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operationsPriorities.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/operationsPriorities.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AAkJF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}
+{"version":3,"file":"operationsPriorities.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/operationsPriorities.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEtB,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA6JF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAYtD,CAAC"}

package/lib/exercises/math/calcul/operations/operationsPriorities.js

@@ -7,17 +7,49 @@
  */
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { DivideNode } from "../../../../tree/nodes/operators/divideNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getStartStatement = (identifiers) => {
+    const { statementIds } = identifiers;
+    return reifyAlgebraic(statementIds).toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer : 
+  
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { statementIds } = identifiers;
+    return reifyAlgebraic(statementIds).simplify().toTex();
+};
+const getHint = (identifiers) => {
+    return ``;
+};
+const getCorrection = (identifiers) => {
+    return ``;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
 const getPriorityQuestions = () => {
     const type = randint(1, 9);
-    let startStatement = "";
-    let answer = "";
     let a, b, c, d;
     let statement;
     switch (type) {
@@ -30,8 +62,6 @@ const getPriorityQuestions = () => {
                 : //a*b middle
                     new AddNode(new AddNode(new NumberNode(c), new MultiplyNode(new NumberNode(a), new NumberNode(b))), new NumberNode(d));
             statement = statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a * b + c + d).toString();
             break;
         case 2: // a/b ±c±d
             [b, c, d] = [1, 2, 3].map((el) => randint(-10, 11, [0]));
@@ -42,67 +72,50 @@ const getPriorityQuestions = () => {
                 : //a/b middle
                     new AddNode(new AddNode(new NumberNode(c), new DivideNode(new NumberNode(a), new NumberNode(b))), new NumberNode(d));
             statement = statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a / b + c + d).toString();
             break;
         case 3: // a*b ± c*d
             [a, b, c, d] = [1, 2, 3, 4].map((el) => randint(-10, 11));
             statement = new AddNode(new MultiplyNode(new NumberNode(a), new NumberNode(b)), new MultiplyNode(new NumberNode(c), new NumberNode(d)));
-            startStatement = statement.toTex();
-            answer = (a * b + c * d).toString();
             break;
         case 4: // a*b ± c/d
             [a, b] = [1, 2].map((el) => randint(-10, 11));
             d = randint(-10, 11, [0]);
             c = d * randint(0, 11);
             statement = new AddNode(new MultiplyNode(new NumberNode(a), new NumberNode(b)), new DivideNode(new NumberNode(c), new NumberNode(d)));
-            statement = statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a * b + c / d).toString();
             break;
         case 5: // a/b ± c/d
             [b, d] = [1, 2].map((el) => randint(-10, 11, [0]));
             a = b * randint(0, 11);
             c = d * randint(0, 11);
             statement = new AddNode(new DivideNode(new NumberNode(a), new NumberNode(b)), new DivideNode(new NumberNode(c), new NumberNode(d)));
-            startStatement = statement.toTex();
-            answer = (a / b + c / d).toString();
             break;
         case 6: // a*b*c ± d
             [a, b, c, d] = [1, 2, 3, 4].map((el) => randint(-10, 11, [0]));
             statement = new AddNode(new MultiplyNode(new MultiplyNode(new NumberNode(a), new NumberNode(b)), new NumberNode(c)), new NumberNode(d));
-            statement = statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a * b * c + d).toString();
             break;
         case 7: //a/b*c et c*a/b
             b = randint(2, 10);
             a = b * randint(2, 10);
             c = randint(2, 10);
             statement = new MultiplyNode(new DivideNode(a.toTree(), b.toTree()), c.toTree()).shuffle();
-            answer = ((a / b) * c).frenchify();
-            startStatement = statement.toTex();
             break;
         case 8: //a+-b+-c
+        default:
             a = randint(-15, 15);
             b = randint(-10, 10);
             c = b > 0 ? randint(-10, 0) : randint(-10, 10);
             statement = new AddNode(new AddNode(a.toTree(), b.toTree()), c.toTree());
-            answer = (a + b + c).frenchify();
-            startStatement = statement.toTex();
             break;
-        default:
-            throw Error("impossible");
     }
-    const question = {
-        instruction: `Calculer : $${startStatement}$`,
-        startStatement,
-        answer,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { type, a, b, c, d },
+    const identifiers = {
+        type,
+        a,
+        b,
+        c,
+        d,
+        statementIds: statement.toIdentifiers(),
     };
-    return question;
+    return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -112,17 +125,13 @@ const getPropositions = (n, { answer }) => {
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (studentAns, { answer }) => {
-    const answerTree = new NumberNode(Number(answer));
-    const texs = answerTree.toAllValidTexs();
-    return texs.includes(studentAns);
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
 };
 export const operationsPriorities = {
     id: "operationsPriorities",
     connector: "=",
     label: "Priorités opératoires",
-    levels: ["5ème", "4ème"],
-    sections: ["Calculs"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getPriorityQuestions, nb),
     qcmTimer: 60,
@@ -130,4 +139,5 @@ export const operationsPriorities = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/calculLitteral/equation/multiplicationEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8HF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}
+{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8HF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

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

@@ -123,8 +123,5 @@ export const multiplicationEquation = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
-    getInstruction,
-    getAnswer,
-    getCorrection,
-    getHint,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/calculLitteral/factorisation/facto1.d.ts

@@ -0,0 +1,16 @@
+/**
+ *  type (ax+b)(cx+d) ± (ax+b)(ex+f)
+ */
+import { Exercise } from "../../../../exercises/exercise.js";
+/**
+ * facto du type (ax+b)(cx+d) ± (ax+b)(ex+f)
+ * b, d, f non nuls
+ */
+type Identifiers = {
+    affinesCoeffs: number[][];
+    operation: string;
+    affinesOrder: number[];
+};
+export declare const factoType1Exercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=facto1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"facto1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/facto1.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAwBrC;;;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;AA4NF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

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

@@ -0,0 +1,184 @@
+/**
+ *  type (ax+b)(cx+d) ± (ax+b)(ex+f)
+ */
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+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";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getStatementNode = (identifiers) => {
+    const { affinesCoeffs, operation, affinesOrder } = identifiers;
+    const affines = affinesCoeffs.map((coeffs) => new Affine(coeffs[1], coeffs[0]));
+    const order = [[], []];
+    order[0][affinesOrder[0]] = affines[1];
+    order[1][affinesOrder[1]] = affines[2];
+    order[0][1 - affinesOrder[0]] = affines[0];
+    order[1][1 - affinesOrder[1]] = affines[0];
+    const statementTree = (operation === "add" ? add : substract)(new MultiplyNode(order[0][0].toTree(), order[0][1].toTree()), new MultiplyNode(order[1][0].toTree(), order[1][1].toTree()));
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    const { affinesCoeffs, operation } = identifiers;
+    return `Factoriser et réduire : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { affinesCoeffs, operation } = identifiers;
+    const factor = new Affine(affinesCoeffs[0][1], affinesCoeffs[0][0]);
+    const affine2 = new Affine(affinesCoeffs[2][1], affinesCoeffs[2][0]);
+    const affine1 = new Affine(affinesCoeffs[1][1], affinesCoeffs[1][0]);
+    const secondTerm = (operation === "add"
+        ? add(affine1.toTree(), affine2.toTree())
+        : substract(affine1.toTree(), affine2.toTree())).simplify({ forbidFactorize: true, towardsDistribute: true });
+    const sol = multiply(factor.toTree(), secondTerm).simplify({});
+    return sol;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getFactoType1Question = () => {
+    const a = randint(-9, 10, [0]);
+    const b = randint(-9, 10, [0]);
+    let operation = random(["add", "substract"]);
+    let c, d;
+    let e, f;
+    do {
+        c = randint(-9, 10, [0]);
+        d = randint(-9, 10, [0]);
+        e = randint(-9, 10, [0]);
+        f = randint(-9, 10, [0]);
+    } while (c / a === d / b ||
+        e / a === f / b ||
+        //éviter un multiple +-1
+        (operation === "add" && f === -d && Math.abs(e + c) === 1) ||
+        (operation === "substract" && f === d && Math.abs(e - c) === 1));
+    const identifiers = {
+        affinesCoeffs: [
+            [a, b],
+            [c, d],
+            [e, f],
+        ],
+        operation,
+        affinesOrder: [random([0, 1]), random([0, 1])],
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStatementNode(identifiers).toTex(),
+        answer: getAnswer(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getHint = (identifiers) => {
+    return `On repère le facteur commun dans les deux termes de l'expression. 
+  
+On utilise ensuite la propriété : 
+
+$$
+k\\times a + k \\times b = k\\times (a+b)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { affinesCoeffs, operation, affinesOrder } = identifiers;
+    const affines = affinesCoeffs.map((coeffs) => new Affine(coeffs[1], coeffs[0]));
+    const order = [[], []];
+    order[0][affinesOrder[0]] = affines[1];
+    order[1][affinesOrder[1]] = affines[2];
+    order[0][1 - affinesOrder[0]] = affines[0];
+    order[1][1 - affinesOrder[1]] = affines[0];
+    const statementTree = (operation === "add" ? add : substract)(new MultiplyNode(order[0][0].toTree(), order[0][1].toTree()), new MultiplyNode(order[1][0].toTree(), order[1][1].toTree()));
+    return `On repère que le facteur commun dans les deux termes est : 
+  
+$$
+${affines[0].toTree().toTex()}
+$$
+
+On a donc : 
+
+${alignTex([
+        ["", statementTree.toTex()],
+        [
+            "=",
+            multiply(affines[0].toTree(), (operation === "add" ? add : substract)(affines[1].toTree(), affines[2].toTree())).toTex(),
+        ],
+        ["=", getAnswer(identifiers)],
+    ])}`;
+};
+const getPropositions = (n, { answer, affinesCoeffs, operation }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affines = affinesCoeffs.map((coeffs) => new Affine(coeffs[1], coeffs[0]));
+    tryToAddWrongProp(propositions, new MultiplyNode(affines[0].toTree(), affines[1]
+        .add(operation !== "add" ? affines[2] : affines[2].opposite())
+        .toTree()).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode(affines[1].toTree(), affines[0]
+        .add(operation === "add" ? affines[2] : affines[2].opposite())
+        .toTree()).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode(affines[2].toTree(), affines[0]
+        .add(operation === "add" ? affines[2] : affines[2].opposite())
+        .toTree()).toTex());
+    while (propositions.length < n) {
+        const wrongAnswer = new MultiplyNode(affines[0].toTree(), affines[1].add(AffineConstructor.differentRandoms(1)[0]).toTree());
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        if (answer !== "0" &&
+            !isMultiplyNode(parsed) &&
+            !isSquareNode(parsed) &&
+            !isPowerNode(parsed))
+            return false;
+        const simp = parsed.simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        });
+        const answerSimp = getAnswerNode(identifiers).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        // const simp = parsed.simplify({});
+        return simp.toTex() === answerSimp.toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const factoType1Exercise = {
+    id: "facto1",
+    connector: "=",
+    isSingleStep: false,
+    label: "Factorisation du type $(ax+b)(cx+d) \\pm (ax+b)(ex+f)$",
+    generator: (nb) => getDistinctQuestions(getFactoType1Question, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/factorisation/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./factoIdRmq1.js";
 export * from "./factoIdRmq2.js";
 export * from "./factoIdRmq3.js";
-export * from "./factoType1Exercise.js";
+export * from "./facto1.js";
 export * from "./factorizeCanonicalForm.js";
 export * from "./factorizeCanonicalFormWithSqrt.js";
 export * from "./factoType2.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}

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

@@ -1,7 +1,7 @@
 export * from "./factoIdRmq1.js";
 export * from "./factoIdRmq2.js";
 export * from "./factoIdRmq3.js";
-export * from "./factoType1Exercise.js";
+export * from "./facto1.js";
 export * from "./factorizeCanonicalForm.js";
 export * from "./factorizeCanonicalFormWithSqrt.js";
 export * from "./factoType2.js";

package/lib/exercises/math/derivation/convexity/convexityQuadrinomials.d.ts

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

package/lib/exercises/math/derivation/convexity/convexityQuadrinomials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convexityQuadrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/convexity/convexityQuadrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAqIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/derivation/convexity/convexityQuadrinomials.js

@@ -0,0 +1,102 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { intervalParser } from "../../../../tree/parsers/intervalParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { askConvex, quadcoeffs } = identifiers;
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const questionType = askConvex ? "convexe" : "concave";
+    return `Soit la fonction $f$ définie par : 
+  
+$$
+f(x) = ${quadrinomial.toTex()}
+$$
+
+Sur quelle intervalle $f$ est-elle ${questionType} ?`;
+};
+const getAnswer = (identifiers) => {
+    const { askConvex, quadcoeffs } = identifiers;
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const secondderivative = quadrinomial.derivate().derivate();
+    const seconddcoeffs = secondderivative.coefficients;
+    const inflexionPoint = new FractionNode(new MultiplyNode(seconddcoeffs[0].toTree(), new NumberNode(-1)), seconddcoeffs[1].toTree()).simplify();
+    let interval;
+    if (askConvex) {
+        interval =
+            quadcoeffs[3] > 0
+                ? new IntervalNode(inflexionPoint, PlusInfinityNode, ClosureType.OO).toTex()
+                : new IntervalNode(MinusInfinityNode, inflexionPoint, ClosureType.OO).toTex();
+    }
+    else {
+        interval =
+            quadcoeffs[3] <= 0
+                ? new IntervalNode(inflexionPoint, PlusInfinityNode, ClosureType.OO).toTex()
+                : new IntervalNode(MinusInfinityNode, inflexionPoint, ClosureType.OO).toTex();
+    }
+    return interval;
+};
+const getConvexityQuadrinomialsQuestion = () => {
+    const quadrinomial = PolynomialConstructor.randomWithOrder(3);
+    const quadcoeffs = quadrinomial.coefficients;
+    const askConvex = coinFlip();
+    const identifiers = { askConvex, quadcoeffs };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["rbracket", "lbracket", "semicolon", "infty", "reals"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, quadcoeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "tex");
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const secondderivative = quadrinomial.derivate().derivate();
+    const seconddcoeffs = secondderivative.coefficients;
+    const inflexionPoint = new FractionNode(new MultiplyNode(seconddcoeffs[0].toTree(), new NumberNode(-1)), seconddcoeffs[1].toTree()).simplify();
+    const wrongInterval1 = new IntervalNode(inflexionPoint, PlusInfinityNode, ClosureType.OO).toTex();
+    const wrongInterval2 = new IntervalNode(MinusInfinityNode, inflexionPoint, ClosureType.OO).toTex();
+    const wrongInterval3 = new IntervalNode(MinusInfinityNode, PlusInfinityNode, ClosureType.OO).toTex();
+    const wrongInterval4 = new IntervalNode(new NumberNode(randint(-1, 2)), PlusInfinityNode, ClosureType.FO).toTex();
+    tryToAddWrongProp(propositions, wrongInterval1);
+    tryToAddWrongProp(propositions, wrongInterval2);
+    tryToAddWrongProp(propositions, wrongInterval3);
+    tryToAddWrongProp(propositions, wrongInterval4);
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, askConvex, quadcoeffs }) => {
+    try {
+        const parsed = intervalParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const convexityQuadrinomials = {
+    id: "convexityQuadrinomials",
+    label: "Convexité des fonctions polynomiales de degré $3$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getConvexityQuadrinomialsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    answerType: "QCU",
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+};

package/lib/exercises/math/derivation/convexity/convexityTrinomials.d.ts

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

package/lib/exercises/math/derivation/convexity/convexityTrinomials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convexityTrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/convexity/convexityTrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA0CF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}

package/lib/exercises/math/derivation/convexity/convexityTrinomials.js

@@ -0,0 +1,52 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+const getInstruction = (identifiers) => {
+    const trinom = TrinomConstructor.fromCoeffs(identifiers.coeffs);
+    return `Soit la fonction $f$ définie par : 
+  
+$$
+f(x) = ${trinom.toTex()}
+$$
+
+Sur $\\mathbb{R}$, $f$ est :`;
+};
+const getAnswer = (identifiers) => {
+    const trinom = TrinomConstructor.fromCoeffs(identifiers.coeffs);
+    const isConvex = trinom.a > 0 ? "Convexe" : "Concave";
+    return isConvex;
+};
+const getConvexityTrinomialsQuestion = () => {
+    const trinom = TrinomConstructor.random();
+    const identifiers = { coeffs: trinom.coefficients };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Concave", "raw");
+    tryToAddWrongProp(propositions, "Convexe", "raw");
+    tryToAddWrongProp(propositions, "Ni concave, ni convexe", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+export const convexityTrinomials = {
+    id: "convexityTrinomials",
+    label: "Déterminer la convexité d'un trinôme",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getConvexityTrinomialsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    answerType: "QCU",
+    getPropositions,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+};

package/lib/exercises/math/derivation/convexity/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./convexityTrinomials.js";
+export * from "./convexityQuadrinomials.js";
+export * from "./inflexionPointQuadrinomials.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/convexity/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/convexity/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC"}

package/lib/exercises/math/derivation/convexity/index.js

@@ -0,0 +1,3 @@
+export * from "./convexityTrinomials.js";
+export * from "./convexityQuadrinomials.js";
+export * from "./inflexionPointQuadrinomials.js";

package/lib/exercises/math/derivation/convexity/inflexionPointQuadrinomials.d.ts

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

package/lib/exercises/math/derivation/convexity/inflexionPointQuadrinomials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inflexionPointQuadrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/convexity/inflexionPointQuadrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAsJF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAkB7D,CAAC"}