math-exercises 3.0.98 → 3.0.99

package/lib/exercises/math/calcul/mentalCaluls/mentalAddAndSub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mentalAddAndSub.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalAddAndSub.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAoFF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"mentalAddAndSub.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalAddAndSub.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA+FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}

package/lib/exercises/math/calcul/mentalCaluls/mentalAddAndSub.js

@@ -24,6 +24,16 @@ const getStartStatement = (identifiers) => {
 const getAnswer = (identifiers) => {
     return getStatementNode(identifiers).simplify().toTex();
 };
+// const getHint: GetHint<Identifiers> = (identifiers)=>{
+//   return `Ajoute les nombres dans l'ordre.`
+// }
+// const getCorrection: GetCorrection<Identifiers> = (identifiers)=>{
+//   const {numbers} = identifiers
+//   return `On ajoute les nombres dans l'ordre :
+// ${alignTex([
+//   [getStartStatement(identifiers), "=", add(numbers[])],
+// ])}`
+// }
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),

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

@@ -50,7 +50,7 @@ $$`;
 };
 const getHint = (identifiers) => {
     const { type, a, b, c, d, e, f } = identifiers;
-    return `Commence par développer ${type === 0 ? "le produit" : "les produits"} en utilisant la distributivité. Ensuite, résout l'équation en regroupant les termes en $x$ d'un côté de l'équation.`;
+    return `Commence par développer ${type === 0 ? "le produit" : "les produits"} en utilisant la distributivité. Ensuite, résous l'équation en regroupant les termes en $x$ d'un côté de l'équation.`;
 };
 const getCorrection = (identifiers) => {
     const { type, a, b, c, d, e, f } = identifiers;

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

@@ -115,7 +115,7 @@ const isAnswerValid = (ans, { answer, xA, xB, yA, yB }) => {
 export const affineExpressionFromTwoImages = {
     id: "affineExpressionFromTwoImages",
     connector: "=",
-    label: "Expression algébrique d'une fonction affine via deux images",
+    label: "Déterminer l'expression algébrique d'une fonction affine via deux images",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getAffineExpressionFromTwoImagesQuestion, nb),
     qcmTimer: 60,

package/lib/exercises/math/functions/sign/readSignTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readSignTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/readSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,EAAE,EAAE,eAAe,EAAE,CAAC;IACtB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AA4GF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}
+{"version":3,"file":"readSignTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/readSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,EAAE,EAAE,eAAe,EAAE,CAAC;IACtB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AA4GF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}

package/lib/exercises/math/functions/variations/compareImagesInVarTable.js

@@ -51,7 +51,7 @@ const getInstruction = (identifiers) => {
     return `On donne le tableau de variations d'une fonction $f$ définie sur $\\mathbb{R}$ :
   
   
-<svg id='varTable'>${JSON.stringify(table)}</svg>
+<svg id="varTable">${JSON.stringify(table)}</svg>
 
 Compléter par le bon symbole : 
 

package/lib/exercises/math/functions/variations/varTableExtremaReading.js

@@ -64,7 +64,7 @@ const getInstruction = (identifiers) => {
     const table = getTable(identifiers);
     let instruction = `On considère la fonction $f$ dont le tableau de variations est donné ci-dessous : 
   
-  <svg id='varTable'>${JSON.stringify(table)}</svg>
+  <svg id="varTable">${JSON.stringify(table)}</svg>
   
   ${identifiers.isAskingX
         ? `Sur l'intervalle $${interval.toTex()}$, en quelle valeur le ${type} de la fonction $f$ est-il atteint ?`

package/lib/exercises/math/functions/variations/varTableFromSentences.d.ts

@@ -3,6 +3,7 @@ import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
     vars: string[];
     xs: NodeIdentifiers[];
+    initTable: string[][];
 };
 export declare const varTableFromSentences: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/functions/variations/varTableFromSentences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"varTableFromSentences.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/varTableFromSentences.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,EAAE,EAAE,eAAe,EAAE,CAAC;CACvB,CAAC;AAyKF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}
+{"version":3,"file":"varTableFromSentences.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/varTableFromSentences.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,EAAE,EAAE,eAAe,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AAwLF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}

package/lib/exercises/math/functions/variations/varTableFromSentences.js

@@ -134,9 +134,21 @@ const getVarTableFromSentencesQuestion = (ops) => {
     const identifiers = {
         xs: xs.map((e) => e.toTree().toIdentifiers()),
         vars,
+        initTable: getInitTable(),
     };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getInitTable = () => {
+    const stringed = ["", "\\ ", "", "\\ ", "", "\\ ", ""];
+    const emptyLine = ["\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "];
+    const inputLine = ["", "", "", "", "", "", ""];
+    return [
+        ["$x$", ...stringed],
+        ["$\\ $", ...emptyLine],
+        ["$f(x)$", ...inputLine],
+        ["$\\ $", ...emptyLine],
+    ];
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     return {
         answerTable: getAnswerTable(identifiers),
@@ -146,6 +158,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
     };
 };
 export const varTableFromSentences = {
@@ -165,3 +178,5 @@ export const varTableFromSentences = {
     hasHintAndCorrection: true,
     answerType: "varTable",
 };
+// caca
+// /pas d'init table ?

package/lib/exercises/math/geometry/vectors/chasles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chasles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/chasles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAqFF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAYzC,CAAC"}
+{"version":3,"file":"chasles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/chasles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAyKF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAazC,CAAC"}

package/lib/exercises/math/geometry/vectors/chasles.js

@@ -3,15 +3,19 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { randint } from "../../../../math/utils/random/randint.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getInstruction = (identifiers) => {
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getStatement = (identifiers) => {
     const { randLetters, vectors } = identifiers;
     let statement = vectors.join("");
     if (statement[0] === "+")
         statement = statement.slice(1, statement.length);
+    return statement;
+};
+const getInstruction = (identifiers) => {
     return `Simplifier : 
   
 $$
-${statement}
+${getStatement(identifiers)}
 $$`;
 };
 const getAnswer = (identifiers) => {
@@ -21,11 +25,83 @@ const getAnswer = (identifiers) => {
 };
 const getKeys = (identifiers) => {
     const { randLetters, vectors } = identifiers;
+    const copy = [...randLetters];
     return [
         "overrightarrow",
-        ...randLetters.sort((a, b) => a.localeCompare(b)),
+        ...copy.sort((a, b) => a.localeCompare(b)),
     ];
 };
+const getHint = (identifiers) => {
+    return `Tu peux utiliser les deux propriétés suivantes : d'une part, pour tous points $A$ et $B$, 
+  
+$$
+-\\overrightarrow{AB} = \\overrightarrow{BA}
+$$
+
+et d'autre part, pour tous points $A$, $B$ et $C$, la relation de Chasles : 
+
+$$
+\\overrightarrow{AB} + \\overrightarrow{BC} = \\overrightarrow{AC}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randLetters, vectors } = identifiers;
+    const answerVec = `${randLetters[0]}${randLetters[vectors.length]}`;
+    const vecs = identifiers.vectors.map((v) => v.replace("\\overrightarrow{", "").replace("}", ""));
+    const positives = vecs.map((e) => (e[0] === "-" ? `+${e[2]}${e[1]}` : e));
+    const positiveStatement = positives
+        .map((e) => `${e[0]}\\overrightarrow{${e.slice(1)}}`)
+        .join("")
+        .slice(1);
+    const ordered = [];
+    ordered.push(positives.find((v) => v[1] === answerVec[0]));
+    for (let i = 1; i < positives.length; i++) {
+        ordered.push(positives.find((v) => v[1] === ordered[i - 1][2]));
+    }
+    const orderedStatement = ordered
+        .map((e) => `${e[0]}\\overrightarrow{${e.slice(1)}}`)
+        .join("")
+        .slice(1);
+    // for (let i = 0; i < positives.length; i++) {
+    //   const vec = positives[i];
+    //   const next = positives[i + 1];
+    //   if (vec[0] === next[2]) {
+    //     ordered.push(next, vec);
+    //     i++;
+    //   }
+    // }
+    let corr = "";
+    if (identifiers.vectors.some((vec) => vec[0] === "-")) {
+        corr += `On commence par supprimer les signes $-$, en utilisant la propriété : 
+    
+$$
+-\\overrightarrow{AB} = \\overrightarrow{BA}
+$$
+
+On a donc : 
+
+${alignTex([
+            ["", getStatement(identifiers)],
+            ["=", positiveStatement],
+        ])}
+`;
+    }
+    if (ordered.some((v, i) => positives[i] !== v)) {
+        corr += `On déplace les vecteurs de sorte à pouvoir utiliser la relation de Chasles : 
+
+${alignTex([
+            ["", positiveStatement],
+            ["=", orderedStatement],
+        ])}`;
+    }
+    return (corr +
+        `\n \n On applique la relation de Chasles : 
+  
+${alignTex([
+            ["", orderedStatement],
+            ["=", getAnswer(identifiers)],
+        ])}`);
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -33,6 +109,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -71,7 +149,7 @@ const isAnswerValid = (ans, { answer }) => {
 export const chasles = {
     id: "chasles",
     connector: "=",
-    label: "Relation de Chasles pour les vecteurs",
+    label: "Simplifier une somme de vecteurs par la relation de Chasles",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getChaslesQuestion, nb),
     qcmTimer: 60,
@@ -80,4 +158,5 @@ export const chasles = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/vectors/determinant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"determinant.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/determinant.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAwFF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAY7C,CAAC"}
+{"version":3,"file":"determinant.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/determinant.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA6GF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}

package/lib/exercises/math/geometry/vectors/determinant.js

@@ -2,21 +2,54 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getInstruction = (identifiers) => {
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getVectors = (identifiers) => {
     const u = new Vector("u", Number(identifiers.uCoords[0]).toTree(), Number(identifiers.uCoords[1]).toTree());
-    const v = new Vector("v", Number(identifiers.uCoords[0]).toTree(), Number(identifiers.uCoords[1]).toTree());
+    const v = new Vector("v", Number(identifiers.vCoords[0]).toTree(), Number(identifiers.vCoords[1]).toTree());
+    return { u, v };
+};
+const getInstruction = (identifiers) => {
+    const { u, v } = getVectors(identifiers);
     return `Soient les vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. 
   
-Calculer le déterminant $\\det(\\overrightarrow u;\\overrightarrow v)$.`;
+Calculer le déterminant $\\det(\\overrightarrow{u};\\overrightarrow{v})$.`;
 };
 const getAnswer = (identifiers) => {
-    const u = new Vector("u", Number(identifiers.uCoords[0]).toTree(), Number(identifiers.uCoords[1]).toTree());
-    const v = new Vector("v", Number(identifiers.uCoords[0]).toTree(), Number(identifiers.uCoords[1]).toTree());
+    const { u, v } = getVectors(identifiers);
     const answer = u.determinant(v).simplify();
     return answer.toTex();
 };
+const getHint = (identifiers) => {
+    const u = new Vector("u", "x".toTree(), "y".toTree());
+    const v = new Vector("v", "x'".toTree(), "y'".toTree());
+    return `Le déterminant de deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$ s'obtient par la formule : 
+  
+$$
+\\det(\\overrightarrow{u}, \\overrightarrow{v})= xy' - x'y
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const uGlobal = new Vector("u", "x".toTree(), "y".toTree());
+    const vGlobal = new Vector("v", "x'".toTree(), "y'".toTree());
+    const { u, v } = getVectors(identifiers);
+    return `Le déterminant de deux vecteurs $${uGlobal.toTexWithCoords()}$ et $${vGlobal.toTexWithCoords()}$ s'obtient par la formule : 
+  
+$$
+\\det(\\overrightarrow{u}, \\overrightarrow{v})= xy' - x'y
+$$
+
+Ici, on a donc : 
+
+${alignTex([
+        [
+            `\\det(\\overrightarrow{u}, \\overrightarrow{v})`,
+            "=",
+            `${u.determinant(v).toTex()}`,
+        ],
+        ["", "=", `${u.determinant(v).simplify().toTex()}`],
+    ])}`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -24,6 +57,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -36,11 +71,10 @@ const getDeterminantQuestion = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getPropositions = (n, { answer, uCoords, vCoords }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    const u = new Vector("u", new NumberNode(Number(uCoords[0])), new NumberNode(Number(uCoords[1])));
-    const v = new Vector("v", new NumberNode(Number(vCoords[0])), new NumberNode(Number(vCoords[1])));
+    const { u, v } = getVectors(identifiers);
     tryToAddWrongProp(propositions, u.scalarProduct(v).toTex());
     while (propositions.length < n) {
         const wrongAnswer = randint(-20, 20) + "";
@@ -63,4 +97,5 @@ export const determinant = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/python/pyWhileLoop1Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pyWhileLoop1Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyWhileLoop1Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;CAKZ,CAAC;AAwIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}
+{"version":3,"file":"pyWhileLoop1Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyWhileLoop1Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;CAKZ,CAAC;AAwIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}

package/lib/index.d.ts

@@ -1215,6 +1215,7 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     vars: string[];
     xs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    initTable: string[][];
 }, {}> | Exercise<{
     type: number;
     coeffs: number[];

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;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,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;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/tests/pdfExo.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pdfExo.test.d.ts","sourceRoot":"","sources":["../../src/tests/pdfExo.test.ts"],"names":[],"mappings":"AAmBA,OAAO,6BAA6B,CAAC"}
+{"version":3,"file":"pdfExo.test.d.ts","sourceRoot":"","sources":["../../src/tests/pdfExo.test.ts"],"names":[],"mappings":"AA2BA,OAAO,6BAA6B,CAAC"}

package/lib/tests/pdfExo.test.js

@@ -1,8 +1,8 @@
-import { subsetsOfKnownSets, } from "../exercises/math/index.js";
+import { valueTableCompletion, } from "../exercises/math/index.js";
 import { buildPdfForExercise } from "./pdfs/buildPDFForExercise.js";
 import "../prototypesEnhancement.js";
 try {
-    buildPdfForExercise(subsetsOfKnownSets);
+    buildPdfForExercise(valueTableCompletion);
 }
 catch (err) {
     console.log(err);

package/lib/tests/pdfs/buildPDFForExercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildPDFForExercise.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/buildPDFForExercise.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAyB,MAAM,6BAA6B,CAAC;AAI9E,eAAO,MAAM,mBAAmB,QAAS,QAAQ,SAkHhD,CAAC"}
+{"version":3,"file":"buildPDFForExercise.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/buildPDFForExercise.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAyB,MAAM,6BAA6B,CAAC;AAQ9E,eAAO,MAAM,mBAAmB,QAAS,QAAQ,SA0KhD,CAAC"}

package/lib/tests/pdfs/buildPDFForExercise.js

@@ -7,6 +7,9 @@ import fs from "fs";
 import latex from "node-latex";
 import { fileURLToPath } from "url";
 import path from "path";
+import { signTableToLatex } from "./signTableToLatex.js";
+import { varTableToLatex } from "./varTableToLatex.js";
+import { valueTableToLatex } from "./valueTableToLatex.js";
 export const buildPdfForExercise = (exo) => {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
@@ -26,11 +29,37 @@ export const buildPdfForExercise = (exo) => {
         for (const match of matches) {
             question.instruction = question.instruction.replace(match[0], ``);
         }
+        const signTableRegex = /<svg id=["']signTable["']>([\s\S]*?)<\/svg>/g;
+        const signTableMatches = question.instruction.matchAll(signTableRegex);
+        for (const match of signTableMatches) {
+            question.instruction = question.instruction.replace(match[0], signTableToLatex(JSON.parse(match[1])));
+        }
+        const varTableRegex = /<svg id=["']varTable["']>([\s\S]*?)<\/svg>/g;
+        const varTableMatches = question.instruction.matchAll(varTableRegex);
+        for (const match of varTableMatches) {
+            question.instruction = question.instruction.replace(match[0], varTableToLatex(JSON.parse(match[1])));
+        }
         const formatted = formatMarkdownToLatex(question.instruction);
         content += `
       ${formatted} \n
       `;
-        if (exo.answerType !== "GGB") {
+        if (question.initTable) {
+            if (exo.answerType === "signTable") {
+                content += signTableToLatex(question.initTable, true);
+            }
+            if (exo.answerType === "varTable") {
+                content += varTableToLatex(question.initTable, true);
+            }
+            if (exo.answerType === "valueTable") {
+                //!TODO
+                // content += mdTableToLatexTabular(question.initTable)
+                content += valueTableToLatex(question.initTable);
+            }
+        }
+        if (exo.answerType !== "GGB" &&
+            exo.answerType !== "valueTable" &&
+            exo.answerType !== "signTable" &&
+            exo.answerType !== "varTable") {
             propositions = exo.getPropositions(4, {
                 answer: question.answer,
                 ...question.identifiers,
@@ -66,17 +95,41 @@ export const buildPdfForExercise = (exo) => {
         content += "\\textbf{Correction : } ";
         if (question.correction) {
             content += formatMarkdownToLatex(question.correction);
+            if (question.answerTable) {
+                if (exo.answerType === "signTable") {
+                    content += signTableToLatex(question.answerTable);
+                }
+                else if (exo.answerType === "varTable") {
+                    content += varTableToLatex(question.answerTable);
+                }
+                else if (exo.answerType === "valueTable") {
+                    // à mettre dans la correction direct
+                }
+            }
         }
         else {
             if (exo.answerType === "GGB") {
                 content += "Correction GGB";
             }
             else {
-                const answers = propositions.filter((prop) => prop.isRightAnswer);
-                answers?.forEach((ans) => {
-                    content +=
-                        ans.format === "raw" ? ans.statement : `$${ans.statement}$`;
-                });
+                if (question.answerTable) {
+                    if (exo.answerType === "signTable") {
+                        content += signTableToLatex(question.answerTable);
+                    }
+                    else if (exo.answerType === "varTable") {
+                        content += varTableToLatex(question.answerTable);
+                    }
+                    else if (exo.answerType === "valueTable") {
+                        // à mettre dans la correction direct
+                    }
+                }
+                else {
+                    const answers = propositions.filter((prop) => prop.isRightAnswer);
+                    answers?.forEach((ans) => {
+                        content +=
+                            ans.format === "raw" ? ans.statement : `$${ans.statement}$`;
+                    });
+                }
             }
         }
         content += "\\end{correctionColored}";

package/lib/tests/pdfs/quizPdfPreambule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quizPdfPreambule.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/quizPdfPreambule.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,cA4E5B,CAAC"}
+{"version":3,"file":"quizPdfPreambule.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/quizPdfPreambule.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,cA6E5B,CAAC"}

package/lib/tests/pdfs/quizPdfPreambule.js

@@ -1,5 +1,7 @@
 export const quizPdfPreambule = () => {
     return `\\documentclass[a4paper, 8pt]{article}
+\\usepackage{tikz}
+\\usepackage{tkz-tab}
 \\usepackage[dvipsnames]{xcolor}
 \\usepackage[utf8]{inputenc}
 \\usepackage[T1]{fontenc}
@@ -19,7 +21,6 @@ export const quizPdfPreambule = () => {
 \\usepackage{qrcode}
 \\usepackage{listings}
 \\usepackage{hyperref}
-\\usepackage{tikz}
 \\usepackage{amssymb}
 \\usepackage{fancyhdr}
 \\usepackage{cancel}

package/lib/tests/pdfs/signTableToLatex.d.ts

@@ -0,0 +1,2 @@
+export declare const signTableToLatex: (arr: string[][], isInput?: boolean) => string;
+//# sourceMappingURL=signTableToLatex.d.ts.map

package/lib/tests/pdfs/signTableToLatex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signTableToLatex.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/signTableToLatex.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,QAAS,MAAM,EAAE,EAAE,8BA2B/C,CAAC"}

package/lib/tests/pdfs/signTableToLatex.js

@@ -0,0 +1,32 @@
+export const signTableToLatex = (arr, isInput = false) => {
+    const width = arr[0].length;
+    // const formated = arr.map((row) =>
+    //   row.map((e) => (e === "\\ " ? " " : e)),
+    // );
+    const size = isInput ? `[lgt = 1.5, espcl=2]` : `[lgt = 1.5, espcl=1.5]`;
+    return `\n \n 
+\\begin{tikzpicture}
+   \\tkzTabInit${size}{${arr
+        .map((row) => `${dollarize(row[0])} /1`)
+        .join(",")}}{${arr[0]
+        .slice(1)
+        .filter((e) => e !== "\\ ")
+        .map((e) => dollarize(e))
+        .join(",")}}
+  ${arr
+        .slice(1)
+        .map((row) => `\\tkzTabLine{${row
+        .slice(1)
+        .map((e) => (e === "0" ? "z" : e === "\\ " || e === "" ? " " : e))
+        .join(",")}}`)
+        .join("\n")}
+\\end{tikzpicture} \n \n 
+`;
+};
+const dollarize = (s) => {
+    if (s === " " || s === "")
+        return s;
+    if (s[0] === "$" && s[s.length - 1] === "$")
+        return s;
+    return "$" + s + "$";
+};

package/lib/tests/pdfs/valueTableToLatex.d.ts

@@ -0,0 +1,2 @@
+export declare const valueTableToLatex: (arr: string[][]) => string;
+//# sourceMappingURL=valueTableToLatex.d.ts.map

package/lib/tests/pdfs/valueTableToLatex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueTableToLatex.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/valueTableToLatex.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,QAAS,MAAM,EAAE,EAAE,WAQhD,CAAC"}

package/lib/tests/pdfs/valueTableToLatex.js

@@ -0,0 +1,18 @@
+export const valueTableToLatex = (arr) => {
+    const width = arr[0].length;
+    const alignement = "|c".repeat(width) + "|";
+    let res = `\n \n \\begin{center}\\begin{tabular}{${alignement}} \n ` +
+        arr.map((row, i) => formatRow(row, i)).join(" \\tabularnewline ") +
+        "\\tabularnewline \\hline \\end{tabular}\\end{center} \n \n";
+    return res;
+};
+const dollarize = (s) => {
+    if (s === " " || s === "")
+        return s;
+    if (s[0] === "$" && s[s.length - 1] === "$")
+        return s;
+    return "$" + s + "$";
+};
+const formatRow = (row, i) => {
+    return "\\hline " + row.map((el) => dollarize(el)).join(" & ");
+};

package/lib/tests/pdfs/varTableToLatex.d.ts

@@ -0,0 +1,2 @@
+export declare const varTableToLatex: (arr: string[][], isInput?: boolean) => string;
+//# sourceMappingURL=varTableToLatex.d.ts.map

package/lib/tests/pdfs/varTableToLatex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varTableToLatex.d.ts","sourceRoot":"","sources":["../../../src/tests/pdfs/varTableToLatex.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,QAAS,MAAM,EAAE,EAAE,8BA2C9C,CAAC"}

package/lib/tests/pdfs/varTableToLatex.js

@@ -0,0 +1,58 @@
+export const varTableToLatex = (arr, isInput = false) => {
+    if (isInput)
+        return getInputVarTable(arr);
+    const formated = arr.map((row) => row.map((e) => (e === "" || e === "\\ " ? " " : e)));
+    const final = [formated[0], [formated[2][0]]];
+    for (let i = 1; i < arr[0].length; i++) {
+        const data = formated[1][i] !== " "
+            ? formated[1][i]
+            : formated[2][i] !== " "
+                ? formated[2][i]
+                : formated[3][i];
+        final[1][i] = data;
+    }
+    const varLine = [];
+    for (let i = 1; i < final[1].length; i++) {
+        const current = final[1][i];
+        if (current === "\\nearrow" || current === "\\searrow")
+            continue;
+        if (i === final[1].length - 1) {
+            const prev = final[1][i - 1];
+            varLine.push(`${prev === "\\nearrow" ? "+" : "-"}/ ${dollarize(current)}`);
+        }
+        else {
+            const next = final[1][i + 1];
+            varLine.push(`${next === "\\nearrow" ? "-" : "+"}/ ${dollarize(current)}`);
+        }
+    }
+    return `\n \n 
+\\begin{tikzpicture}
+   \\tkzTabInit[lgt=1.5,espcl=1.5]{${final
+        .map((row, i) => `${dollarize(row[0])} /${i === 0 ? "1" : "1.5"}`)
+        .join(",")}}{${final[0]
+        .slice(1)
+        .filter((e) => e !== " ")
+        .map((e) => dollarize(e))
+        .join(",")}}
+  \\tkzTabVar{${varLine.join(",")}}
+\\end{tikzpicture} \n \n
+`;
+};
+const dollarize = (s) => {
+    if (s === " " || s === "")
+        return s;
+    if (s[0] === "$" && s[s.length - 1] === "$")
+        return s;
+    return "$" + s + "$";
+};
+const getInputVarTable = (arr) => {
+    const width = arr[0].length;
+    const alignement = "|c|" + "c".repeat(width - 1) + "|";
+    let res = ` \\begin{center}\\begin{tabular}{${alignement}} \n \\hline ` +
+        arr.map((row, i) => formatRow(row, i)).join(" \\tabularnewline ") +
+        "\\tabularnewline \\hline \\end{tabular}\\end{center} ";
+    return res;
+};
+const formatRow = (row, i) => {
+    return ((i === 1 ? "\\hline " : "") + row.map((el) => dollarize(el)).join(" & "));
+};

package/lib/tests/questionTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIjE,eAAO,MAAM,YAAY,QAAS,QAAQ,YAAY,QAAQ;;;CAkN7D,CAAC"}
+{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIjE,eAAO,MAAM,YAAY,QAAS,QAAQ,YAAY,QAAQ;;;CA4N7D,CAAC"}

package/lib/tests/questionTest.js

@@ -37,6 +37,12 @@ export const questionTest = (exo, question) => {
             throw new Error(`exo ${exo.id} has studentGgbOptions but answerType is not GGB`);
         }
     }
+    if (question.initTable?.length &&
+        exo.answerType !== "valueTable" &&
+        exo.answerType !== "varTable" &&
+        exo.answerType !== "signTable") {
+        throw new Error(`exo ${exo.id} has init table but is not tableExo`);
+    }
     if (exo.answerType === "GGB") {
         if (!question.ggbAnswer?.length)
             throw new Error(`exo ${exo.id} has no ggbAnswer`);
@@ -48,6 +54,8 @@ export const questionTest = (exo, question) => {
         exo.answerType === "signTable") {
         if (!question.answerTable?.length)
             throw new Error(`exo ${exo.id} has no answerTable`);
+        if (!question.initTable?.length)
+            throw new Error(`exo ${exo.id} has no initTable`);
     }
     else if (exo.answerType !== "QCU" && exo.answerType !== "QCM") {
         if (!question.answer)

package/package.json

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