math-exercises 3.0.3 → 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"}

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

@@ -1,84 +1,225 @@
-import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randomColor } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { Lagrange } from "../../../../geogebra/lagrange.js";
 import { Spline } from "../../../../geogebra/spline.js";
+import { Line } from "../../../../math/geometry/line.js";
+import { Parabola } from "../../../../math/geometry/parabola.js";
 import { Point } from "../../../../math/geometry/point.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { round } from "../../../../math/utils/round.js";
 import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
 import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
-import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getImageFunctionGeogebra = () => {
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds.splinePoints?.length) {
+        const x = oldIds.x;
+        const wrongY = oldIds.splinePoints.find((p) => p[1] === x && Math.floor(p[0]) === p[0]);
+        if (!wrongY && wrongY !== 0)
+            throw new Error("no wrong y");
+        const otherPoints = oldIds.splinePoints.filter((p) => p[0] !== x && p[0] !== wrongY);
+        return {
+            functionType: oldIds.isSpline ? "Tracés" : "Polynômes",
+            x: oldIds.x,
+            y: oldIds.y,
+            wrongY,
+            otherPoints,
+        };
+    }
+    else if (oldIds.poly1?.length || oldIds.poly2?.length) {
+        const x = oldIds.xValue;
+        const polynome = new Polynomial(oldIds.rand ? oldIds.poly1 : oldIds.poly2);
+        const y = polynome.calculate(x);
+        const wrongY = oldIds.rand
+            ? Math.floor((x - oldIds.poly1[0]) / oldIds.poly1[1])
+            : polynome.calculate(x + 2);
+        return {
+            functionType: oldIds.rand ? "Droites" : "Paraboles",
+            x: oldIds.x,
+            y: oldIds.y,
+            wrongY,
+            otherPoints: oldIds.rand ? [] : [[x + 1, polynome.calculate(x + 1)]],
+        };
+    }
+    else
+        return oldIds;
+};
+const getInstruction = (identifiers) => {
+    const { x } = identifiers;
+    return `Quelle est l'image de $${x}$ par la fonction $f$ représentée ci dessous ?`;
+};
+const getAnswer = (identifiers) => {
+    const { y } = identifiers;
+    return y.frenchify();
+};
+const getGGBOptions = (identifiers) => {
+    const { functionType, otherPoints, wrongY, x, y } = identifiers;
+    const allPoints = [...otherPoints, [x, y], [wrongY, x]].sort((a, b) => a[0] - b[0]);
+    console.log(allPoints);
+    let commands = [];
+    switch (functionType) {
+        case "Droites":
+            const line = new Line(new Point("A", allPoints[0][0], allPoints[0][1]), new Point("B", allPoints[1][0], allPoints[1][1]));
+            commands = line.toGGBCommands(false);
+            break;
+        case "Tracés":
+            //! on devrait plutôt build a spline et renvoyer toGgbCommand
+            commands = [
+                `S = Spline(${allPoints
+                    .map((point) => `(${point[0]},${point[1]})`)
+                    .join(",")})`,
+                "SetFixed(S, true)",
+                `SetColor(S, "${randomColor()}")`,
+            ];
+            break;
+        case "Paraboles":
+            const parabola = new Parabola([
+                new Point("A", allPoints[0][0], allPoints[0][1]),
+                new Point("B", allPoints[1][0], allPoints[1][1]),
+                new Point("C", allPoints[2][0], allPoints[2][1]),
+            ]);
+            commands = parabola.toGGBCommands(false);
+            break;
+        case "Polynômes":
+        default:
+            //! on devrait plutôt build a lagrange et renvoyer toGgbCommand
+            commands = [
+                `P = Polynomial(${allPoints
+                    .map((point) => `(${point[0]},${point[1]})`)
+                    .join(",")})`,
+                "SetFixed(P, true)",
+                `SetColor(P, "${randomColor()}")`,
+            ];
+            break;
+    }
+    // const spline = new (isSpline ? Spline : Lagrange)(
+    //   new IntervalNode((-10).toTree(), (10).toTree(), ClosureType.FF),
+    //   splinePoints.map((e, i) => new Point(`A_${i}`, e[0], e[1])),
+    // );
+    const ggb = new GeogebraConstructor({
+        // commands: spline.getCommands()
+        commands,
+    });
+    const xMin = allPoints[0][0];
+    const xMax = allPoints[allPoints.length - 1][0];
+    const yMin = Math.min(...allPoints.map((p) => p[1])) - 1;
+    const yMax = Math.max(...allPoints.map((p) => p[1])) + 1;
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            forceShowAxes: true,
+            xMax,
+            xMin,
+            yMax,
+            yMin,
+        }),
+    });
+};
+const getStartStatement = (identifiers) => {
+    const { x } = identifiers;
+    return `f(${x})`;
+};
+const getImageFunctionGeogebra = (opts) => {
     const x = randint(-8, 9);
     const y = randint(-8, 9);
-    const isSpline = coinFlip();
-    const spline = new (isSpline ? Spline : Lagrange)(new IntervalNode((-10).toTree(), (10).toTree(), ClosureType.FF), [
-        new Point("A", x.toTree(), y.toTree()),
-        //distractor point with ordonnée = x
-        new Point("B", (y + randint(-3, 4, [0, x - y, 10 - y, -10 - y])).toTree(), x.toTree()),
-    ]);
-    const ggb = new GeogebraConstructor({ commands: spline.getCommands() });
-    const xMin = spline.points[0][0];
-    const xMax = spline.points[spline.points.length - 1][0];
-    const yMin = Math.min(...spline.points.map((p) => p[1])) - 1;
-    const yMax = Math.max(...spline.points.map((p) => p[1])) + 1;
-    const instruction = `Quelle est l'image de $${x}$ par la fonction $f$ représentée ci dessous ?`;
+    const wrongY = y + randint(-3, 4, [0, x - y, 10 - y, -10 - y]);
+    const functionType = random(opts?.curveTypes ?? ["Tracés", "Polynômes", "Droites", "Paraboles"]);
+    let otherPoints = [];
+    switch (functionType) {
+        case "Droites":
+            //nothing to add
+            break;
+        case "Tracés":
+            const spline = new Spline(new IntervalNode((-10).toTree(), (10).toTree(), ClosureType.FF), [
+                new Point("A", x.toTree(), y.toTree()),
+                //distractor point with ordonnée = x
+                new Point("B", wrongY.toTree(), x.toTree()),
+            ]);
+            otherPoints = spline.points.filter((p) => p[0] !== x && p[0] !== wrongY);
+            break;
+        case "Paraboles":
+            //3e point au milieu de AB
+            otherPoints.push([(x + wrongY) / 2, y + randint(-3, 4, [0])]);
+            break;
+        case "Polynômes":
+            const lagrange = new Lagrange(new IntervalNode((-10).toTree(), (10).toTree(), ClosureType.FF), [
+                new Point("A", x.toTree(), y.toTree()),
+                //distractor point with ordonnée = x
+                new Point("B", wrongY.toTree(), x.toTree()),
+            ]);
+            otherPoints = lagrange.points.filter((p) => p[0] !== x && p[0] !== wrongY);
+        default:
+            break;
+    }
+    // const spline = new (isSpline ? Spline : Lagrange)(
+    //   new IntervalNode((-10).toTree(), (10).toTree(), ClosureType.FF),
+    //   [
+    //     new Point("A", x.toTree(), y.toTree()),
+    //     //distractor point with ordonnée = x
+    //     new Point("B", wrongY.toTree(), x.toTree()),
+    //   ],
+    // );
+    const identifiers = {
+        // isSpline,
+        // splinePoints: spline.points,
+        x,
+        y,
+        functionType,
+        wrongY,
+        otherPoints,
+    };
     const question = {
-        instruction,
-        startStatement: `f(${x})`,
-        answer: y.frenchify(),
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: ggb.getAdaptedCoords({
-                forceShowAxes: true,
-                xMax,
-                xMin,
-                yMax,
-                yMin,
-            }),
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: {
-            splinePoints: spline.points,
-            x,
-            y,
-            isSpline,
-        },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, splinePoints, x, y }) => {
+const getPropositions = (n, { answer, x, y, wrongY }, opts) => {
     const propositions = [];
     addValidProp(propositions, answer);
     //old questions have spline POint undefined
-    (splinePoints ?? [])
-        .filter((p) => p[1] === x)
-        .map((e) => round(e[0], 0))
-        .forEach((y) => tryToAddWrongProp(propositions, y.frenchify()));
+    tryToAddWrongProp(propositions, wrongY + "");
     while (propositions.length < n) {
         const wrongAnswer = Number(answer) + randint(-10, 11, [0]);
         tryToAddWrongProp(propositions, wrongAnswer + "");
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer }, opts) => {
     return numberVEA(ans, answer);
 };
+const options = [
+    {
+        id: "curveTypes",
+        label: "Types de courbes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Tracés", "Polynômes", "Droites", "Paraboles"],
+        values: ["Tracés", "Polynômes", "Droites", "Paraboles"],
+    },
+];
 export const imageFunctionGeogebra = {
     id: "imageFunctionGeogebra",
     connector: "=",
     label: "Lecture d'une image",
-    levels: ["3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
-    sections: ["Fonctions"],
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getImageFunctionGeogebra, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getImageFunctionGeogebra(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    options,
+    getAnswer,
+    getInstruction,
+    getGGBOptions,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/functions/cube/cubicEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cubicEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/cubicEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyCF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAe/C,CAAC"}
+{"version":3,"file":"cubicEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/cubicEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4DF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}

package/lib/exercises/math/functions/cube/cubicEquation.js

@@ -1,21 +1,41 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { equationKeys } from "../../../../exercises/utils/keys/equationKeys.js";
+import { equationVEA } from "../../../../exercises/vea/equationVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.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 getInstruction = (identifiers) => {
+    const k = identifiers.k;
+    return `Résoudre l'équation suivante : 
+  
+$$
+x^3 = ${k}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const k = identifiers.k;
+    const x = Math.cbrt(k);
+    const answer = `S=\\left\\{${x}\\right\\}`;
+    return answer;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return "";
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return "";
+// };
 const getCubicEquationQuestion = () => {
     const x = randint(-10, 11);
     const k = x ** 3;
-    const answer = `S=\\left\\{${x}\\right\\}`;
+    const identifiers = { k };
     const question = {
-        answer: answer,
-        instruction: `Résoudre l'équation suivante : $x^3 = ${k}$`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: equationKeys,
         answerFormat: "tex",
-        identifiers: { k },
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -30,18 +50,13 @@ const getPropositions = (n, { answer, k }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { k }) => {
-    const sol = Math.cbrt(k);
-    const answerTree = new EquationSolutionNode(new DiscreteSetNode([new NumberNode(sol)]));
-    const texs = answerTree.toAllValidTexs();
-    return texs.includes(ans);
+    return equationVEA(ans, Math.cbrt(k).frenchify());
 };
 export const cubicEquation = {
     id: "cubicEquation",
     connector: "\\iff",
     label: "Résoudre une équation du type $x^3 = k$",
-    levels: ["2nde", "1reESM", "1reSpé", "1reTech"],
     isSingleStep: true,
-    sections: ["Fonctions de référence", "Fonction cube", "Équations"],
     generator: (nb) => getDistinctQuestions(getCubicEquationQuestion, nb, 20),
     isAnswerValid,
     qcmTimer: 60,
@@ -49,4 +64,9 @@ export const cubicEquation = {
     maxAllowedQuestions: 20,
     getPropositions,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    // getCorrection,
+    // getHint,
+    // hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.js

@@ -37,7 +37,7 @@ const getInstruction = (identifiers) => {
 };
 const getHint = (identifiers) => {
     const { type, k, nbEssais, caracType } = identifiers;
-    return `La fréquence est le nombre de fois qu'on a obtenu ${caracType} divisée par le nombre total d'essais.`;
+    return `La fréquence est le nombre de fois qu'on a obtenu ${caracType} divisé par le nombre total d'essais.`;
 };
 const getCorrection = (identifiers) => {
     const { type, k, nbEssais, caracType } = identifiers;

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAiIF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}
+{"version":3,"file":"arithmeticFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA8IF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.js

@@ -2,9 +2,9 @@ import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrong
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Polynomial } from "../../../../math/polynomials/polynomial.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
-import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers, opts) => {
     const firstRank = opts?.firstTermRankOne ? 1 : 0;
     return `$(u_n)$ est une suite arithmétique de premier terme $u_{${firstRank}} = ${identifiers.firstValue}$ et de raison $r = ${identifiers.reason}$. 
@@ -74,15 +74,28 @@ const getPropositions = (n, { answer, firstValue, reason }) => {
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { reason, firstValue }, opts) => {
-    const formula = opts?.firstTermRankOne
-        ? new Polynomial([firstValue - reason, reason], "n")
-        : new Polynomial([firstValue, reason], "n");
-    const equal = new EqualNode(new VariableNode("u_n"), formula.toTree(), {
-        allowRawRightChildAsSolution: true,
-    });
-    const texs = equal.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, reason, firstValue }, opts) => {
+    try {
+        const formated = ans.replaceAll("u_n", "").replaceAll("=", "");
+        const parsed = parseAlgebraic(formated);
+        if (!parsed)
+            return false;
+        console.log(parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex());
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex() === answer.split("=")[1]);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const options = [
     {

package/lib/exercises/math/trigonometry/associatePoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"associatePoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/associatePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAItE,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,eAAe,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAyDF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"associatePoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/associatePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAItE,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,eAAe,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/geogebra/lagrange.d.ts

@@ -1,5 +1,7 @@
 import { Point } from "../math/geometry/point.js";
 import { IntervalNode } from "../tree/nodes/sets/intervalNode.js";
+export declare abstract class LagrangeConstructor {
+}
 export declare class Lagrange {
     points: number[][];
     constructor(interval: IntervalNode, points?: Point[]);

package/lib/geogebra/lagrange.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lagrange.d.ts","sourceRoot":"","sources":["../../src/geogebra/lagrange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAIrD,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAerE,qBAAa,QAAQ;IACnB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}
+{"version":3,"file":"lagrange.d.ts","sourceRoot":"","sources":["../../src/geogebra/lagrange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAIrD,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAKrE,8BAAsB,mBAAmB;CASxC;AACD,qBAAa,QAAQ;IACnB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}

package/lib/geogebra/lagrange.js

@@ -1,16 +1,8 @@
 import { randfloat } from "../math/utils/random/randfloat.js";
 import { randint } from "../math/utils/random/randint.js";
 import { randomColor } from "./colors.js";
-// export abstract class LagrangeConstructor {
-//   random() {
-//     const a = randint(-10, 0);
-//     const b = doWhile(
-//       () => randint(0, 10),
-//       (x) => Math.abs(x - a) < 5,
-//     );
-//     return new Spline(new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF));
-//   }
-// }
+export class LagrangeConstructor {
+}
 export class Lagrange {
     points;
     constructor(interval, points) {

package/lib/index.d.ts

@@ -674,17 +674,22 @@ declare const mathExercises: (Exercise<{
     y: number;
     isOnLine: boolean;
 }, {}> | Exercise<{
-    rand: boolean;
-    poly1: number[];
-    poly2: number[];
-    xValue: number;
-    flip: boolean;
-}, {}> | Exercise<{
-    isSpline: boolean;
-    splinePoints: number[][];
+    xValue: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    polynomeCoeffs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    imageSyntaxText: boolean;
+}, {
+    functionType: string[];
+    coeffsType: string[];
+    xType: string[];
+}> | Exercise<{
+    functionType: string;
     x: number;
     y: number;
-}, {}> | Exercise<{
+    wrongY: number;
+    otherPoints: number[][];
+}, {
+    curveTypes: string[];
+}> | Exercise<{
     poly1: number[];
     xValue: number;
 }, {}> | Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/math/geometry/parabola.d.ts

@@ -0,0 +1,11 @@
+import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps.js";
+import { Point } from "./point.js";
+export declare class Parabola {
+    points: Point[];
+    name: string;
+    unformatedName: string;
+    ggbName: string;
+    constructor(points: Point[], name?: string);
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showUnderlyingPoints, }?: ToGGBCommandsProps): string[];
+}
+//# sourceMappingURL=parabola.d.ts.map

package/lib/math/geometry/parabola.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parabola.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/parabola.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM;IAS1C,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,GAC5B,GAAE,kBAAuB;CA+B7B"}

package/lib/math/geometry/parabola.js

@@ -0,0 +1,32 @@
+export class Parabola {
+    points;
+    name;
+    unformatedName;
+    ggbName;
+    constructor(points, name) {
+        if (points.length !== 3)
+            throw new Error(`Parabola needs 3 points but received ${points.length}`);
+        this.points = points;
+        this.unformatedName = name ?? `${points.map((p) => p.name)}`;
+        this.name = name ?? `\\mathcal{P}_${points.map((p) => p.name)}`;
+        this.ggbName = name ?? `parabola_{${points.map((p) => p.name)}}`;
+    }
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showUnderlyingPoints = true, } = {}) {
+        const commands = [];
+        if (shouldBuildPoints) {
+            const pointsCommands = this.points.map((p) => p.toGGBCommand({
+                isFixed,
+                showLabel: showUnderlyingPointsLabel,
+            }));
+            commands.push(...pointsCommands.flat(), `${this.ggbName}=Polynomial(${this.points[0].name},${this.points[1].name},${this.points[2].name})`);
+        }
+        else {
+            commands.push(`${this.ggbName}=Polynomial(${this.points[0].toMathString()},${this.points[1].toMathString()},${this.points[2].toMathString()})`);
+        }
+        commands.push(...[
+            `SetFixed(${this.ggbName},${isFixed ? "true" : "false"})`,
+            `ShowLabel(${this.ggbName},${showLabel ? "true" : "false"})`,
+        ]);
+        return commands;
+    }
+}

package/lib/math/polynomials/generalPolynomial.d.ts

@@ -0,0 +1,19 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
+import { AddNode } from "../../tree/nodes/operators/addNode.js";
+export declare abstract class GeneralPolynomialConstructor {
+    static fromIdentifiers(identifiers: GeneralPolynomialIdentifiers): GeneralPolynomial;
+}
+export type GeneralPolynomialIdentifiers = {
+    id: "polynomial";
+    coeffs: NodeIdentifiers[];
+    variable?: string;
+};
+export declare class GeneralPolynomial {
+    coeffs: AlgebraicNode[];
+    variable: string;
+    constructor(coeffs: (number | AlgebraicNode)[], variable?: string);
+    toIdentifiers(): GeneralPolynomialIdentifiers;
+    toTree(): AddNode;
+}
+//# sourceMappingURL=generalPolynomial.d.ts.map

package/lib/math/polynomials/generalPolynomial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generalPolynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalPolynomial.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAO,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAYrE,8BAAsB,4BAA4B;IAChD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,4BAA4B;CAMjE;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,EAAE,EAAE,YAAY,CAAC;IACjB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,qBAAa,iBAAiB;IAC5B,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;gBAEL,MAAM,EAAE,CAAC,MAAM,GAAG,aAAa,CAAC,EAAE,EAAE,QAAQ,GAAE,MAAY;IAUtE,aAAa,IAAI,4BAA4B;IAO7C,MAAM;CAWP"}

package/lib/math/polynomials/generalPolynomial.js

@@ -0,0 +1,44 @@
+import { reifyAlgebraic, } from "../../tree/nodes/nodeConstructor.js";
+import { AddNode } from "../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../tree/nodes/operators/powerNode.js";
+import { operatorComposition } from "../../tree/utilities/operatorComposition.js";
+export class GeneralPolynomialConstructor {
+    static fromIdentifiers(identifiers) {
+        return new GeneralPolynomial(identifiers.coeffs.map((c) => reifyAlgebraic(c)), identifiers.variable);
+    }
+}
+export class GeneralPolynomial {
+    coeffs;
+    variable;
+    constructor(coeffs, variable = "x") {
+        const nodedCoeffs = coeffs.map((c) => {
+            if (typeof c === "number")
+                return c.toTree();
+            return c;
+        });
+        this.coeffs = nodedCoeffs;
+        if (nodedCoeffs[coeffs.length - 1].evaluate() === 0)
+            throw new Error("n-th coeff is null");
+        this.variable = variable;
+    }
+    toIdentifiers() {
+        return {
+            id: "polynomial",
+            coeffs: this.coeffs.map((c) => c.toIdentifiers()),
+            variable: this.variable !== "x" ? this.variable : undefined,
+        };
+    }
+    toTree() {
+        const monoms = this.coeffs
+            .map((c, i) => {
+            if (i === 0)
+                return c;
+            if (i === 1)
+                return multiply(c, this.variable);
+            return multiply(c, power(this.variable, i));
+        })
+            .filter((n, i) => this.coeffs[i].evaluate() !== 0);
+        return operatorComposition(AddNode, monoms.reverse());
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [