math-exercises 3.0.2 → 3.0.4

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

@@ -1 +1 @@
-{"version":3,"file":"factorizeCanonicalForm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factorizeCanonicalForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiGF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"factorizeCanonicalForm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factorizeCanonicalForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAmBxD,CAAC"}

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

@@ -3,31 +3,40 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { Affine } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isMultiplyNode, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
 import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
-//(x-a)^2-b^2 avec b entier
-const getFactorizeCanonicalFormQuestion = () => {
-    const affine = new Affine(1, randint(-10, 10, [0]));
-    const b = randint(-10, 10, [0]);
+const getStatementNode = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(1, a);
     const statement = new SubstractNode(new SquareNode(affine.toTree()), (b ** 2).toTree());
-    const bPositive = Math.abs(b);
-    const answer = new MultiplyNode(affine.add(-bPositive).toTree(), affine.add(bPositive).toTree()).toTex();
-    const statementTex = statement.toTex();
-    const question = {
-        answer,
-        instruction: `Factoriser : $${statementTex}$`,
-        keys: ["x"],
-        answerFormat: "tex",
-        identifiers: { a: affine.b, b },
-        hint: `Utilise l'identité remarquable 
+    return statement;
+};
+const getInstruction = (identifiers) => {
+    const statementTex = getStatementNode(identifiers).toTex();
+    return `Factoriser : 
+  
+$$
+${statementTex}
+$$`;
+};
+const getHint = (identifiers) => {
+    return `Utilise l'identité remarquable 
     
 $$
 a^2 - b^2 = (a-b)(a+b)
-$$`,
-        correction: `
-On utilise l'identité remarquable 
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(1, a);
+    const bPositive = Math.abs(b);
+    const statementTex = getStatementNode(identifiers).toTex();
+    const answer = getAnswer(identifiers);
+    return `On utilise l'identité remarquable 
 
 $$
 a^2 - b^2=(a-b)(a+b)
@@ -36,18 +45,39 @@ $$
 en prenant $a=${affine.toTex()}$ et $b=${bPositive}$ : 
 
 ${alignTex([
-            [
-                statementTex,
-                "=",
-                new SubstractNode(new SquareNode(affine.toTree()), new SquareNode(bPositive.toTree())).toTex(),
-            ],
-            [
-                "",
-                "=",
-                new MultiplyNode(new AddNode(affine.toTree(), (-bPositive).toTree()), new AddNode(affine.toTree(), bPositive.toTree())).toTex(),
-            ],
-            ["", "=", answer],
-        ])}`,
+        [
+            statementTex,
+            "=",
+            new SubstractNode(new SquareNode(affine.toTree()), new SquareNode(bPositive.toTree())).toTex(),
+        ],
+        [
+            "",
+            "=",
+            new MultiplyNode(new AddNode(affine.toTree(), (-bPositive).toTree()), new AddNode(affine.toTree(), bPositive.toTree())).toTex(),
+        ],
+        ["", "=", answer],
+    ])}`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(1, a);
+    const bPositive = Math.abs(b);
+    const answer = new MultiplyNode(affine.add(-bPositive).toTree(), affine.add(bPositive).toTree()).toTex();
+    return answer;
+};
+//(x-a)^2-b^2 avec b entier
+const getFactorizeCanonicalFormQuestion = () => {
+    const affine = new Affine(1, randint(-10, 10, [0]));
+    const b = randint(-10, 10, [0]);
+    const identifiers = { a: affine.b, b };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -61,11 +91,27 @@ const getPropositions = (n, { answer, a, b }) => {
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, a, b }) => {
-    const affine = new Affine(1, a);
-    const bPositive = Math.abs(b);
-    const answerTree = new MultiplyNode(affine.add(-bPositive).toTree(), affine.add(bPositive).toTree());
-    return answerTree.toAllValidTexs().includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        if (!isMultiplyNode(parsed))
+            return false;
+        const simp = parsed.simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        });
+        const answerSimp = getStatementNode(identifiers).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        // const simp = parsed.simplify({});
+        return simp.toTex() === answerSimp.toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const factorizeCanonicalForm = {
     id: "factorizeCanonicalForm",
@@ -81,4 +127,8 @@ export const factorizeCanonicalForm = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
 };

package/lib/exercises/math/functions/affines/affineExpressionFromTwoImages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affineExpressionFromTwoImages.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineExpressionFromTwoImages.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA+IF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAgB/D,CAAC"}
+{"version":3,"file":"affineExpressionFromTwoImages.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineExpressionFromTwoImages.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAgIF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAgB/D,CAAC"}

package/lib/exercises/math/functions/affines/affineExpressionFromTwoImages.js

@@ -91,7 +91,7 @@ const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { xA, xB, yA, yB }) => {
+const isAnswerValid = (ans, { answer, xA, xB, yA, yB }) => {
     try {
         const parsed = parseAlgebraic(ans);
         if (!parsed)
@@ -101,27 +101,13 @@ const isAnswerValid = (ans, { xA, xB, yA, yB }) => {
             towardsDistribute: true,
             forbidFactorize: true,
             forceDistributeFractions: true,
+            decimalToFractions: true,
         })
-            .toTex() === ans);
+            .toTex() === answer);
     }
     catch (err) {
         return handleVEAError(err);
     }
-    // const a = new Rational(yB - yA, xB - xA).simplify().toTree();
-    // //yA = axA+b donc b = yA-axA
-    // const b = new SubstractNode(
-    //   yA.toTree(),
-    //   new MultiplyNode(a, xA.toTree()),
-    // ).simplify();
-    // const answer = new AddNode(new MultiplyNode(a, new VariableNode("x")), b, {
-    //   allowFractionToDecimal: true,
-    // }).simplify({
-    //   forceDistributeFractions: true,
-    //   towardsDistribute: true,
-    //   forbidFactorize: true,
-    // });
-    // const texs = answer.toAllValidTexs();
-    // return texs.includes(ans);
 };
 export const affineExpressionFromTwoImages = {
     id: "affineExpressionFromTwoImages",

package/lib/exercises/math/functions/affines/leadingCoeffAndOriginOrdinate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"leadingCoeffAndOriginOrdinate.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoeffAndOriginOrdinate.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AA4DF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}
+{"version":3,"file":"leadingCoeffAndOriginOrdinate.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoeffAndOriginOrdinate.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAyFF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAiB/D,CAAC"}

package/lib/exercises/math/functions/affines/leadingCoeffAndOriginOrdinate.js

@@ -1,17 +1,60 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getHint = (identifiers) => {
+    return `Dans l'expression algébrique d'une fonction affine : 
+  
+$$
+f(x) = ax+b
+$$
+
+le coefficient directeur est $a$ et l'ordonnée à l'origine est $b$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, isAskingA } = identifiers;
+    return `Dans l'expression algébrique d'une fonction affine : 
+  
+$$
+f(x) = ax+b
+$$
+
+le coefficient directeur est $a$ et l'ordonnée à l'origine est $b$.
+
+Ici, on a $a = ${a}$ et $b = ${b}$.
+
+${isAskingA
+        ? `Le coefficient directeur est donc $${a}$.`
+        : `L'ordonnée à l'origine est donc $${b}$.`}
+`;
+};
+const getInstruction = (identifiers) => {
+    const { a, b, isAskingA } = identifiers;
+    const f = new Affine(a, b);
+    return `Soit la fonction affine $f(x)=${f.toTex()}$. 
+
+${isAskingA
+        ? `Déterminer la valeur du coefficient directeur.`
+        : `Déterminer la valeur de l'ordonnée à l'origine.`}`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, isAskingA } = identifiers;
+    const correctAnwer = isAskingA ? a : b;
+    return correctAnwer.frenchify();
+};
 const getLeadingCoeffAndOriginOrdinateQuestion = () => {
-    const exercise = generateExercise();
-    const isAskingA = +exercise.correctAnwer === exercise.f.a ? true : false;
+    const isAskingA = coinFlip();
+    const f = AffineConstructor.random();
+    const identifiers = { a: f.a, b: f.b, isAskingA };
     const question = {
-        answer: exercise.correctAnwer,
-        instruction: exercise.instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { a: exercise.f.a, b: exercise.f.b, isAskingA },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -31,28 +74,19 @@ const getPropositions = (n, { answer, a, b, isAskingA }) => {
 const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
-const generateExercise = () => {
-    const flip = coinFlip();
-    const f = AffineConstructor.random();
-    const instruction = `Soit la fonction affine $f(x)=${f.toTex()}$. ${flip
-        ? `Déterminer la valeur du coefficient directeur.`
-        : `Déterminer la valeur de l'ordonnée à l'origine.`}`;
-    return {
-        instruction,
-        correctAnwer: flip ? f.a + "" : f.b + "",
-        f,
-    };
-};
 export const leadingCoeffAndOriginOrdinate = {
     id: "leadingCoeffAndOriginOrdinate",
     label: "Identifier le coefficient directeur ou l'ordonnée à l'origine d'une fonction affine",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Fonctions affines"],
     generator: (nb) => getDistinctQuestions(getLeadingCoeffAndOriginOrdinateQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

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

@@ -1,11 +1,15 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
-    rand: boolean;
-    poly1: number[];
-    poly2: number[];
-    xValue: number;
-    flip: boolean;
+    xValue: NodeIdentifiers;
+    polynomeCoeffs: NodeIdentifiers[];
+    imageSyntaxText: boolean;
 };
-export declare const imageFunction: Exercise<Identifiers>;
+type Options = {
+    functionType: string[];
+    coeffsType: string[];
+    xType: string[];
+};
+export declare const imageFunction: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=imageFunction.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"imageFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAqGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}
+{"version":3,"file":"imageFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IAOjB,MAAM,EAAE,eAAe,CAAC;IACxB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAoLF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AA4BF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBxD,CAAC"}

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

@@ -1,92 +1,149 @@
-import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { GeneralPolynomial, } from "../../../../math/polynomials/generalPolynomial.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.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 getInstruction = (identifiers) => {
-    const { rand, poly1, poly2, xValue, flip } = identifiers;
-    const polynome1 = new Polynomial(poly1);
-    const polynome2 = new Polynomial(poly2);
-    const statement = `Soit $f(x) = ${(rand ? polynome1 : polynome2)
-        .toTree()
-        .toTex()}$. 
+const rebuildIdentifiers = (oldIdentifiers) => {
+    const polynomeCoeffsNumbers = oldIdentifiers.rand
+        ? oldIdentifiers.poly1
+        : oldIdentifiers.poly2;
+    const polynomeCoeffs = polynomeCoeffsNumbers.map((n) => n.toTree().toIdentifiers());
+    return {
+        imageSyntaxText: oldIdentifiers.flip ?? true,
+        xValue: oldIdentifiers.xValue.toTree().toIdentifiers(),
+        polynomeCoeffs,
+    };
+};
+const getInstruction = (identifiers, opts) => {
+    // const { rand, poly1, poly2, xValue, flip } = identifiers;
+    // const polynome1 = new Polynomial(poly1);
+    // const polynome2 = new Polynomial(poly2);
+    const { xValue, polynomeCoeffs, imageSyntaxText } = identifiers;
+    const xValueTex = reifyAlgebraic(xValue).toTex();
+    const coeffsNode = polynomeCoeffs.map((coeff) => reifyAlgebraic(coeff));
+    const polynome = new GeneralPolynomial(coeffsNode);
+    const statement = `Soit $f(x) = ${polynome.toTree().toTex()}$. 
     
-Calculer ${flip ? `l'image de $${xValue}$ par $f$.` : `$f(${xValue})$.`}`;
+Calculer ${imageSyntaxText
+        ? `l'image de $${xValueTex}$ par $f$.`
+        : `$f\\left(${xValueTex}\\right)$.`}`;
     return statement;
 };
-const getAnswer = (identifiers) => {
-    const { rand, poly1, poly2, xValue } = identifiers;
-    const polynome1 = new Polynomial(poly1);
-    const polynome2 = new Polynomial(poly2);
-    const answer = rand
-        ? polynome1.calculate(xValue) + ""
-        : polynome2.calculate(xValue) + "";
+const getAnswer = (identifiers, opts) => {
+    const { xValue, polynomeCoeffs, imageSyntaxText } = identifiers;
+    const xValueNode = reifyAlgebraic(xValue);
+    const coeffsNode = polynomeCoeffs.map((coeff) => reifyAlgebraic(coeff));
+    const polynome = new GeneralPolynomial(coeffsNode);
+    const answer = polynome
+        .toTree()
+        .toDetailedEvaluation({ x: xValueNode })
+        .simplify()
+        .toTex();
     return answer;
 };
-const getHint = (identifiers) => {
-    return `Remplace $x$ par $${identifiers.xValue}$ dans l'expression de $f$.`;
+const getHint = (identifiers, opts) => {
+    const { xValue, polynomeCoeffs, imageSyntaxText } = identifiers;
+    const xValueTex = reifyAlgebraic(xValue).toTex();
+    return `Remplace $x$ par $${xValueTex}$ dans l'expression de $f$.`;
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, opts) => {
+    const { xValue, polynomeCoeffs, imageSyntaxText } = identifiers;
+    const xValueNode = reifyAlgebraic(xValue);
+    const xValueTex = xValueNode.toTex();
+    const coeffsNode = polynomeCoeffs.map((coeff) => reifyAlgebraic(coeff));
+    const polynome = new GeneralPolynomial(coeffsNode).toTree();
     const answer = getAnswer(identifiers);
-    const { rand, poly1, poly2, xValue, flip } = identifiers;
-    const polynome1 = new Polynomial(poly1).toTree();
-    const polynome2 = new Polynomial(poly2).toTree();
-    return `On remplace $x$ par $${identifiers.xValue}$ dans l'expression de $f$ : 
+    return `On remplace $x$ par $${xValueTex}$ dans l'expression de $f$ : 
   
 ${alignTex([
         [
-            `f\\left(${identifiers.xValue}\\right)`,
+            `f\\left(${xValueTex}\\right)`,
             "=",
-            rand
-                ? polynome1.toDetailedEvaluation({ x: xValue.toTree() }).toTex()
-                : polynome2.toDetailedEvaluation({ x: xValue.toTree() }).toTex(),
+            polynome.toDetailedEvaluation({ x: xValueNode }).toTex(),
         ],
         ["", "=", answer],
     ])}`;
 };
-const getImageFunction = () => {
-    const rand = coinFlip();
-    const polynome1 = new Polynomial([randint(-9, 10), randint(-5, 6, [0])]);
-    const polynome2 = new Polynomial([
-        randint(-9, 10),
-        randint(-9, 10),
-        randint(-4, 5, [0]),
-    ]);
-    const xValue = randint(-9, 10);
-    const flip = coinFlip();
+const getStartStatement = (identifiers) => {
+    const { xValue, polynomeCoeffs, imageSyntaxText } = identifiers;
+    const xValueTex = reifyAlgebraic(xValue).toTex();
+    return `f\\left(${xValueTex}\\right)`;
+};
+const getImageFunction = (opts) => {
+    // xValue: NodeIdentifiers;
+    // polynomeCoeffs: NodeIdentifiers[]; // [0] is the constant term
+    // imageSyntaxText: boolean;
+    const functionType = opts?.functionType ?? ["Affine", "Trinôme"];
+    const allowTrinom = functionType.includes("Trinôme");
+    const allowAffine = functionType.includes("Affine");
+    const isTrinom = !allowTrinom ? false : allowAffine ? coinFlip() : true;
+    const imageSyntaxText = coinFlip();
+    const xType = random(opts?.xType ?? ["Entier"]);
+    const coeffsTypes = opts?.coeffsType ?? ["Entiers"];
+    const buildNb = (type, excludes = []) => {
+        switch (type) {
+            case "Entier":
+            case "Entiers":
+                return randint(-9, 10, excludes).toTree().toIdentifiers();
+            case "Décimal":
+            case "Décimaux":
+                return randfloat(-9, 10, 1, excludes).toTree().toIdentifiers();
+            case "Rationnel":
+            case "Rationnels":
+            default:
+                return RationalConstructor.randomIrreductible()
+                    .toTree()
+                    .toIdentifiers();
+        }
+    };
+    const xValue = buildNb(xType);
+    const coeffs = isTrinom
+        ? [
+            buildNb(random(coeffsTypes)),
+            buildNb(random(coeffsTypes)),
+            buildNb(random(coeffsTypes), [0]),
+        ]
+        : [buildNb(random(coeffsTypes)), buildNb(random(coeffsTypes), [0])];
     const identifiers = {
-        poly1: polynome1.coefficients,
-        poly2: polynome2.coefficients,
-        rand,
+        polynomeCoeffs: coeffs,
+        imageSyntaxText,
         xValue,
-        flip,
     };
     const question = {
-        instruction: getInstruction(identifiers),
-        startStatement: `f(${xValue})`,
-        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers, opts),
         keys: [],
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
         answerFormat: "tex",
         identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, ...identifiers }, opts) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    const { xValue, polynomeCoeffs } = identifiers;
+    const xValueNode = reifyAlgebraic(xValue);
+    const coeffsNode = polynomeCoeffs.map((coeff) => reifyAlgebraic(coeff));
+    const polynome = new GeneralPolynomial(coeffsNode).toTree();
     while (propositions.length < n) {
-        const wrongAnswer = Number(answer) + randint(-10, 11, [0]);
-        tryToAddWrongProp(propositions, wrongAnswer + "");
+        const wrongX = add(xValueNode, randint(-3, 4, [0]).toTree()).simplify();
+        tryToAddWrongProp(propositions, polynome.toDetailedEvaluation({ x: wrongX }).simplify().toTex());
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer }, opts) => {
     try {
         const parsed = parseAlgebraic(ans);
         if (!parsed)
@@ -97,14 +154,38 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
+const options = [
+    {
+        id: "functionType",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Affine", "Trinôme"],
+        values: ["Affine", "Trinôme"],
+    },
+    {
+        id: "coeffsType",
+        label: "Type des coefficients",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Entiers"],
+        values: ["Entiers", "Décimaux", "Rationnels"],
+    },
+    {
+        id: "xType",
+        label: "Type du nombre $x$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Entier"],
+        values: ["Entier", "Décimal", "Rationnel"],
+    },
+];
 export const imageFunction = {
     id: "imageFunction",
     connector: "=",
     label: "Calcul d'image par une fonction",
-    levels: ["3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
-    sections: ["Fonctions"],
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getImageFunction, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getImageFunction(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -115,4 +196,6 @@ export const imageFunction = {
     getHint,
     hasHintAndCorrection: true,
     getInstruction,
+    options,
+    rebuildIdentifiers,
 };

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

@@ -1,11 +1,17 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
-    /**old */
-    isSpline: boolean;
-    splinePoints: number[][];
+    /**very old */
+    /** old */
+    /** new */
+    functionType: string;
     x: number;
     y: number;
+    wrongY: number;
+    otherPoints: number[][];
 };
-export declare const imageFunctionGeogebra: Exercise<Identifiers>;
+type Options = {
+    curveTypes: string[];
+};
+export declare const imageFunctionGeogebra: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=imageFunctionGeogebra.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"imageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,SAAS;IAIT,QAAQ,EAAE,OAAO,CAAC;IAElB,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwEF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"imageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,cAAc;IAMd,UAAU;IAMV,UAAU;IACV,YAAY,EAAE,MAAM,CAAC;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;CACzB,CAAC;AAwOF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBhE,CAAC"}