math-exercises 3.0.7 → 3.0.9

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

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

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

@@ -17,7 +17,8 @@ const getPropositions = (n, { answer }) => {
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    const statement = NodeConstructor.fromIdentifiers(identifiers.statementIdentifiers);
+    console.log("ans", identifiers);
+    const statement = NodeConstructor.fromIdentifiers(identifiers.statementIdentifiers, true);
     return statement.simplify().toTex();
 };
 const getInstruction = (identifiers) => {
@@ -58,6 +59,9 @@ const getFractionsOperationsQuestion = (ops) => {
     const identifiers = {
         statementIdentifiers: ids,
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -84,4 +88,5 @@ export const fractionsOperations = {
     // getHint,
     // getCorrection,
     getAnswer,
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"choseOperationToSolveEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/choseOperationToSolveEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAqJF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}
+{"version":3,"file":"choseOperationToSolveEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/choseOperationToSolveEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAuJF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

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

@@ -130,14 +130,15 @@ const getChoseOperationToSolveEquationQuestion = (opts) => {
             break;
     }
     const identifiers = { type, a, b, c };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -153,8 +154,7 @@ export const choseOperationToSolveEquation = {
     isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
-    // getHint,
-    // getCorrection,
     getAnswer,
     answerType: "QCU",
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"equationType1Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType1Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAcrC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAoBvD,CAAC"}
+{"version":3,"file":"equationType1Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType1Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAqBvD,CAAC"}

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

@@ -58,6 +58,9 @@ const getEquationType1ExerciseQuestion = () => {
     const b = randint(-10, 11);
     const a = randint(-10, 11, [0]);
     const identifiers = { a, b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         startStatement: getStartStatement(identifiers),
@@ -104,4 +107,5 @@ export const equationType1Exercise = {
     getInstruction,
     getAnswer,
     getStartStatement,
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"equationType2Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType2Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAsBrC,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C;;GAEG;AAGH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAaF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBhE,CAAC"}
+{"version":3,"file":"equationType2Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType2Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAsBrC,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C;;GAEG;AAGH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA0JF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAaF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBhE,CAAC"}

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

@@ -94,15 +94,18 @@ const getEquationType2ExerciseQuestion = (opts) => {
         isXRight,
         aNumberType: type,
     };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        instruction: getInstruction(identifiers),
-        startStatement: getStartStatement(identifiers),
-        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
         keys: equationKeys,
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -129,7 +132,7 @@ const isAnswerValid = (ans, { a, b }) => {
 const options = [
     {
         id: "aNumberType",
-        label: "Autoriser des fractions pour $a$",
+        label: "Type du coefficient $a$",
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         defaultValue: ["Entier"],
@@ -157,4 +160,5 @@ export const equationType2Exercise = {
     getAnswer,
     getStartStatement,
     rebuildIdentifiers,
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"equationType3Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType3Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAerC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAqBvD,CAAC"}
+{"version":3,"file":"equationType3Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType3Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAsBvD,CAAC"}

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

@@ -60,6 +60,9 @@ const getEquationType3ExerciseQuestion = () => {
     const a = randint(-10, 11, [0, 1]);
     const c = randint(-10, 11);
     const identifiers = { a, b, c };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         hint: getHint(identifiers),
@@ -106,4 +109,5 @@ export const equationType3Exercise = {
     getCorrection,
     getHint,
     getStartStatement,
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"equationType4Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType4Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAerC;;GAEG;AAEH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+FF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}
+{"version":3,"file":"equationType4Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType4Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAerC;;GAEG;AAEH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

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

@@ -43,6 +43,9 @@ const getEquationType4ExerciseQuestion = () => {
         c,
         d,
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         startStatement: getStartStatement(identifiers),
@@ -50,23 +53,23 @@ const getEquationType4ExerciseQuestion = () => {
         keys: equationKeys,
         answerFormat: "tex",
         identifiers,
-        //     hint: `Commence par regrouper les termes en $x$ d'un même côté de l'équation. Puis, isole $x$ en effectuant les bonnes opérations.`,
-        //     correction: `On isole $x$ à gauche en soustrayant par $${b}$ puis en divisant par $${a}$ :
-        // ${alignTex([
-        //   [
-        //     statementTex,
-        //     "\\iff",
-        //     new EqualNode(
-        //       new Affine(a, 0).toTree(),
-        //       affines[1].add(-b).toTree(),
-        //     ).toTex(),
-        //   ],
-        //   ["", "\\iff", answer],
-        // ])}
-        //     `,
     };
     return question;
 };
+//     hint: `Commence par regrouper les termes en $x$ d'un même côté de l'équation. Puis, isole $x$ en effectuant les bonnes opérations.`,
+//     correction: `On isole $x$ à gauche en soustrayant par $${b}$ puis en divisant par $${a}$ :
+// ${alignTex([
+//   [
+//     statementTex,
+//     "\\iff",
+//     new EqualNode(
+//       new Affine(a, 0).toTree(),
+//       affines[1].add(-b).toTree(),
+//     ).toTex(),
+//   ],
+//   ["", "\\iff", answer],
+// ])}
+//     `,
 const getPropositions = (n, { answer, a, b, c, d }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -97,4 +100,5 @@ export const equationType4Exercise = {
     subject: "Mathématiques",
     getInstruction,
     getAnswer,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/dataRepresentations/barChartReading.js

@@ -130,3 +130,70 @@ export const barChartReading = {
     getCorrection,
     getAnswer,
 };
+// !signtable
+//  const options = { svg: true };
+//   const d3n = new D3Node(options);
+//   const d3 = d3n.d3;
+//   const width = 600;
+//   const height = 250;
+//   const svg = d3n.createSVG(width, height);
+//   // Define table structure
+//   const rows = 3;
+//   const cols = 5;
+//   const cellWidth = 120;
+//   const cellHeight = 50;
+//   const startX = 50;
+//   const startY = 50;
+//   // Define table values
+//   const headers = ["x", "-\\infty", "-2", "0", "+\\infty"];
+//   const firstRow = ["f'(x)", "+", "0", "-", ""];
+//   const secondRow = ["f(x)", "\\nearrow", "max", "\\searrow", ""];
+//   // Draw table grid
+//   for (let r = 0; r < rows; r++) {
+//     for (let c = 0; c < cols; c++) {
+//       svg
+//         .append("rect")
+//         .attr("x", startX + c * cellWidth)
+//         .attr("y", startY + r * cellHeight)
+//         .attr("width", cellWidth)
+//         .attr("height", cellHeight)
+//         .attr("stroke", "black")
+//         .attr("fill", "black");
+//     }
+//   }
+//   // Function to render LaTeX with KaTeX
+//   const renderLatex = (formula: any) =>
+//     katex.renderToString(formula, { throwOnError: false });
+//   // Add LaTeX text using <foreignObject> for proper positioning
+//   const addLatexText = (x: any, y: any, latex: any) => {
+//     svg
+//       .append("foreignObject")
+//       .attr("x", x - cellWidth / 2)
+//       .attr("y", y - cellHeight / 2)
+//       .attr("width", cellWidth)
+//       .attr("height", cellHeight)
+//       .html(`<div xmlns="http://www.w3.org/1999/xhtml"
+//                       style="display: flex; align-items: center; justify-content: center; width: 100%; height: 100%;">
+//                       ${renderLatex(latex)}
+//                  </div>`);
+//   };
+//   // Insert header row
+//   headers.forEach((text, i) =>
+//     addLatexText(startX + i * cellWidth + cellWidth / 2, startY + 25, text),
+//   );
+//   // Insert first row (derivative sign changes)
+//   firstRow.forEach((text, i) =>
+//     addLatexText(
+//       startX + i * cellWidth + cellWidth / 2,
+//       startY + cellHeight + 25,
+//       text,
+//     ),
+//   );
+//   // Insert second row (function increasing/decreasing)
+//   secondRow.forEach((text, i) =>
+//     addLatexText(
+//       startX + i * cellWidth + cellWidth / 2,
+//       startY + 2 * cellHeight + 25,
+//       text,
+//     ),
+//   );

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;AAgIF,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,CAmB/D,CAAC"}

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

@@ -124,4 +124,7 @@ export const affineExpressionFromTwoImages = {
     subject: "Mathématiques",
     hasHintAndCorrection: true,
     getCorrection,
+    getInstruction,
+    getAnswer,
+    getHint,
 };

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

@@ -5,9 +5,10 @@ type Identifiers = {
     /** new */
     functionType: string;
     x: number;
-    y: number;
+    y?: number;
     wrongY: number;
     otherPoints: number[][];
+    functionCommand?: string;
 };
 type Options = {
     curveTypes: string[];

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,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;AAyOF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBhE,CAAC"}
+{"version":3,"file":"imageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,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,CAAC,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAgRF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBhE,CAAC"}

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

@@ -49,19 +49,33 @@ const rebuildIdentifiers = (oldIds) => {
     else
         return oldIds;
 };
-const getInstruction = (identifiers) => {
+const getInstruction = (identifiers, opts) => {
     const { x } = identifiers;
-    return `Quelle est l'image de $${x}$ par la fonction $f$ représentée ci dessous ?`;
+    let instruction = `Quelle est l'image de $${x}$ par la fonction $f$ représentée ci dessous ?`;
+    if (opts?.curveTypes?.includes("Avec valeur interdite (pas d'image)")) {
+        instruction += `
+    
+On écrira "aucun" si l'image n'existe pas.`;
+    }
+    return instruction;
 };
 const getAnswer = (identifiers) => {
     const { y } = identifiers;
+    if (y === undefined)
+        return "\\text{Aucun}";
     return y.frenchify();
 };
 const getGGBOptions = (identifiers) => {
-    const { functionType, otherPoints, wrongY, x, y } = identifiers;
+    const { functionType, otherPoints, wrongY, x, y, functionCommand } = identifiers;
     const allPoints = [...otherPoints, [x, y], [wrongY, x]].sort((a, b) => a[0] - b[0]);
     let commands = [];
     switch (functionType) {
+        case "Avec valeur interdite (pas d'image)":
+            commands = [
+                `f(x) = ${functionCommand}`,
+                `SetColor(f, "${randomColor()}")`,
+            ];
+            break;
         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);
@@ -104,10 +118,19 @@ const getGGBOptions = (identifiers) => {
         // 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;
+    let xMin, xMax, yMin, yMax;
+    if (functionType === "Avec valeur interdite (pas d'image)") {
+        xMin = x - 3;
+        xMax = x + 3;
+        yMin = -7;
+        yMax = 7;
+    }
+    else {
+        xMin = allPoints[0][0];
+        xMax = allPoints[allPoints.length - 1][0];
+        yMin = Math.min(...allPoints.map((p) => p[1])) - 1;
+        yMax = Math.max(...allPoints.map((p) => p[1])) + 1;
+    }
     return ggb.getOptions({
         coords: ggb.getAdaptedCoords({
             forceShowAxes: true,
@@ -122,13 +145,39 @@ const getStartStatement = (identifiers) => {
     const { x } = identifiers;
     return `f(${x})`;
 };
+const getKeys = (identifiers, options) => {
+    if (options?.curveTypes?.includes("Avec valeur interdite (pas d'image)")) {
+        return ["aucun"];
+    }
+    else {
+        return [];
+    }
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
 const getImageFunctionGeogebra = (opts) => {
-    const x = randint(-8, 9);
-    const y = randint(-8, 9);
-    const wrongY = y + randint(-3, 4, [0, x - y, 10 - y, -10 - y]);
+    let x = randint(-8, 9);
+    let y = randint(-8, 9);
+    let wrongY = y + randint(-3, 4, [0, x - y, 10 - y, -10 - y]);
+    let functionCommand = undefined;
     const functionType = random(opts?.curveTypes ?? ["Tracés", "Polynômes", "Droites", "Paraboles"]);
     let otherPoints = [];
     switch (functionType) {
+        case "Avec valeur interdite (pas d'image)":
+            y = undefined;
+            const k = randint(2, 6);
+            functionCommand = `${k}/(x-${x}) -x`;
+            break;
         case "Droites":
             //nothing to add
             break;
@@ -154,35 +203,17 @@ const getImageFunctionGeogebra = (opts) => {
         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,
+        functionCommand,
     };
-    const question = {
-        instruction: getInstruction(identifiers),
-        startStatement: getStartStatement(identifiers),
-        answer: getAnswer(identifiers),
-        keys: [],
-        ggbOptions: getGGBOptions(identifiers),
-        answerFormat: "tex",
-        identifiers,
-    };
-    return question;
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getPropositions = (n, { answer, x, y, wrongY }, opts) => {
+const getPropositions = (n, { answer, wrongY }, opts) => {
     const propositions = [];
     addValidProp(propositions, answer);
     //old questions have spline POint undefined
@@ -203,7 +234,13 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         defaultValue: ["Tracés", "Polynômes", "Droites", "Paraboles"],
-        values: ["Tracés", "Polynômes", "Droites", "Paraboles"],
+        values: [
+            "Tracés",
+            "Polynômes",
+            "Droites",
+            "Paraboles",
+            "Avec valeur interdite (pas d'image)",
+        ],
     },
 ];
 export const imageFunctionGeogebra = {
@@ -223,4 +260,5 @@ export const imageFunctionGeogebra = {
     getInstruction,
     getGGBOptions,
     rebuildIdentifiers,
+    getQuestionFromIdentifiers,
 };

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

@@ -1,10 +1,7 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
-    xValue: number;
     yValue: number;
-    affineCoeffs?: number[];
-    trinomCoeffs?: number[];
-    isAffine: boolean;
+    points: number[][];
 };
 export declare const inverseImageFunctionGeogebra: Exercise<Identifiers>;
 export {};

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,EAQT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA0IF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}
+{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IAEjB,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAmNF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}

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

@@ -1,94 +1,175 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { randomColor } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { Affine } from "../../../../math/polynomials/affine.js";
-import { Polynomial } from "../../../../math/polynomials/polynomial.js";
-import { Trinom } from "../../../../math/polynomials/trinom.js";
+import { Line } from "../../../../math/geometry/line.js";
+import { Parabola } from "../../../../math/geometry/parabola.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
+import { valueParser } from "../../../../tree/parsers/valueParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds.points?.length)
+        return oldIds;
+    const [x, y] = [oldIds.xValue, oldIds.yValue];
+    let points = [[x, y]];
+    if (oldIds.isAffine) {
+        const affine = AffineConstructor.fromCoeffs(oldIds.affineCoeffs);
+        const x2 = x + 1;
+        const y2 = affine.calculate(x2);
+        points.push([x2, y2]);
+    }
+    else {
+        const trinom = TrinomConstructor.fromCoeffs(oldIds.trinomCoeffs);
+        const x2 = x - 1;
+        const x3 = x + 1;
+        const y2 = trinom.calculate(x2);
+        const y3 = trinom.calculate(x3);
+        points.push([x2, y2], [x3, y3]);
+    }
+    return {
+        points,
+        yValue: oldIds.yValue,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { yValue } = identifiers;
+    return `Avec la précision permise par le graphique, déterminer le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.
+  
+S'il n'y en a pas, on écrira "aucun".`;
+};
+const getAnswer = (identifiers) => {
+    const { points, yValue } = identifiers;
+    const validPoints = points.filter((p) => p[1] === yValue);
+    if (!validPoints.length) {
+        return "\\text{Aucun}";
+    }
+    return validPoints
+        .map((p) => round(p[0], 2).frenchify())
+        .join("\\text{ et }");
+};
+const getGGBOptions = (identifiers) => {
+    const { points } = identifiers;
+    let commands = [];
+    if (points.length === 2) {
+        const line = new Line(new Point("A", points[0][0], points[0][1]), new Point("B", points[1][0], points[1][1]));
+        commands = line.toGGBCommands(false);
+    }
+    else {
+        const parabola = new Parabola(points.map((p, i) => new Point(`A_${i}`, p[0], p[1])));
+        commands = parabola.toGGBCommands(false);
+    }
+    const Xs = points.map((p) => p[0]);
+    const Ys = points.map((p) => p[1]);
+    const xMin = Math.min(...Xs);
+    const xMax = Math.max(...Xs);
+    const yMin = Math.min(...Ys);
+    const yMax = Math.max(...Ys);
+    const ggb = new GeogebraConstructor({ commands });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+            forceShowAxes: true,
+        }),
+    });
+};
 const getInverseImageFunctionGeogebra = () => {
-    const isAffine = coinFlip();
-    const xValue = randint(-5, 6);
-    // const yValue = randint(-5, 6);
+    const isLine = coinFlip();
+    const hasAntecedent = probaFlip(0.8);
+    // const isLine = false;
+    // const hasAntecedent = true;
     let yValue;
-    let affine;
-    let trinom;
-    let answer = "";
-    let xMin = -1;
-    let xMax = 1;
-    let yMin = -1;
-    let yMax = 1;
-    let commands;
-    if (isAffine) {
-        do {
-            affine = new Affine(randint(-5, 6, [0]), randint(-9, 10));
-            yValue = affine.calculate(xValue);
-        } while (Math.abs(yValue) > 10);
-        answer = xValue.toString().replace(".", ",");
-        yMin = yValue;
-        yMax = yValue;
-        xMin = xValue;
-        xMax = xValue;
-        commands = [affine.toString()];
+    const points = [];
+    if (isLine) {
+        if (hasAntecedent) {
+            yValue = randint(-6, 7);
+            const xIsDecimal = probaFlip(0.3);
+            const xValue = xIsDecimal
+                ? randfloat(-6, 7, 2, [yValue])
+                : randint(-6, 7, [yValue]);
+            const wrongY = randint(-6, 7);
+            points.push([xValue, yValue], [yValue, wrongY]);
+        }
+        else {
+            yValue = randint(-6, 7, [0]);
+            const constante = randint(-6, 7, [yValue]);
+            points.push([0, constante], [1, constante]);
+        }
     }
     else {
-        let roots;
-        yValue = randint(-5, 6);
-        do {
-            trinom = new Trinom(randint(-4, 5, [0]), randint(-9, 10), randint(-9, 10) - yValue);
-            roots = trinom.getRoots();
-        } while (roots.some((root) => Math.abs(root) > 10));
-        answer = !roots.length
-            ? "\\text{Aucun}"
-            : roots
-                .map((r) => round(r, 1).toString().replace(".", ","))
-                .join("\\text{ et }");
-        const beta = trinom.getBeta() + yValue;
-        yMin = trinom.a > 0 ? beta : roots.length ? yValue : beta - 5;
-        yMax = trinom.a < 0 ? beta : roots.length ? yValue : beta + 5;
-        xMax = roots.length ? Math.max(...roots) : -10;
-        xMin = roots.length ? Math.min(...roots) : 10;
-        commands = [
-            `f(x) = ${yValue !== 0
-                ? trinom.add(new Polynomial([yValue])).toString()
-                : trinom.toString()}`,
-            `SetColor(f, "${randomColor()}")`,
-        ];
+        if (hasAntecedent) {
+            yValue = randint(-6, 7);
+            const xIsDecimal = coinFlip();
+            const xValue = xIsDecimal
+                ? randfloat(-6, 7, 2, [yValue])
+                : randint(-6, 7, [yValue]);
+            const hasTwoAntecedents = probaFlip(0.8);
+            if (hasTwoAntecedents) {
+                const wrongY = randint(-6, 7, [yValue]);
+                const secondAntecedentPoint = [
+                    randint(-6, 7, [xValue, yValue]),
+                    yValue,
+                ];
+                points.push([xValue, yValue], [yValue, wrongY], secondAntecedentPoint);
+            }
+            else {
+                //(x,y) is summit
+                const wrongY = randint(-6, 7, [yValue]);
+                points.push([xValue, yValue], [yValue, wrongY], [2 * xValue - yValue, wrongY]);
+            }
+        }
+        else {
+            yValue = randint(-8, 9);
+            const wrongY = randint(-3, 4, [yValue, yValue - 1, yValue + 1]);
+            const below = wrongY < yValue;
+            const summit = [
+                randint(-6, 7, [yValue]),
+                below
+                    ? randint(wrongY + 1, yValue, [wrongY])
+                    : randint(yValue + 1, wrongY, [wrongY]),
+            ];
+            const thirdPoint = [2 * summit[0] - yValue, wrongY];
+            //construire deux autrs points au pif avec y sous/audssu yValus
+            points.push([yValue, wrongY], summit, thirdPoint);
+        }
     }
-    const statement = `Lire graphiquement le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.`;
-    const ggb = new GeogebraConstructor({ commands });
+    points.sort((p1, p2) => p1[0] - p2[0]);
+    const identifiers = {
+        // xValue,
+        // affineCoeffs: isAffine ? affine!.coefficients : undefined,
+        // trinomCoeffs: isAffine ? undefined : trinom!.coefficients,
+        yValue,
+        points,
+        // isAffine,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: statement,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: ["et", "aucun"],
-        ggbOptions: ggb.getOptions({
-            coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: {
-            xValue,
-            affineCoeffs: isAffine ? affine.coefficients : undefined,
-            trinomCoeffs: isAffine ? undefined : trinom.coefficients,
-            yValue,
-            isAffine,
-        },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, xValue, affineCoeffs, trinomCoeffs, yValue, isAffine }) => {
+const getPropositions = (n, { answer, points, yValue }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     tryToAddWrongProp(propositions, "\\text{Aucun}");
-    if (isAffine) {
-        const affine = new Polynomial(affineCoeffs);
-        tryToAddWrongProp(propositions, affine.calculate(yValue).toString().replace(".", ","));
-    }
-    else {
-        const trinom = new Polynomial(trinomCoeffs);
-        tryToAddWrongProp(propositions, trinom.calculate(yValue).toString().replace(".", ","));
+    const wrongY = points.find((p) => p[0] === yValue)?.[1];
+    if (wrongY !== undefined) {
+        tryToAddWrongProp(propositions, wrongY.frenchify());
     }
     while (propositions.length < n) {
         const wrongAnswer = coinFlip()
@@ -98,26 +179,27 @@ const getPropositions = (n, { answer, xValue, affineCoeffs, trinomCoeffs, yValue
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer, xValue, affineCoeffs, trinomCoeffs, yValue, isAffine }) => {
-    const antecedents = [];
-    if (isAffine) {
-        antecedents.push(xValue);
+const isAnswerValid = (ans, { answer, points, yValue }) => {
+    if (ans === "\\text{Aucun}" || answer === "\\text{Aucun}")
+        return ans === answer;
+    const validPoints = points.filter((p) => p[1] === yValue);
+    const ansElements = ans.split("\\text{ et }");
+    if (validPoints.length !== ansElements.length)
+        return false;
+    let sorted = [];
+    for (const el of ansElements) {
+        const parsed = valueParser(el);
+        if (parsed === false)
+            return false;
+        sorted.push(parsed);
     }
-    else {
-        const trinom = new Polynomial(trinomCoeffs);
-        const roots = trinom.getRoots();
-        antecedents.push(...roots);
+    sorted.sort((a, b) => a - b);
+    for (let i = 0; i < sorted.length; i++) {
+        const validPointX = validPoints[i][0];
+        if (Math.abs(sorted[i] - validPointX) > 0.3)
+            return false;
     }
-    if (!antecedents.length)
-        return ans === `\\text{Aucun}`;
-    const studentNumbers = ans
-        .split("\\text{ et }")
-        .map((n) => Number(n.replace(",", ".")))
-        .filter((n) => !isNaN(n))
-        .sort((a, b) => a - b);
-    antecedents.sort((a, b) => a - b);
-    return (!!studentNumbers.length &&
-        studentNumbers.every((nb, index) => Math.abs(nb - antecedents[index]) < 0.2));
+    return true;
 };
 export const inverseImageFunctionGeogebra = {
     id: "inverseImageFunctionGeogebra",
@@ -133,4 +215,9 @@ export const inverseImageFunctionGeogebra = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getGGBOptions,
+    getQuestionFromIdentifiers,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/percent/globalPercent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"globalPercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/globalPercent.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAYT,MAAM,mBAAmB,CAAC;AAO3B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAuGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAe/C,CAAC"}
+{"version":3,"file":"globalPercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/globalPercent.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAYT,MAAM,mBAAmB,CAAC;AAO3B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAuGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAmB/C,CAAC"}

package/lib/exercises/math/percent/globalPercent.js

@@ -99,4 +99,8 @@ export const globalPercent = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getCorrection,
+    getHint,
 };

package/lib/index.d.ts

@@ -684,20 +684,18 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     functionType: string;
     x: number;
-    y: number;
+    y?: number;
     wrongY: number;
     otherPoints: number[][];
+    functionCommand?: string;
 }, {
     curveTypes: string[];
 }> | Exercise<{
     poly1: number[];
     xValue: number;
 }, {}> | Exercise<{
-    xValue: number;
     yValue: number;
-    affineCoeffs?: number[];
-    trinomCoeffs?: number[];
-    isAffine: boolean;
+    points: number[][];
 }, {}> | Exercise<{
     yValue: number;
     splinePoints: [number, number][];

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/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,UAAU,YAAW,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,UAAU,YAEtB,CAAC"}

package/lib/playground.js

@@ -1,8 +1,3 @@
-import { NodeConstructor } from "./tree/nodes/nodeConstructor.js";
-export const playground = () => { };
-const logIdentifiers = () => {
-    const ids = '{"xA":-3,"yA":-2,"yPrimeA":{"id":31,"child":{"id":3,"leftChild":{"id":7,"value":3},"rightChild":{"id":7,"value":2}}},"trinomCoeffs":[0.3888888888888889,0.833333333333333,-3]}';
-    const parsed = JSON.parse(ids);
-    console.log(parsed);
-    console.log(NodeConstructor.fromIdentifiers({ ...parsed.yPrimeA }).toTex());
+export const playground = () => {
+    // logIdentifiers();
 };

package/lib/server.d.ts

@@ -1,2 +1,3 @@
 import "./prototypesEnhancement.js";
+export declare const logIdentifiers: () => void;
 //# sourceMappingURL=server.d.ts.map

package/lib/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,4BAA4B,CAAC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,4BAA4B,CAAC;AAOpC,eAAO,MAAM,cAAc,YAW1B,CAAC"}

package/lib/server.js

@@ -11,6 +11,18 @@ const jsonParser = bodyParser.json();
 const mathExercises = Object.values(MathExercises);
 const pcExercises = Object.values(PCExercises);
 const allExercises = [...mathExercises, ...pcExercises];
+export const logIdentifiers = () => {
+    const log = false;
+    if (!log)
+        return;
+    const shortname = "fractionsOperations";
+    const gen = mathExercises.find((el) => el.id === shortname);
+    const ids = '{"statementIdentifiers":{"id":1,"leftChild":{"id":3,"leftChild":{"id":7,"value":10},"rightChild":{"id":7,"value":3}},"rightChild":{"id":2,"leftChild":{"id":3,"leftChild":{"id":7,"value":1},"rightChild":{"id":7,"value":5}},"rightChild":{"id":3,"leftChild":{"id":7,"value":7},"rightChild":{"id":7,"value":5}}}}}';
+    const parsed = JSON.parse(ids);
+    console.log(parsed);
+    const question = gen.getQuestionFromIdentifiers(parsed);
+    console.log(question.instruction);
+};
 const runServer = () => {
     dotenv.config();
     const app = express();
@@ -19,6 +31,7 @@ const runServer = () => {
     console.log("math hints", mathExercises.filter((exo) => exo.hasHintAndCorrection).length);
     console.log("pc exos", `${pcExercises.length}`);
     playground();
+    logIdentifiers();
     app.get("/", (req, res) => {
         res.json(allExercises);
     });
@@ -28,6 +41,9 @@ const runServer = () => {
     app.get("/xplive", (req, res) => {
         res.json(pcExercises);
     });
+    app.get("/question", (req, res) => {
+        const exoId = req.query.exoId;
+    });
     app.get("/exo", (req, res) => {
         const exoId = req.query.exoId;
         const options = req.query.options

package/lib/tree/nodes/nodeConstructor.d.ts

@@ -1,11 +1,11 @@
 import { AlgebraicNode } from "./algebraicNode.js";
 import { Node, NodeIds } from "./node.js";
-export declare const reifyAlgebraic: (identifiers: NodeIdentifiers) => AlgebraicNode;
+export declare const reifyAlgebraic: (identifiers: NodeIdentifiers, log?: boolean) => AlgebraicNode;
 export declare const reifyNode: (identifiers: NodeIdentifiers) => Node;
 export type NodeIdentifiers = {
     id: NodeIds;
 } & Record<string, any>;
 export declare abstract class NodeConstructor {
-    static fromIdentifiers(identifiers: NodeIdentifiers): Node;
+    static fromIdentifiers(identifiers: NodeIdentifiers, log?: boolean): Node;
 }
 //# sourceMappingURL=nodeConstructor.d.ts.map

package/lib/tree/nodes/nodeConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeConstructor.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/nodeConstructor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAwBnD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoB1C,eAAO,MAAM,cAAc,gBAAiB,eAAe,KACT,aAAa,CAAC;AAChE,eAAO,MAAM,SAAS,gBAAiB,eAAe,SACR,CAAC;AAE/C,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACpE,8BAAsB,eAAe;IACnC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe,GAAG,IAAI;CAoS3D"}
+{"version":3,"file":"nodeConstructor.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/nodeConstructor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAwBnD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoB1C,eAAO,MAAM,cAAc,gBAAiB,eAAe,QAAQ,OAAO,KACxB,aAAa,CAAC;AAChE,eAAO,MAAM,SAAS,gBAAiB,eAAe,SACR,CAAC;AAE/C,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACpE,8BAAsB,eAAe;IACnC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,IAAI;CAqS1E"}

package/lib/tree/nodes/nodeConstructor.js

@@ -41,10 +41,11 @@ import { DiscreteSetNode } from "./sets/discreteSetNode.js";
 import { IntervalNode } from "./sets/intervalNode.js";
 import { UnionIntervalNode } from "./sets/unionIntervalNode.js";
 import { VariableNode } from "./variables/variableNode.js";
-export const reifyAlgebraic = (identifiers) => NodeConstructor.fromIdentifiers(identifiers);
+export const reifyAlgebraic = (identifiers, log) => NodeConstructor.fromIdentifiers(identifiers);
 export const reifyNode = (identifiers) => NodeConstructor.fromIdentifiers(identifiers);
 export class NodeConstructor {
-    static fromIdentifiers(identifiers) {
+    static fromIdentifiers(identifiers, log) {
+        log && console.log(identifiers.id);
         switch (identifiers.id) {
             case NodeIds.variable: {
                 return new VariableNode(identifiers.name);

package/package.json

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