math-exercises 3.0.87 → 3.0.89

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

@@ -1,7 +1,8 @@
 import { Point } from "../math/geometry/point.js";
 import { IntervalNode } from "../tree/nodes/sets/intervalNode.js";
 export declare abstract class SplineConstructor {
-    random(): Spline;
+    static random(): Spline;
+    static getAdequatePoints(nbOfPoints?: number): [number, number][];
 }
 export declare class Spline {
     points: number[][];

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

@@ -1 +1 @@
-{"version":3,"file":"spline.d.ts","sourceRoot":"","sources":["../../src/geogebra/spline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAIrD,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAKrE,8BAAsB,iBAAiB;IACrC,MAAM;CAQP;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}
+{"version":3,"file":"spline.d.ts","sourceRoot":"","sources":["../../src/geogebra/spline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAIrD,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AAKrE,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM;IASb,MAAM,CAAC,iBAAiB,CAAC,UAAU,SAAI;CAsCxC;AACD,qBAAa,MAAM;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;gBAEP,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE;IAuDpD,WAAW;CAUZ"}

package/lib/geogebra/spline.js

@@ -2,14 +2,52 @@ import { randfloat } from "../math/utils/random/randfloat.js";
 import { randint } from "../math/utils/random/randint.js";
 import { ClosureType } from "../tree/nodes/sets/closure.js";
 import { IntervalNode } from "../tree/nodes/sets/intervalNode.js";
+import { coinFlip } from "../utils/alea/coinFlip.js";
 import { doWhile } from "../utils/doWhile.js";
 import { randomColor } from "./colors.js";
 export class SplineConstructor {
-    random() {
+    static random() {
         const a = randint(-10, 0);
         const b = doWhile(() => randint(0, 10), (x) => Math.abs(x - a) < 5);
         return new Spline(new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF));
     }
+    static getAdequatePoints(nbOfPoints = 4) {
+        let xSolutions = [];
+        const nb = nbOfPoints;
+        // const nb = 2;
+        for (let i = 0; i < nb; i++) {
+            xSolutions.push(randint(-9, 10, xSolutions));
+        }
+        xSolutions.sort((a, b) => a - b);
+        const yValue = randint(-5, 6);
+        const splinePoints = [];
+        let prevYWasAbove = coinFlip();
+        if (coinFlip()) {
+            const y = prevYWasAbove ? randint(-2, 0) : randint(1, 3);
+            prevYWasAbove = y > 0;
+            splinePoints.push([xSolutions[0] - (1 + Math.random() * 3), yValue + y]);
+        }
+        for (let i = 0; i < xSolutions.length; i++) {
+            splinePoints.push([xSolutions[i], yValue]);
+            if (i < xSolutions.length - 1) {
+                const mid = (xSolutions[i] + xSolutions[i + 1]) / 2;
+                const distance = xSolutions[i + 1] - xSolutions[i];
+                const x = mid + ((Math.random() * 2) / 5) * (distance / 2);
+                const y = prevYWasAbove ? randint(-2, 0) : randint(1, 3);
+                prevYWasAbove = y > 0;
+                splinePoints.push([x, yValue + y]);
+            }
+        }
+        if (coinFlip() || splinePoints.length < 4) {
+            const y = prevYWasAbove ? randint(-2, 0) : randint(1, 3);
+            prevYWasAbove = y > 0;
+            splinePoints.push([
+                xSolutions[xSolutions.length - 1] + (1 + Math.random() * 3),
+                yValue + y,
+            ]);
+        }
+        return splinePoints;
+    }
 }
 export class Spline {
     points;

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;
@@ -897,9 +903,15 @@ 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[][];
+}, {}> | Exercise<{
+    points: number[][];
+    initTable: string[][];
 }, {}> | Exercise<{
     k: number;
 }, {}> | Exercise<{
@@ -1283,18 +1295,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;
@@ -1398,6 +1398,23 @@ 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<{
     trinom: number[];
 }, {}> | Exercise<{
@@ -1681,6 +1698,8 @@ declare const mathExercises: (Exercise<{
     price: number;
     evolution: number;
     askingFinalPrice: boolean;
+}, {}> | Exercise<{
+    evolutions: number[];
 }, {}> | Exercise<{
     initialCapital: number;
     rate: number;
@@ -1694,6 +1713,9 @@ declare const mathExercises: (Exercise<{
 }, {
     withFormula?: boolean;
 }> | Exercise<{
+    x: number;
+    y: number;
+}, {}> | Exercise<{
     int: number;
     power: number;
 }, {}> | Exercise<{
@@ -2252,6 +2274,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;
@@ -2350,6 +2375,19 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     points: number[][];
     labels: string[];
+}, {}> | Exercise<{
+    affineCoeffs: number[];
+    initTable: string[][];
+}, {}> | Exercise<{
+    k: number;
+    x1: number;
+    x2: number;
+    C: number;
+    initTable: string[][];
+}, {}> | Exercise<{
+    affine1Coeffs: number[];
+    affine2Coeffs: 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/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"}