math-exercises 3.0.162 → 3.0.164

package/lib/exercises/math/calculLitteral/distributivity/doubleDistributivityAdd.js

@@ -72,7 +72,7 @@ $$
 `;
 };
 const getHint = () => {
-    return "Développe et réduit chacun des produits d'abord. Puis, additionne les deux résultats.";
+    return "Développe et réduis chacun des produits d'abord. Puis, additionne les deux résultats.";
 };
 const getCorrection = (identifiers) => {
     const { affine1, affine2, affine3, type, affine4 } = identifiers;

package/lib/exercises/math/calculLitteral/distributivity/doubleDistributivitySubstract.js

@@ -72,7 +72,7 @@ $$
 `;
 };
 const getHint = () => {
-    return "Développe et réduit chacun des produits d'abord. Puis, soustrait les deux résultats.";
+    return "Développe et réduis chacun des produits d'abord. Puis, soustrais les deux résultats.";
 };
 const getCorrection = (identifiers) => {
     const { affine1, affine2, affine3, type, affine4 } = identifiers;

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

@@ -1 +1 @@
-{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IAEjB,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AA8WF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}
+{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IAEjB,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AA8bF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}

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

@@ -46,7 +46,15 @@ const getGGBOptions = (identifiers) => {
     const xMax = Math.max(...Xs);
     const yMin = Math.min(...Ys);
     const yMax = Math.max(...Ys);
-    const ggb = new GeogebraConstructor({ commands });
+    const ggb = new GeogebraConstructor({
+        commands,
+        xAxis: {
+            steps: 1,
+        },
+        yAxis: {
+            steps: 1,
+        },
+    });
     return ggb.getOptions({
         coords: ggb.getAdaptedCoords({
             xMin,
@@ -227,7 +235,11 @@ const getFeedback = (ans, { answer, ...identifiers }) => {
         if (Math.abs(studentAns - image.evaluate()) < 0.3) {
             return {
                 errorType: "A3-1",
-                feedback: "Tu as donné l'image au lieu de l'antécédent",
+                feedback: `Pour lire une image, la technique est la suivante (ici l'image de $4$ est $2$) : 
+
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/imageReading.png)
+        
+Et pour lire un antécédent, comment fait-on ? Sur quel axe, lit-on les antécédents ?`,
             };
         }
         if (affine.a.evaluate() !== 0) {
@@ -235,7 +247,7 @@ const getFeedback = (ans, { answer, ...identifiers }) => {
             if (Math.abs(studentAns - root.evaluate()) < 0.3) {
                 return {
                     errorType: "A3-2",
-                    feedback: "Tu lis l'intersection avec axe abscisse",
+                    feedback: "Tu as trouvé l'intersection de la courbe avec l'axe des abscisses. Cette technique est pertinente pour trouver les antécédents de 0, mais pas pour trouver les antécédents d'un nombre différent de 0. De manière générale, comment fait-on pour lire les antécédents d'un nombre ?",
                 };
             }
         }
@@ -243,14 +255,14 @@ const getFeedback = (ans, { answer, ...identifiers }) => {
         if (Math.abs(studentAns - ordOrigine) < 0.3) {
             return {
                 errorType: "A3-3",
-                feedback: "Tu lis l'intersection avec ordonnée",
+                feedback: "Tu as trouvé l'intersection de la courbe avec l'axe des ordonnés, mais cela n'a a priori pas de rapports avec la recherche d'antécédent. Comment fait-on pour lire un antécédent ?",
             };
         }
         const ansNb = answer.unfrenchify();
         if (Math.abs(studentAns - ansNb) < 1) {
             return {
                 errorType: "D",
-                feedback: "Lecture graphique peu précise",
+                feedback: "Ta lecture sur le graphique n'est pas assez précise, mais tu as bien compris la procédure à suivre pour répondre à la question.",
             };
         }
         return {
@@ -270,7 +282,7 @@ const getFeedback = (ans, { answer, ...identifiers }) => {
                 validPoints.some((p) => Math.abs(p[0] - v) < 0.2)) {
                 return {
                     errorType: "C3-1",
-                    feedback: "Tu as donné une seule solution au lieu de deux",
+                    feedback: "Tu as trouvé une partie de la réponse, mais ce n'est pas complet. Combien un nombre peut-il avoir d'antécédent ?",
                 };
             }
         }
@@ -283,31 +295,35 @@ const getFeedback = (ans, { answer, ...identifiers }) => {
             if (Math.abs(v - image) < 0.2) {
                 return {
                     errorType: "A3-1",
-                    feedback: "Tu as donné l'image au lieu de l'antécédent",
+                    feedback: `Pour lire une image, la technique est la suivante (ici l'image de $4$ est $2$) : 
+
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/imageReading.png)
+        
+Et pour lire un antécédent, comment fait-on ? Sur quel axe, lit-on les antécédents ?`,
                 };
             }
             if (Math.abs(v - c) < 0.2)
                 return {
                     errorType: "A3-3",
-                    feedback: "Tu lis l'intersection avec ordonnée",
+                    feedback: "Tu as trouvé l'intersection de la courbe avec l'axe des ordonnés, mais cela n'a a priori pas de rapports avec la recherche d'antécédent. Comment fait-on pour lire un antécédent ?",
                 };
             if (Math.abs(v - extrema) < 0.2)
                 if (trinom.a < 0)
                     return {
                         errorType: "A3-4",
-                        feedback: "Tu lis le maximum",
+                        feedback: "Tu as trouvé le maximum de la courbe, mais cela n'a a priori pas de rapports avec la recherche d'antécédent. Comment fait-on pour lire un antécédent ?",
                     };
                 else {
                     return {
                         errorType: "A3-5",
-                        feedback: "Tu lis le minimum",
+                        feedback: "Tu as trouvé le minimum de la courbe, mais cela n'a a priori pas de rapports avec la recherche d'antécédent. Comment fait-on pour lire un antécédent ?",
                     };
                 }
             if (roots.length) {
                 if (Math.abs(v - roots[0]) < 0.2 || Math.abs(v - roots[1]) < 0.2) {
                     return {
                         errorType: "A3-2",
-                        feedback: "Tu lis l'intersection avec axe abscisse",
+                        feedback: "Tu as trouvé l'intersection de la courbe avec l'axe des abscisses. Cette technique est pertinente pour trouver les antécédents de 0, mais pas pour trouver les antécédents d'un nombre différent de 0. De manière générale, comment fait-on pour lire les antécédents d'un nombre ?",
                     };
                 }
             }
@@ -330,10 +346,61 @@ const getFeedback = (ans, { answer, ...identifiers }) => {
     }
 };
 const getMethodology = () => {
+    //  const commands = [
+    //     "f(x) = (x+2)(x-1)",
+    //     `Conique_1 : 1.76x^2+6.43y^2+0.77x-51.42y = -102.21`,
+    //     `step = Slider(1, 4, 1, 1, 100, false, true, true, false)`,
+    //     "C = (2,4)",
+    //     `SetVisibleInView(step, 1, false)`,
+    //     `ShowLabel(C, false)`,
+    //     "SetFixed(C, true, false)",
+    //     `SetConditionToShowObject(C, step>1)`,
+    //     "D = (-3,4)",
+    //     `ShowLabel(D, false)`,
+    //     "SetFixed(D, true, false)",
+    //     `SetConditionToShowObject(D, step>1)`,
+    //     `g: y=4`,
+    //     `SetConditionToShowObject(g, step>1)`,
+    //     "A = (-3,0)",
+    //     `ShowLabel(A, false)`,
+    //     "SetFixed(A, true, false)",
+    //     `SetConditionToShowObject(A, step>2)`,
+    //     "B = (2,0)",
+    //     `ShowLabel(B, false)`,
+    //     "SetFixed(B, true, false)",
+    //     `SetConditionToShowObject(B, step>2)`,
+    //     "S_1 = Segment(B,C)",
+    //     `SetConditionToShowObject(B, step>2)`,
+    //     `SetLineStyle(S_1, 2)`,
+    //     "S_2 = Segment(A,D)",
+    //     `SetConditionToShowObject(B, step>2)`,
+    //     `SetLineStyle(S_2, 2)`,
+    //     `text1 = Text("$\\scriptsize 2\\text{ est un}\\\\ \\text{antécédent de }4\\\\ \\text{ par la fonction }f$", (2.69357, 1.61646))`,
+    //     `SetConditionToShowObject(text1, step>2)`,
+    //     `SetConditionToShowObject(text1, step>2)`,
+    //     `I = (2.64071, 0.39819)`,
+    //     `SetVisibleInView(I, 1, false)`,
+    //     `v = Vector(I, B)`,
+    //     `SetConditionToShowObject(v, step>2)`,
+    //     `text2 = Text("$\\scriptsize -3 \\text{ est un autre} \\\\ \\text{antécédent de } 4 \\\\ \\text{par la fonction }f$", (-6.27307, 1.61256))`,
+    //     `SetConditionToShowObject(text2, step>3)`,
+    //     `H = (-3.83865, 0.62044)`,
+    //     `SetVisibleInView(H, 1, false)`,
+    //     `u = Vector(H, A)`,
+    //     `SetConditionToShowObject(u, step>3)`,
+    //     `StartAnimation(step, true)`,
+    //   ];
     return {
-        methodology: `Voici la méthodologie blah blah blah
+        methodology: `Chercher des antécédents d'un réel $4$ par la fonction f, c'est déterminer les réels $x$ tels que $f(x)=4$.
+ 
+La donnée $4$ se trouve donc sur l'axe des ordonnées et les antécédents cherchés doivent donc se trouver sur l'axe des abscisses !
+
+Voici la technique à employer pour trouver les antécédents de $4$ : 
     
-![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/antecedentReading.png)`,
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/antecedentMethodo.gif)`,
+        // methodologyGGBOptions: ggb.getOptions({
+        //   coords: [-8, 6, -3, 5],
+        // }),
     };
 };
 export const inverseImageFunctionGeogebra = {

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

@@ -5,4 +5,5 @@ export * from "./rootsFromFactorizedForm.js";
 export * from "./rootsProduct.js";
 export * from "./rootsReading.js";
 export * from "./rootsSum.js";
+export * from "./trinomAlgebraicFormFromRootsAndPoint.js";
 //# sourceMappingURL=index.d.ts.map

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

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

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

@@ -5,3 +5,4 @@ export * from "./rootsFromFactorizedForm.js";
 export * from "./rootsProduct.js";
 export * from "./rootsReading.js";
 export * from "./rootsSum.js";
+export * from "./trinomAlgebraicFormFromRootsAndPoint.js";

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

@@ -1 +1 @@
-{"version":3,"file":"rootsFromFactorizedForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromFactorizedForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkHF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}
+{"version":3,"file":"rootsFromFactorizedForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromFactorizedForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiJF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

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

@@ -4,18 +4,48 @@ import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trino
 import { randint } from "../../../../../math/utils/random/randint.js";
 import { OppositeNode } from "../../../../../tree/nodes/functions/oppositeNode.js";
 import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
 import { discreteSetParser } from "../../../../../tree/parsers/discreteSetParser.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return `Un produit est nul si et seulement si un de ses facteurs est nul.
-// Il faut donc trouver les valeurs de $x$ qui rendent un des facteurs nuls.`;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   const { a, b, c } = identifiers;
-//   const trinom = new Trinom(a, b, c);
-//   return ``;
-// };
+const getHint = () => {
+    return `Un produit est nul si et seulement si un de ses facteurs est nul.
+
+Il faut donc trouver les valeurs de $x$ qui rendent un des facteurs nuls.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const factors = roots.map((r) => substract("x", r).simplify());
+    return `Un produit est nul si et seulement si un de ses facteurs est nul.
+
+${roots.length === 2
+        ? `Or,
+
+$$
+${factors[0].toTex()} = 0 \\iff x = ${roots[0].toTex()} 
+$$
+
+et
+
+$$
+${factors[1].toTex()} = 0 \\iff x = ${roots[1].toTex()} 
+$$
+`
+        : `Or, 
+  
+$$
+${square(factors[0]).toTex()} = 0 \\iff x = ${roots[0].toTex()} 
+$$`}
+
+L'ensemble des solutions de $f(x) = 0$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
 const getInstruction = (identifiers) => {
     const { a, b, c } = identifiers;
     const trinom = new Trinom(a, b, c);
@@ -45,6 +75,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -94,4 +126,5 @@ export const rootsFromFactorizedForm = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    rootsIds: NodeIdentifiers[];
+    pointIds: PointIdentifiers;
+};
+type Options = {
+    expectedForm: string;
+};
+export declare const trinomAlgebraicFormFromRootsAndPoint: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=trinomAlgebraicFormFromRootsAndPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trinomAlgebraicFormFromRootsAndPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/trinomAlgebraicFormFromRootsAndPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA4RF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAWF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAwBR,CAAC"}

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

@@ -0,0 +1,252 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../../math/utils/random/randTupleInt.js";
+import { reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }, opts) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, getAnswer(generateIdentifiers(), opts));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers, options) => {
+    const { pointIds, rootsIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const roots = rootsIds.map((rootId) => reifyAlgebraic(rootId));
+    const partialTrinom = roots.length === 1
+        ? square(substract("x", roots[0]).simplify())
+        : multiply(substract("x", roots[0]).simplify(), substract("x", roots[1]).simplify());
+    const partialImage = partialTrinom
+        .toDetailedEvaluation({ x: point.x })
+        .simplify();
+    const a = frac(point.y, partialImage).simplify();
+    const facto = multiply(a, partialTrinom).simplify({ forbidFactorize: true });
+    if (options?.expectedForm === "Forme développée")
+        return facto.simplify({ towardsDistribute: true, forbidFactorize: true });
+    return facto;
+};
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getInstruction = (identifiers, opts) => {
+    const { pointIds, rootsIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const roots = rootsIds.map((rootId) => reifyAlgebraic(rootId));
+    return `Soit $f$ une fonction polynôme du second degré, dont la parabole passe par le point $${point.toTexWithCoords()}$, et qui a ${roots.length === 1
+        ? `pour seule racine : $${roots[0].toTex()}$`
+        : `deux racines : $${roots[0].toTex()}$ et $${roots[1].toTex()}$`}
+  
+Déterminer la forme ${opts?.expectedForm === "Forme développée" ? "développée" : "factorisée"} de $f(x)$.
+`;
+};
+const getHint = () => {
+    return `Si $f$ est une fonction polynôme du second degré ayant deux racines $x_1$ et $x_2$, alors sa forme factorisée est : 
+  
+$$
+f(x) = a(x-x_1)(x-x_2)
+$$
+
+Si elle n'admet qu'une racine $x_0$, alors sa forme factorisée est :
+
+$$
+f(x) = a(x-x_0)^2 
+$$
+
+Sers-toi ensuite du fait que $A$ appartient à la courbe de $f$ pour déterminer $a$.
+`;
+};
+const getCorrection = (identifiers, opts) => {
+    const { pointIds, rootsIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const roots = rootsIds.map((rootId) => reifyAlgebraic(rootId));
+    const partialTrinom = roots.length === 1
+        ? square(substract("x", roots[0]).simplify())
+        : multiply(substract("x", roots[0]).simplify(), substract("x", roots[1]).simplify());
+    const partialImage = partialTrinom
+        .toDetailedEvaluation({ x: point.x })
+        .simplify();
+    const a = frac(point.y, partialImage).simplify();
+    if (roots.length === 1) {
+        return `Puisque $f$ a une seule racine $${roots[0].toTex()}$, sa forme factorisée est :
+    
+$$
+f(x) = ${multiply("a", square(substract("x", roots[0]).simplify())).toTex()}
+$$
+
+Pour déterminer $a$, on utilise le fait que $${point.toTexWithCoords()}$ appartient à la parabole représentative de $f$. Cela implique que $f(${point.x.toTex()})=${point.y.toTex()}$. Donc : 
+
+$$
+${multiply("a", square(substract(point.x, roots[0]))).toTex()}=${point.y.toTex()}
+$$
+
+d'où $a =${a.toTex()}$.
+
+La forme factorisée de $f$ est donc : 
+
+$$
+f(x) = ${multiply(a, partialTrinom).toTex()}
+$$
+
+${opts?.expectedForm === "Forme développée"
+            ? `
+Il suffit alors de développer et réduire pour obtenir la forme développée : 
+
+${alignTex([
+                ["f(x)", "=", multiply(a, partialTrinom).toTex()],
+                [
+                    "",
+                    "=",
+                    multiply(a, partialTrinom.simplify({
+                        towardsDistribute: true,
+                        forbidFactorize: true,
+                    })).toTex(),
+                ],
+                [
+                    "",
+                    "=",
+                    multiply(a, partialTrinom)
+                        .simplify({ towardsDistribute: true, forbidFactorize: true })
+                        .toTex(),
+                ],
+            ])}
+`
+            : ""}
+`;
+    }
+    return `Puisque $f$ a deux racines $${roots[0].toTex()}$ et $${roots[1].toTex()}$, sa forme factorisée est :
+    
+$$
+f(x) = ${multiply("a", multiply(substract("x", roots[0]).simplify(), substract("x", roots[1]).simplify())).toTex()}
+$$
+
+Pour déterminer $a$, on utilise le fait que $${point.toTexWithCoords()}$ appartient à la parabole représentative de $f$. Cela implique que $f(${point.x.toTex()})=${point.y.toTex()}$. Donc : 
+
+$$
+${multiply("a", multiply(substract(point.x, roots[0]).simplify(), substract(point.x, roots[1]).simplify())).toTex()}=${point.y.toTex()}
+$$
+
+d'où $a =${a.toTex()}$.
+
+La forme factorisée de $f$ est donc : 
+
+$$
+f(x) = ${multiply(a, partialTrinom).toTex()}
+$$
+
+${opts?.expectedForm === "Forme développée"
+        ? `
+Il suffit alors de développer et réduire pour obtenir la forme développée : 
+
+${alignTex([
+            ["f(x)", "=", multiply(a, partialTrinom).toTex()],
+            [
+                "",
+                "=",
+                multiply(a, partialTrinom.simplify({
+                    towardsDistribute: true,
+                    forbidFactorize: true,
+                })).toTex(),
+            ],
+            [
+                "",
+                "=",
+                multiply(a, partialTrinom)
+                    .simplify({ towardsDistribute: true, forbidFactorize: true })
+                    .toTex(),
+            ],
+        ])}
+`
+        : ""}`;
+};
+const getKeys = () => {
+    return ["xsquare", "x"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        const ansNode = getAnswerNode(identifiers, opts);
+        return (parsed
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex() ===
+            ansNode
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const generateIdentifiers = (_options) => {
+    const uniqueRoot = coinFlip();
+    const roots = uniqueRoot
+        ? [randint(-9, 10, [0])]
+        : randTupleInt(2, {
+            from: -9,
+            to: 10,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+    const a = randint(-9, 10, [0]);
+    const pointX = randint(-9, 10, roots);
+    const pointY = multiply(a, uniqueRoot
+        ? square(substract(pointX, roots[0]))
+        : multiply(substract(pointX, roots[0]), substract(pointX, roots[1]))).simplify();
+    const point = new Point("A", pointX, pointY);
+    return {
+        pointIds: point.toIdentifiers(),
+        rootsIds: roots.map((r) => r.toTree().toIdentifiers()),
+    };
+};
+const getTrinomAlgebraicFormFromRootsAndPointQuestion = (opts) => {
+    return getQuestionFromIdentifiers(generateIdentifiers(opts), opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const options = [
+    {
+        id: "expectedForm",
+        label: "Forme attendue",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.select,
+        values: ["Forme développée", "Forme factorisée"],
+        defaultValue: "Forme factorisée",
+    },
+];
+export const trinomAlgebraicFormFromRootsAndPoint = {
+    id: "trinomAlgebraicFormFromRootsAndPoint",
+    connector: "=",
+    label: "Déterminer l'expression algébrique d'un trinôme en connaissant ses racines et un point de la parabole",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrinomAlgebraicFormFromRootsAndPointQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
+};

package/lib/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.d.ts

@@ -4,6 +4,9 @@ type Identifiers = {
     summitIds: PointIdentifiers;
     pointIds: PointIdentifiers;
 };
-export declare const devFormFromSummitAndPoint: Exercise<Identifiers>;
+type Options = {
+    expectedForm: string;
+};
+export declare const devFormFromSummitAndPoint: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=devFormFromSummitAndPoint.d.ts.map

package/lib/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"devFormFromSummitAndPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAyLF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAmB3D,CAAC"}
+{"version":3,"file":"devFormFromSummitAndPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAyNF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAaF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBpE,CAAC"}

package/lib/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.js

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
@@ -10,7 +10,7 @@ import { substract } 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";
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer }, opts) => {
     const propositions = [];
     addValidProp(propositions, answer);
     propWhile(propositions, n, () => {
@@ -23,27 +23,30 @@ const getPropositions = (n, { answer }) => {
             pointIds: point.toIdentifiers(),
             summitIds: summit.toIdentifiers(),
         };
-        tryToAddWrongProp(propositions, getAnswer(fakeIds));
+        tryToAddWrongProp(propositions, getAnswer(fakeIds, opts));
     });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers, opts) => {
     const { pointIds, summitIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
     const summit = PointConstructor.fromIdentifiers(summitIds);
     const a = frac(substract(point.y, summit.y), square(substract(point.x, summit.x))).simplify();
-    const cano = add(multiply(a, square(substract("x", summit.x))), summit.y);
-    return cano
-        .simplify({ towardsDistribute: true, forbidFactorize: true })
-        .toTex();
+    const cano = add(multiply(a, square(substract("x", summit.x).simplify())), summit.y);
+    if (opts?.expectedForm === "Forme canonique")
+        return cano;
+    return cano.simplify({ towardsDistribute: true, forbidFactorize: true });
 };
-const getInstruction = (identifiers) => {
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getInstruction = (identifiers, opts) => {
     const { pointIds, summitIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
     const summit = PointConstructor.fromIdentifiers(summitIds);
     return `On considère une fonction polynôme du second degré $f$. Sa parabole passe par le point $${point.toTexWithCoords()}$, et son sommet est $${summit.toTexWithCoords()}$. 
   
-Déterminer la forme développée de $f$.`;
+Déterminer la forme ${opts?.expectedForm === "Forme canonique" ? "canonique" : "développée"} de $f$.`;
 };
 const getHint = (identifiers) => {
     return `La forme canonique d'une fonction polynôme du second degré $f$ est : 
@@ -56,7 +59,7 @@ où $\\alpha$ est l'abscisse du sommet de la parabole, et $\\beta$ son ordonnée
 
 Utilise cette formule ici, puis le fait que le point $${PointConstructor.fromIdentifiers(identifiers.pointIds).toTexWithCoords()}$ est un point de la parabole pour déterminer $a$.`;
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, opts) => {
     const { pointIds, summitIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
     const summit = PointConstructor.fromIdentifiers(summitIds);
@@ -88,49 +91,59 @@ ${alignTex([
         ["a", "=", a.simplify().toTex()],
     ])}
 
-Il ne reste plus qu'à développer la forme canonique de $f$ :
+${opts?.expectedForm === "Forme canonique"
+        ? `La forme canonique de $f$ est donc : 
+    
+$$
+f(x) = ${getAnswer(identifiers, opts)}
+$$`
+        : `Il ne reste plus qu'à développer la forme canonique de $f$ :
 
 ${alignTex([
-        [
-            "f(x)",
-            "=",
-            add(multiply(a, square(substract("x", alpha))), beta)
-                .simplify()
-                .toTex(),
-        ],
-        [
-            "",
-            "=",
-            add(multiply(a, square(substract("x", alpha)).simplify({
-                towardsDistribute: true,
-                forbidFactorize: true,
-            })), beta).toTex(),
-        ],
-        [
-            "",
-            "=",
-            add(multiply(a, square(substract("x", alpha))), beta)
-                .simplify({ towardsDistribute: true, forbidFactorize: true })
-                .toTex(),
-        ],
-    ])}
-`;
+            [
+                "f(x)",
+                "=",
+                add(multiply(a, square(substract("x", alpha))), beta)
+                    .simplify()
+                    .toTex(),
+            ],
+            [
+                "",
+                "=",
+                add(multiply(a, square(substract("x", alpha)).simplify({
+                    towardsDistribute: true,
+                    forbidFactorize: true,
+                })), beta).toTex(),
+            ],
+            [
+                "",
+                "=",
+                add(multiply(a, square(substract("x", alpha))), beta)
+                    .simplify({ towardsDistribute: true, forbidFactorize: true })
+                    .toTex(),
+            ],
+        ])}
+`}`;
 };
 const getKeys = () => {
     return ["xsquare", "x"];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
     try {
         const parsed = parseAlgebraic(ans);
+        const ansNode = getAnswerNode(identifiers, opts);
         return (parsed
             .simplify({ towardsDistribute: true, forbidFactorize: true })
-            .toTex() === answer);
+            .toTex() ===
+            ansNode
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex());
     }
     catch (err) {
         return handleVEAError(err);
     }
 };
-const getDevFormFromSummitAndPointQuestion = () => {
+const getDevFormFromSummitAndPointQuestion = (opts) => {
     const summit = PointConstructor.random("S");
     const a = randint(-10, 10, [0]);
     const pointX = randint(-10, 10, [summit.x.evaluate()]);
@@ -140,23 +153,33 @@ const getDevFormFromSummitAndPointQuestion = () => {
         pointIds: point.toIdentifiers(),
         summitIds: summit.toIdentifiers(),
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     return {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
 };
+const options = [
+    {
+        id: "expectedForm",
+        label: "Forme attendue",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.select,
+        values: ["Forme développée", "Forme canonique"],
+        defaultValue: "Forme développée",
+    },
+];
 export const devFormFromSummitAndPoint = {
     id: "devFormFromSummitAndPoint",
     connector: "=",
-    label: "Déterminer la forme développée d'un trinôme en connaissant un point et le sommet de la parabole",
+    label: "Déterminer l'expression algébrique d'un trinôme en connaissant un point et le sommet de la parabole",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getDevFormFromSummitAndPointQuestion(opts), nb),
     qcmTimer: 60,
@@ -169,5 +192,6 @@ export const devFormFromSummitAndPoint = {
     getCorrection,
     getAnswer,
     getQuestionFromIdentifiers,
+    options,
     hasHintAndCorrection: true,
 };

package/lib/index.d.ts

@@ -1397,6 +1397,11 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode.js").TrinomNodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    rootsIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+}, {
+    expectedForm: string;
+}> | Exercise<{
     trinomCoeffs: number[];
     isAskingPositive: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1442,7 +1447,9 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     summitIds: import("./math/geometry/point.js").PointIdentifiers;
     pointIds: import("./math/geometry/point.js").PointIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    expectedForm: string;
+}> | Exercise<{
     type: number;
     points: number[][];
 }, Record<string, string | boolean | string[]>> | Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/package.json

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