math-exercises 3.0.88 → 3.0.90

package/lib/exercises/math/tests/testVarTable.js

@@ -0,0 +1,147 @@
+import { addValidProp, shuffleProps, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getFunc = (identifiers) => {
+    const { k, x1, x2, C } = identifiers;
+    return (x) => 2 * k * x ** 3 - 3 * k * (x1 + x2) * x ** 2 + 6 * x1 * x2 * k * x + C;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        throw Error("QCM not implemented");
+    }
+    return shuffleProps(propositions, n);
+};
+const getGGBOptions = (identifiers) => {
+    const { k, x1, x2, C } = identifiers;
+    const commands = [
+        `f(x) = 2*${k}*x^3 - 3*${k}*(${x1}+(${x2}))*x^2 + 6*${x1}*${x2}*${k}*x + ${C}`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: [-10, 10, -10, 10],
+    });
+};
+const getAnswerTable = (identifiers) => {
+    const { k, x1, x2, C } = identifiers;
+    const fct = getFunc(identifiers);
+    const fx1 = fct(x1);
+    const fx2 = fct(x2);
+    const vars = k > 0
+        ? ["\\nearrow", "\\searrow", "\\nearrow"]
+        : ["\\searrow", "\\nearrow", "\\searrow"];
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            x1.toTree().toTex(),
+            "\\ ",
+            x2.toTree().toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        [
+            "\\ ",
+            "\\ ",
+            "\\ ",
+            k > 0 ? fx1.toTree().toTex() : "\\ ",
+            "\\ ",
+            k > 0 ? "\\ " : fx2.toTree().toTex(),
+            "\\ ",
+            "\\ ",
+        ],
+        ["$f(x)$", "\\ ", vars[0], "\\ ", vars[1], "\\ ", vars[2], "\\ "],
+        [
+            "\\ ",
+            "\\ ",
+            "\\ ",
+            k > 0 ? fx2.toTree().toTex() : "\\ ",
+            "\\ ",
+            k > 0 ? "\\ " : fx1.toTree().toTex(),
+            "\\ ",
+            "\\ ",
+        ],
+    ];
+};
+const getInstruction = (identifiers) => {
+    return `Dresser le tableau de variations de la fonction $f$ définie sur $\\mathbb{R}$ dont la courbe représentative est donnée ci-dessous :`;
+};
+const getHint = (identifiers) => {
+    return `indice`;
+};
+const getCorrection = (identifiers) => {
+    return `correction : le tableau attendu est donc : 
+  
+`;
+};
+const getKeys = (identifiers) => {
+    return ["inf"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return ans.every((row, i) => row.every((cell, j) => cell === answerTable[i][j]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTestSignTableQuestion = (ops) => {
+    const k = randint(-4, 5, [0]);
+    let x1 = randint(-9, 10);
+    let x2 = randint(-9, 10, [x1]);
+    if (x1 > x2)
+        [x1, x2] = [x2, x1];
+    const C = randint(-9, 10);
+    const initTable = [
+        ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+        ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+        ["$f(x)$", "\\ ", "", "", "", "", "", "\\ "],
+        ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+    ];
+    const identifiers = {
+        k,
+        x1,
+        x2,
+        C,
+        initTable,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const testVarTable = {
+    id: "testVarTable",
+    label: "Test Tableau Variations basique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTestSignTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "varTable",
+    hasGeogebra: true,
+};

package/lib/exercises/math/trigonometry/index.d.ts

@@ -13,4 +13,5 @@ export * from "./mainAngleMeasure.js";
 export * from "./degreeToRadians.js";
 export * from "./arcLength.js";
 export * from "./equationCosOnRandomInterval.js";
+export * from "./trigoFundamentalEquation.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC"}

package/lib/exercises/math/trigonometry/index.js

@@ -13,3 +13,4 @@ export * from "./mainAngleMeasure.js";
 export * from "./degreeToRadians.js";
 export * from "./arcLength.js";
 export * from "./equationCosOnRandomInterval.js";
+export * from "./trigoFundamentalEquation.js";

package/lib/exercises/math/trigonometry/trigoFundamentalEquation.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    givenValue: NodeIdentifiers;
+    isCosGiven: boolean;
+};
+export declare const trigoFundamentalEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigoFundamentalEquation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trigoFundamentalEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigoFundamentalEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,eAAe,CAAC;IAC5B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAwIF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAmB1D,CAAC"}

package/lib/exercises/math/trigonometry/trigoFundamentalEquation.js

@@ -0,0 +1,151 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { sqrt } from "../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.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 { probaFlip } from "../../../utils/alea/probaFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, givenValue }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const value = reifyAlgebraic(givenValue);
+    tryToAddWrongProp(propositions, substract(1, value).simplify().toTex());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randfloat(0, 1, 1).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { givenValue, isCosGiven } = identifiers;
+    const squared = substract(1, square(reifyAlgebraic(givenValue))).simplify();
+    return sqrt(squared).simplify();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { givenValue, isCosGiven } = identifiers;
+    const node = isCosGiven
+        ? `\\cos(\\alpha) = ${reifyAlgebraic(givenValue).toTex()}`
+        : `\\sin(\\alpha) = ${reifyAlgebraic(givenValue).toTex()}`;
+    return `$\\alpha$ est la mesure en degrés d'un angle aigu dans un triangle rectangle.
+  
+Calculer $${isCosGiven ? "\\sin" : "\\cos"}(\\alpha)$ sachant que : 
+
+$$
+${node}
+$$
+
+Donner la valeur exacte ou une valeur arrondie au centième.`;
+};
+const getHint = (identifiers) => {
+    return `Utilise la relation : 
+  
+$$
+\\cos^2(\\alpha) + \\sin^2(\\alpha) = 1
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { givenValue, isCosGiven } = identifiers;
+    const valueNode = reifyAlgebraic(givenValue);
+    const squareValue = square(valueNode).simplify();
+    const node = isCosGiven
+        ? `\\cos(\\alpha) = ${valueNode.toTex()}`
+        : `\\sin(\\alpha) = ${valueNode.toTex()}`;
+    const squareNode = isCosGiven
+        ? `\\cos^2(\\alpha) = ${squareValue.toTex()}`
+        : `\\sin^2(\\alpha) = ${squareValue.toTex()}`;
+    const fct = isCosGiven ? "\\sin" : "\\cos";
+    return `On utilise la relation suivante : 
+  
+$$
+\\cos^2(\\alpha) + \\sin^2(\\alpha) = 1
+$$
+
+Puisque $${node}$, on a donc :
+
+$$
+${squareNode}
+$$
+
+Donc : 
+
+$$
+${fct}^2(\\alpha) = 1 - ${squareValue.toTex()} = ${substract(1, squareValue)
+        .simplify()
+        .toTex()}
+$$
+
+Puisque l'angle est aigu, on cherche une valeur positive. 
+
+On en déduit donc : 
+
+$$
+${fct}(\\alpha) = ${getAnswer(identifiers)}
+$$
+  `;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        const answerNode = getAnswerNode(identifiers);
+        const simp = parsed.simplify().toTex();
+        return (simp === answer ||
+            Math.abs(parsed.evaluate() - answerNode.evaluate()) < 0.01);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTrigoFundamentalEquationQuestion = (ops) => {
+    const isCosGiven = coinFlip();
+    const givenValue = probaFlip(0.3)
+        ? randfloat(0, 1, 1).toTree()
+        : coinFlip()
+            ? RationalConstructor.randomIrreductibleProba().toTree()
+            : frac(sqrt(random([2, 3])), 2);
+    const identifiers = {
+        isCosGiven,
+        givenValue: givenValue.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const trigoFundamentalEquation = {
+    id: "trigoFundamentalEquation",
+    connector: "=",
+    label: "Calculer le cosinus d'un angle à partir de son sinus (ou inversement)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigoFundamentalEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/geogebra/parsers/ggbPointsToPoints.d.ts

@@ -0,0 +1,3 @@
+import { Point } from "../../math/geometry/point.js";
+export declare const ggbPointsToPoints: (commands: string[]) => Point[];
+//# sourceMappingURL=ggbPointsToPoints.d.ts.map

package/lib/geogebra/parsers/ggbPointsToPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ggbPointsToPoints.d.ts","sourceRoot":"","sources":["../../../src/geogebra/parsers/ggbPointsToPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,MAAM,8BAA8B,CAAC;AAGvE,eAAO,MAAM,iBAAiB,aAAc,MAAM,EAAE,YASnD,CAAC"}

package/lib/geogebra/parsers/ggbPointsToPoints.js

@@ -0,0 +1,12 @@
+import { Point } from "../../math/geometry/point.js";
+import { ggbPointToCoords } from "./ggbPointToCoords.js";
+export const ggbPointsToPoints = (commands) => {
+    const points = commands.filter((s) => s.match(/^[A-Z]=\(/));
+    const finalPoints = points.map((p) => {
+        const split = p.split("=");
+        const name = split[0];
+        const { x, y } = ggbPointToCoords(split[1]);
+        return new Point(p.split("=")[0], x, y);
+    });
+    return finalPoints;
+};

package/lib/index.d.ts

@@ -72,6 +72,12 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     point: import("./math/geometry/point.js").PointIdentifiers;
     bounding: number;
+}, {}> | Exercise<{
+    type: number;
+    a: number;
+    b?: number;
+    c?: number;
+    d?: number;
 }, {}> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -831,6 +837,10 @@ declare const mathExercises: (Exercise<{
     xB: number;
     yA: number;
     yB: number;
+}, {}> | Exercise<{
+    phrase: number;
+    initial: number;
+    growth: number;
 }, {}> | Exercise<{
     xValue: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     polynomeCoeffs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
@@ -897,6 +907,9 @@ declare const mathExercises: (Exercise<{
     inegalitySymbol: import("./math/inequations/inequation.js").InegalitySymbols;
     a: number;
     b: number;
+}, {}> | Exercise<{
+    a: number;
+    type: number;
 }, {}> | Exercise<{
     coeffs: number[];
     initTable: string[][];
@@ -1062,6 +1075,10 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     type: string;
     fctCmd: string;
+}, {}> | Exercise<{
+    isEven: boolean;
+    isLeftSideGiven: boolean;
+    givenPointsCoords: number[][];
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -1120,11 +1137,38 @@ declare const mathExercises: (Exercise<{
 }, {
     instructionType: string;
 }> | Exercise<{
+    affineCoeffs: number[];
+    initTable: string[][];
+}, {}> | Exercise<{
+    affine1Coeffs: number[];
+    affine2Coeffs: number[];
+    initTable: string[][];
+}, {}> | Exercise<{
+    signs: string[];
+    xs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    initTable: string[][];
+    a: number;
+    x1: number;
+    x2: number;
+    x3: number;
+}, {}> | Exercise<{
     xValues: number[];
     yValues: number[];
     isAskingX: boolean;
     isAskingMin: boolean;
     intervalXIndexes: number[];
+}, {}> | Exercise<{
+    type: number;
+    coeffs: number[];
+    initTable: string[][];
+}, {}> | Exercise<{
+    xs: number[];
+    ys: number[];
+    vars: string[];
+    a: number;
+    b: number;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -1286,18 +1330,6 @@ declare const mathExercises: (Exercise<{
     B: number[];
     startLetter: string;
     endLetter: string;
-}, {}> | Exercise<{
-    xu: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    yu: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    xv: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    yv: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, {}> | Exercise<{
-    xA: number;
-    xB: number;
-    xC: number;
-    yA: number;
-    yB: number;
-    yC: number;
 }, {}> | Exercise<{
     xA: number;
     xB: number;
@@ -1401,6 +1433,26 @@ declare const mathExercises: (Exercise<{
     coeff: number;
 }, {}> | Exercise<{
     pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
+}, {}> | Exercise<{
+    xu: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    yu: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    xv: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    yv: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    xA: number;
+    xB: number;
+    xC: number;
+    yA: number;
+    yB: number;
+    yC: number;
+}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    c: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    d: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    expression: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    type: number;
 }, {}> | Exercise<{
     trinom: number[];
 }, {}> | Exercise<{
@@ -2260,6 +2312,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     degree: number;
     leftBoundPiMultiple: number;
+}, {}> | Exercise<{
+    givenValue: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isCosGiven: boolean;
 }, {}> | Exercise<{
     initialValue: number;
     step: number;
@@ -2358,6 +2413,12 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     points: number[][];
     labels: string[];
+}, {}> | Exercise<{
+    k: number;
+    x1: number;
+    x2: number;
+    C: number;
+    initTable: string[][];
 }, {}>)[];
 declare const pcExercises: (Exercise<{
     atomicMass: 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/latexTester.js

@@ -255,4 +255,6 @@ const validCmds = [
     "\\lstinline",
     "\\subset",
     "\\not",
+    "\\nearrow",
+    "\\searrow",
 ];

package/lib/math/numbers/reals/real.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"real.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/real.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAC;AASlE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClD,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM;CAUd;AACD,qBAAa,IAAK,YAAW,MAAM;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBACL,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKtC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM,IAAI,aAAa;CAIxB;AAED,8BAAsB,qBAAqB;IACzC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,EACxB,kBAA0B,EAC1B,SAAc,GACf;;;KAAA,GAAG,UAAU;IASd,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW,GAAG,UAAU;CAIxD;AAED,qBAAa,UAAW,SAAQ,IAAI;IAClC,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAK3B,cAAc;IAMd,mBAAmB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAkBvC,sDAAsD;IACtD,aAAa,IAAI,MAAM;IAMvB,QAAQ,IAAI,MAAM;IA4BlB,KAAK,IAAI,MAAM;IAIf,MAAM;CAGP"}
+{"version":3,"file":"real.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/real.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAC;AASlE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClD,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM;CAUd;AACD,qBAAa,IAAK,YAAW,MAAM;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBACL,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKtC,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM,IAAI,aAAa;CAIxB;AAED,8BAAsB,qBAAqB;IACzC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,EACxB,kBAA0B,EAC1B,SAAc,GACf;;;KAAA,GAAG,UAAU;IASd,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW,GAAG,UAAU;CAIxD;AAED,qBAAa,UAAW,SAAQ,IAAI;IAClC,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAK3B,cAAc;IAMd,mBAAmB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAkBvC,sDAAsD;IACtD,aAAa,IAAI,MAAM;IAMvB,QAAQ,IAAI,MAAM;IA+BlB,KAAK,IAAI,MAAM;IAIf,MAAM;CAGP"}

package/lib/math/numbers/reals/real.js

@@ -1,6 +1,7 @@
 import { isSquare } from "../../../math/utils/arithmetic/isSquare.js";
 import { primeFactors } from "../../../math/utils/arithmetic/primeFactors.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
 import { SqrtNode } from "../../../tree/nodes/functions/sqrtNode.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { PiNode } from "../../../tree/nodes/numbers/piNode.js";
@@ -100,8 +101,12 @@ export class SquareRoot extends Real {
             return new Integer(0);
         if (this.operand === 1)
             return new Integer(1);
-        if (Math.floor(this.operand) !== this.operand)
-            return new Decimal(Math.sqrt(this.operand));
+        if (Math.floor(this.operand) !== this.operand) {
+            const ev = Math.sqrt(this.operand);
+            if (round(ev, 8) === ev)
+                return new Decimal(ev);
+            return this;
+        }
         const [outsideSqrt, insideSqrt] = this.getSimplifiedCoeffs();
         const simplified = insideSqrt !== 1
             ? new Real(outsideSqrt * Math.sqrt(insideSqrt), `${outsideSqrt === 1 ? "" : `${outsideSqrt}`}\\sqrt{${insideSqrt}}`)

package/lib/playground.d.ts.map

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

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

@@ -1 +1 @@
-{"version":3,"file":"exoTest.d.ts","sourceRoot":"","sources":["../../src/tests/exoTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIvD,eAAO,MAAM,OAAO,QAAS,QAAQ;;;;CAuFpC,CAAC"}
+{"version":3,"file":"exoTest.d.ts","sourceRoot":"","sources":["../../src/tests/exoTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAIvD,eAAO,MAAM,OAAO,QAAS,QAAQ;;;;CA+FpC,CAAC"}

package/lib/tests/exoTest.js

@@ -21,14 +21,18 @@ export const exoTest = (exo) => {
     generatorTime = after - before;
     if (exo.answerType !== "free" &&
         exo.answerType !== "GGB" &&
-        exo.answerType !== "valueTable") {
+        exo.answerType !== "valueTable" &&
+        exo.answerType !== "varTable" &&
+        exo.answerType !== "signTable") {
         if (!exo.getPropositions)
             throw new Error(`exo ${exo.id} has no getPropositions`);
     }
     if (exo.answerType !== "QCM" &&
         exo.answerType !== "QCU" &&
         exo.answerType !== "GGB" &&
-        exo.answerType !== "valueTable") {
+        exo.answerType !== "valueTable" &&
+        exo.answerType !== "varTable" &&
+        exo.answerType !== "signTable") {
         if (!exo.isAnswerValid)
             throw new Error(`exo ${exo.id} has no isAnswerValid`);
     }
@@ -36,7 +40,9 @@ export const exoTest = (exo) => {
         if (!exo.isGGBAnswerValid)
             throw new Error(`exo ${exo.id} has no isGGBAnswerValid`);
     }
-    if (exo.answerType === "valueTable") {
+    if (exo.answerType === "valueTable" ||
+        exo.answerType === "varTable" ||
+        exo.answerType === "signTable") {
         if (!exo.isAnswerTableValid)
             throw new Error(`exo ${exo.id} has no isAnswerTableValid`);
     }

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;;;CAuM7D,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;;;CAkN7D,CAAC"}

package/lib/tests/questionTest.js

@@ -43,7 +43,9 @@ export const questionTest = (exo, question) => {
         if (!question.studentGgbOptions?.coords?.length)
             throw new Error(`exo ${exo.id} has no studentGgbOptions Coords`);
     }
-    else if (exo.answerType === "valueTable") {
+    else if (exo.answerType === "valueTable" ||
+        exo.answerType === "varTable" ||
+        exo.answerType === "signTable") {
         if (!question.answerTable?.length)
             throw new Error(`exo ${exo.id} has no answerTable`);
     }
@@ -62,14 +64,17 @@ export const questionTest = (exo, question) => {
         }
     }
     if (question.answerTable) {
-        for (const cell of question.answerTable.flat()) {
-            if (cell.match(dotDecimalPattern))
-                throw new Error(`exo ${exo.id} has invalid number format`);
-            if (cell.includes("[object Object]"))
-                throw new Error(`exo ${exo.id} has invalid answer`);
-            if (question.answerFormat !== "raw") {
-                if (!latexTester(cell, true))
+        for (let i = 0; i < question.answerTable.length; i++) {
+            for (let j = 0; j < question.answerTable[0].length; j++) {
+                const cell = question.answerTable[i][j];
+                if (cell.match(dotDecimalPattern))
+                    throw new Error(`exo ${exo.id} has invalid number format`);
+                if (cell.includes("[object Object]"))
                     throw new Error(`exo ${exo.id} has invalid answer`);
+                if (question.answerFormat !== "raw") {
+                    if (!latexTester(cell, j === 0 ? false : true))
+                        throw new Error(`exo ${exo.id} has invalid answer`);
+                }
             }
         }
     }
@@ -120,7 +125,9 @@ export const questionTest = (exo, question) => {
     if (exo.answerType !== "QCM" &&
         exo.answerType !== "QCU" &&
         exo.answerType !== "GGB" &&
-        exo.answerType !== "valueTable") {
+        exo.answerType !== "valueTable" &&
+        exo.answerType !== "signTable" &&
+        exo.answerType !== "varTable") {
         if (!question.keys)
             throw new Error(`exo ${exo.id} has no keys`);
         const answer = question.answer;
@@ -134,7 +141,9 @@ export const questionTest = (exo, question) => {
     }
     if (exo.answerType !== "free" &&
         exo.answerType !== "GGB" &&
-        exo.answerType !== "valueTable") {
+        exo.answerType !== "valueTable" &&
+        exo.answerType !== "varTable" &&
+        exo.answerType !== "signTable") {
         let before = Date.now();
         console.log("will generate props : ", exo.id, "ids :", question.identifiers);
         const props = exo.getPropositions(4, {