math-exercises 2.2.8 → 2.2.10

package/lib/exercises/math/sequences/geometric/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qBAAqB,CAAC;AACpC,cAAc,0CAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qBAAqB,CAAC;AACpC,cAAc,0CAA0C,CAAC;AACzD,cAAc,iCAAiC,CAAC"}

package/lib/exercises/math/sequences/geometric/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./geometricRecurrenceFormulaUsage"), exports);
 __exportStar(require("./geometricFindExplicitFormulaFirstTermRandom"), exports);
 __exportStar(require("./geometricFindTerm"), exports);
 __exportStar(require("./geometricRecognizeReasonFromFirstTerms"), exports);
+__exportStar(require("./geometricFirstTermsGeneralSum"), exports);

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

@@ -3,4 +3,6 @@ export * from "./geometric";
 export * from "./explicitFormulaUsage";
 export * from "./genericSequenceVariations";
 export * from "./recurrenceFormulaUsage";
+export * from "./sequenceEvaluation";
+export * from "./sequencePlot";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC"}

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

@@ -19,3 +19,5 @@ __exportStar(require("./geometric"), exports);
 __exportStar(require("./explicitFormulaUsage"), exports);
 __exportStar(require("./genericSequenceVariations"), exports);
 __exportStar(require("./recurrenceFormulaUsage"), exports);
+__exportStar(require("./sequenceEvaluation"), exports);
+__exportStar(require("./sequencePlot"), exports);

package/lib/exercises/math/sequences/sequenceEvaluation.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    termeid: number;
+    affine: number[];
+    termeAdd: number;
+    termeMult: number;
+};
+export declare const sequenceEvaluation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sequenceEvaluation.d.ts.map

package/lib/exercises/math/sequences/sequenceEvaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceEvaluation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequenceEvaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoLF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/math/sequences/sequenceEvaluation.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequenceEvaluation = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const affine_1 = require("../../../math/polynomials/affine");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const getSequenceEvaluationQuestion = () => {
+    const termeid = (0, randint_1.randint)(1, 3);
+    const a = (0, randint_1.randint)(-10, 10, [0]);
+    const b = (0, randint_1.randint)(-10, 10);
+    const affine = new affine_1.Affine(a, b, "n");
+    let terme;
+    let termeAdd = 0;
+    let termeMult = 1;
+    if (termeid === 1) {
+        termeAdd = (0, randint_1.randint)(1, 4);
+        terme = new addNode_1.AddNode(new variableNode_1.VariableNode("n"), new numberNode_1.NumberNode(termeAdd));
+    }
+    else if (termeid === 2) {
+        termeMult = (0, randint_1.randint)(2, 4);
+        terme = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n"));
+    }
+    else {
+        termeAdd = (0, randint_1.randint)(1, 4);
+        termeMult = (0, randint_1.randint)(1, 4);
+        terme = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(termeAdd));
+    }
+    let answer;
+    if (termeid === 1) {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        answer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else if (termeid === 2) {
+        const innerTerm = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n"));
+        answer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        answer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    const question = {
+        answer: answer.toTex(),
+        instruction: `Soit $(u_n)$ une suite telle que $u_n = ${affine.toTex()}$. Exprimer $u_{${terme.toTex()}}$.`,
+        keys: ["n"],
+        answerFormat: "tex",
+        identifiers: {
+            termeid,
+            affine: [a, b],
+            termeAdd,
+            termeMult,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, termeid, affine, termeAdd, termeMult }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const a = affine[0];
+    const b = affine[1];
+    let wrongAnswer;
+    if (termeid === 1) {
+        const wrongInnerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * (termeAdd + (0, randint_1.randint)(-2, 2))));
+        wrongAnswer = new addNode_1.AddNode(wrongInnerTerm, new numberNode_1.NumberNode(b + (0, randint_1.randint)(-5, 5))).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else if (termeid === 2) {
+        const wrongInnerTerm = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * (termeMult + (0, randint_1.randint)(-1, 1))), new variableNode_1.VariableNode("n"));
+        wrongAnswer = new addNode_1.AddNode(wrongInnerTerm, new numberNode_1.NumberNode(b + (0, randint_1.randint)(-5, 5))).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else {
+        const wrongInnerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * (termeMult + (0, randint_1.randint)(-1, 1))), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * (termeAdd + (0, randint_1.randint)(-2, 2))));
+        wrongAnswer = new addNode_1.AddNode(wrongInnerTerm, new numberNode_1.NumberNode(b + (0, randint_1.randint)(-5, 5))).simplify({
+            forbidFactorize: true,
+        });
+    }
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new affine_1.Affine((0, randint_1.randint)(-10, 10, [0]), (0, randint_1.randint)(-10, 10), "n").toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { affine, termeid, termeAdd, termeMult }) => {
+    const a = affine[0];
+    const b = affine[1];
+    let terme;
+    if (termeid === 1) {
+        terme = new addNode_1.AddNode(new variableNode_1.VariableNode("n"), new numberNode_1.NumberNode(termeAdd));
+    }
+    else if (termeid === 2) {
+        terme = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n"));
+    }
+    else {
+        terme = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(termeAdd));
+    }
+    let validanswer;
+    if (termeid === 1) {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        validanswer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else if (termeid === 2) {
+        const innerTerm = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n"));
+        validanswer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        validanswer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    const latexs = validanswer.toAllValidTexs();
+    return latexs.includes(ans);
+};
+exports.sequenceEvaluation = {
+    id: "sequenceEvaluation",
+    label: "Exprimer $u_{f(n)}$ en connaissant $u_n$",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequenceEvaluationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/sequences/sequencePlot.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    nValue: number;
+    points: number[][];
+    isArithmetic: boolean;
+};
+export declare const sequencePlot: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sequencePlot.d.ts.map

package/lib/exercises/math/sequences/sequencePlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencePlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequencePlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA2FF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAe9C,CAAC"}

package/lib/exercises/math/sequences/sequencePlot.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequencePlot = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const getSequencePlotQuestion = () => {
+    const isArithmetic = (0, coinFlip_1.coinFlip)();
+    const a = isArithmetic ? (0, randfloat_1.randfloat)(0.1, 0.5, 1) : (0, randfloat_1.randfloat)(1.01, 1.1, 2);
+    const b = (0, randint_1.randint)(2, 10);
+    const nMax = 10;
+    const points = [];
+    for (let n = 0; n <= nMax; n++) {
+        let u_n;
+        if (isArithmetic) {
+            const noise = (0, randfloat_1.randfloat)(-2, 2, 1);
+            u_n = a * n + b + noise;
+        }
+        else {
+            const noise = (0, randfloat_1.randfloat)(-2, 2, 1);
+            u_n = b * Math.pow(a, n) + noise;
+        }
+        points.push([n, Math.round(u_n)]);
+    }
+    const nValue = (0, randint_1.randint)(0, nMax);
+    const u_nValue = points[nValue][1];
+    const commands = points.map((point, index) => {
+        return `A${index}=(${point[0]},${point[1]})`;
+    });
+    commands.push(...points.map((_, index) => {
+        return `SetFixed(A${index},true)`;
+    }), ...points.map((_, index) => {
+        return `SetLabelMode(A${index},1)`;
+    }));
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideAxes: false,
+        hideGrid: false,
+        isXAxesNatural: true,
+        isGridSimple: true,
+    });
+    const answer = u_nValue.toString();
+    const question = {
+        answer,
+        instruction: `Ci-dessous est tracé un nuage de points représentant les valeurs d'une suite $(u_n)$. Quelle est la valeur de $u_{${nValue}}$ ?`,
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: ggb.getAdaptedCoords({
+            xMin: 0,
+            xMax: nMax,
+            yMin: Math.min(...points.map((p) => p[1])) - 2,
+            yMax: Math.max(...points.map((p) => p[1])) + 2,
+        }),
+        keys: [],
+        answerFormat: "raw",
+        identifiers: { nValue, points, isArithmetic },
+        hint: `$u_{${nValue}}$ est l'ordonnée du point d'absicsse $${nValue}$ dans le nuage de points.`,
+        correction: `$u_{${nValue}}$ est l'ordonnée du point d'absicsse $${nValue}$ dans le nuage de points.
+
+On lit donc : $u_{${nValue}}=${answer}$.
+    `,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, nValue, points }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const correctValue = parseInt(answer);
+    while (propositions.length < n) {
+        const wrongAnswer = (correctValue + (0, randint_1.randint)(-2, 2)).toString();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.sequencePlot = {
+    id: "sequencePlot",
+    label: "Lire graphiquement un terme d'une suite à partir d'un nuage de points",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    hasGeogebra: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequencePlotQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sets/intervals/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./inequalityToInterval";
 export * from "./intervalsIntersection";
 export * from "./intervalsUnion";
+export * from "./intervalToInequality";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sets/intervals/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC"}

package/lib/exercises/math/sets/intervals/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./inequalityToInterval"), exports);
 __exportStar(require("./intervalsIntersection"), exports);
 __exportStar(require("./intervalsUnion"), exports);
+__exportStar(require("./intervalToInequality"), exports);

package/lib/exercises/math/sets/intervals/intervalToInequality.d.ts

@@ -5,6 +5,6 @@ type Identifiers = {
     intervalMax: number | string;
     intervalClosure: ClosureType;
 };
-export declare const inequalityToInterval: Exercise<Identifiers>;
+export declare const intervalToInequality: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=intervalToInequality.d.ts.map

package/lib/exercises/math/sets/intervals/intervalToInequality.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inequalityToInterval = void 0;
+exports.intervalToInequality = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const intervals_1 = require("../../../../math/sets/intervals/intervals");
@@ -96,7 +96,7 @@ const isAnswerValid = (ans, { intervalClosure, intervalMax, intervalMin }) => {
     const texs = answer.toAllValidTexs();
     return texs.includes(ans);
 };
-exports.inequalityToInterval = {
+exports.intervalToInequality = {
     id: "intervalToInequality",
     connector: "=",
     label: "Traduire un intervalle en inégalité",

package/lib/exercises/math/sets/intervals/intervalsIntersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5D,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAwDF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAW,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAQrE,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AA6EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}

package/lib/exercises/math/sets/intervals/intervalsIntersection.js

@@ -4,11 +4,13 @@ exports.intervalsIntersection = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const intervals_1 = require("../../../../math/sets/intervals/intervals");
+const discreteSetNode_1 = require("../../../../tree/nodes/sets/discreteSetNode");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
 const shuffle_1 = require("../../../../utils/shuffle");
 const getIntervalsIntersectionQuestion = () => {
     const [int1, int2] = intervals_1.IntervalConstructor.differentRandoms(2);
     const inter = int1.intersection(int2);
-    const answer = inter.tex;
+    const answer = inter.toTex();
     const question = {
         answer,
         instruction: `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$. Déterminer $I\\cap J$.`,
@@ -20,6 +22,8 @@ const getIntervalsIntersectionQuestion = () => {
             "semicolon",
             "cup",
             "cap",
+            "lbrace",
+            "rbrace",
         ],
         answerFormat: "tex",
         identifiers: {
@@ -30,6 +34,19 @@ const getIntervalsIntersectionQuestion = () => {
             int2Max: int2.max,
             int2Min: int2.min,
         },
+        hint: `Détermine l'ensemble des nombres qui appartiennent à la fois à $I$ et à $J$.`,
+        correction: `$I$ contient les nombres ${int1.toTree().toText(true, false)}. 
+    
+$J$ contient les nombres ${int2.toTree().toText(false, false)}.
+    
+${(0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 0
+            ? `Il n'y a donc aucun nombre commun aux intervalles $I$ et $J$.`
+            : (0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 1
+                ? `Il n'y a donc qu'un nombre commun aux intervalles $I$ et $J$ : $${inter.elements[0].toTex()}$.`
+                : (0, intervalNode_1.isIntervalNode)(inter) &&
+                    `Les nombres communs à $I$ et $J$ sont donc les nombres ${inter.toText(true, false)}.`}
+    
+Ainsi, $I\\cap J = ${answer}$`,
     };
     return question;
 };
@@ -61,4 +78,5 @@ exports.intervalsIntersection = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sets/intervals/intervalsUnion.js

@@ -30,7 +30,7 @@ const getPropositions = (n, { answer, int1Closure, int1Max, int1Min, int2Closure
     (0, exercise_1.addValidProp)(propositions, answer);
     const int1 = new intervals_1.Interval(int1Min.toTree(), int1Max.toTree(), int1Closure);
     const int2 = new intervals_1.Interval(int2Min.toTree(), int2Max.toTree(), int2Closure);
-    (0, exercise_1.tryToAddWrongProp)(propositions, int1.intersection(int2).tex);
+    (0, exercise_1.tryToAddWrongProp)(propositions, int1.intersection(int2).toTex());
     while (propositions.length < n) {
         const wrongAnswer = intervals_1.IntervalConstructor.random().tex;
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);

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

@@ -1 +1 @@
-{"version":3,"file":"arcValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/arcValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAoEF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAY1C,CAAC"}
+{"version":3,"file":"arcValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/arcValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA6FF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAa1C,CAAC"}

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

@@ -5,10 +5,15 @@ const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const sinNode_1 = require("../../../tree/nodes/functions/sinNode");
 const cosNode_1 = require("../../../tree/nodes/functions/cosNode");
 const tanNode_1 = require("../../../tree/nodes/functions/tanNode");
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const arcSinNode_1 = require("../../../tree/nodes/functions/arcSinNode");
+const arccosNode_1 = require("../../../tree/nodes/functions/arccosNode");
+const alignTex_1 = require("../../../utils/alignTex");
+const arctanNode_1 = require("../../../tree/nodes/functions/arctanNode");
 const getArcValueQuestion = () => {
     const trigFunctions = ["sin", "cos", "tan"];
     const selectedFunction = trigFunctions[(0, randint_1.randint)(0, trigFunctions.length)];
@@ -41,6 +46,11 @@ const getArcValueQuestion = () => {
         : selectedFunction === "cos"
             ? new cosNode_1.CosNode(new variableNode_1.VariableNode("\\theta"))
             : new tanNode_1.TanNode(new variableNode_1.VariableNode("\\theta"));
+    const reciprocalFunction = selectedFunction === "sin"
+        ? { name: "arcsin", otherName: "\\sin^{-1}", node: arcSinNode_1.ArcsinNode }
+        : selectedFunction === "cos"
+            ? { name: "arccos", otherName: "\\cos^{-1}", node: arccosNode_1.ArccosNode }
+            : { name: "arctan", otherName: "\\tan^{-1}", node: arctanNode_1.ArctanNode };
     const instruction = `Quelle est la valeur en degrés de l'angle $\\theta$ sachant que $${trigNode.toTex()} = ${trigValue.frenchify()}$ ? Arrondir à l'unité.`;
     const answer = (0, round_1.round)(angleInDegrees, 0).toTree().toTex();
     const question = {
@@ -48,6 +58,18 @@ const getArcValueQuestion = () => {
         instruction: instruction,
         keys: [],
         answerFormat: "tex",
+        hint: `La valeur de $\\theta$ s'obtient en calculant l'${reciprocalFunction.name} (ou $${reciprocalFunction.otherName}$) de la valeur $${trigValue.frenchify()}$, avec la calculatrice.`,
+        correction: `On calcule l'${reciprocalFunction.name} (ou $${reciprocalFunction.otherName}$) de  $${trigValue.frenchify()}$ avec la calculatrice : 
+    
+${(0, alignTex_1.alignTex)([
+            [
+                `${new reciprocalFunction.node(new numberNode_1.NumberNode(trigValue)).toTex()}`,
+                "\\approx",
+                (0, round_1.round)(angleInDegrees, 3).toTree().toTex(),
+            ],
+        ])}
+
+En arrondissant à l'unité, on a donc $\\theta \\approx ${answer}°$.`,
         identifiers: { trigFunction: selectedFunction, trigValue, angleInDegrees },
     };
     return question;
@@ -75,4 +97,5 @@ exports.arcValue = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/index.d.ts

@@ -137,6 +137,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     b: number;
     c: number;
     d: number;
+}> | import("./exercises/exercise").Exercise<{
+    nodeIds: any;
+    type: number;
+    subType: number;
 }> | import("./exercises/exercise").Exercise<{
     randQuation: number;
     x1: string | number;
@@ -1162,6 +1166,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     randomValues: number[];
     randomQuartile: number;
+}> | import("./exercises/exercise").Exercise<{
+    sortedValues: number[];
+}> | import("./exercises/exercise").Exercise<{
+    sortedValues: number[];
 }> | import("./exercises/exercise").Exercise<{
     xValues: number[];
     yValues: number[];
@@ -1300,6 +1308,11 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     sequence: number[];
     reason: number;
+}> | import("./exercises/exercise").Exercise<{
+    firstRank: number;
+    firstValue: number;
+    reason: number;
+    nbTerms: number;
 }> | import("./exercises/exercise").Exercise<{
     rank: number;
     coeffs: number[];
@@ -1309,6 +1322,15 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rank: number;
     u0: number;
     coeffs: number[];
+}> | import("./exercises/exercise").Exercise<{
+    termeid: number;
+    affine: number[];
+    termeAdd: number;
+    termeMult: number;
+}> | import("./exercises/exercise").Exercise<{
+    nValue: number;
+    points: number[][];
+    isArithmetic: boolean;
 }> | import("./exercises/exercise").Exercise<{
     intervalMin: string | number;
     intervalMax: string | number;
@@ -1327,6 +1349,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     int2Min: number;
     int2Max: number;
     int2Closure: import("./tree/nodes/sets/closure").ClosureType;
+}> | import("./exercises/exercise").Exercise<{
+    intervalMin: string | number;
+    intervalMax: string | number;
+    intervalClosure: import("./tree/nodes/sets/closure").ClosureType;
 }> | import("./exercises/exercise").Exercise<{
     type: number;
     nb: string;
@@ -1432,15 +1458,6 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
         n: number;
         p: number;
     };
-}> | import("./exercises/exercise").Exercise<{
-    termeid: number;
-    affine: number[];
-    termeAdd: number;
-    termeMult: number;
-}> | import("./exercises/exercise").Exercise<{
-    nValue: number;
-    points: number[][];
-    isArithmetic: boolean;
 }>)[];
 declare const pcExercises: (import("./exercises/exercise").Exercise<{
     numbers: number[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAI3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/math/geometry/point.d.ts

@@ -1,3 +1,4 @@
+import { NodeIds } from "../../tree/nodes/node";
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 export declare abstract class PointConstructor {
     static random(name: string): Point;
@@ -9,6 +10,16 @@ export declare class Point {
     y: AlgebraicNode;
     constructor(name: string, x: AlgebraicNode, y: AlgebraicNode);
     toTex(): string;
+    toIdentifiers(): {
+        id: string;
+        name: string;
+        x: {
+            id: NodeIds;
+        } & Record<string, any>;
+        y: {
+            id: NodeIds;
+        } & Record<string, any>;
+    };
     toTexWithCoords(): string;
     toCoords(): string;
     getXnumber(): number;

package/lib/math/geometry/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CAevC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAM5B,YAAY;CAKb"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAY,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CAevC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAGf,aAAa;;;;;;;;;;IAQb,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAM5B,YAAY;CAKb"}

package/lib/math/geometry/point.js

@@ -38,6 +38,14 @@ class Point {
     toTex() {
         return `${this.name}`;
     }
+    toIdentifiers() {
+        return {
+            id: "point",
+            name: this.name,
+            x: this.x.toIdentifiers(),
+            y: this.y.toIdentifiers(),
+        };
+    }
     toTexWithCoords() {
         return `${this.name}\\left(${this.x.toTex()};${this.y.toTex()}\\right)`;
     }

package/lib/math/numbers/reals/extendedRingElement.d.ts

@@ -1,5 +1,7 @@
 import { OppositeNode } from '../../../tree/nodes/functions/oppositeNode';
 import { NumberNode } from '../../../tree/nodes/numbers/numberNode';
+import { AddNode } from '../../../tree/nodes/operators/addNode';
+import { MultiplyNode } from '../../../tree/nodes/operators/multiplyNode';
 import { SubstractNode } from '../../../tree/nodes/operators/substractNode';
 import { Nombre } from '../nombre';
 /**
@@ -11,6 +13,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | OppositeNode | SubstractNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | MultiplyNode | OppositeNode | AddNode | SubstractNode;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"extendedRingElement.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/extendedRingElement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAGjE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,qBAAa,mBAAmB;IAM9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,MAAM,CAAC;gBACb,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAM1D,MAAM;CAeP"}
+{"version":3,"file":"extendedRingElement.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/extendedRingElement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,qBAAa,mBAAmB;IAM9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,MAAM,CAAC;gBACb,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAM1D,MAAM;CAeP"}

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

@@ -2,7 +2,7 @@ import { AlgebraicNode } from "../../../tree/nodes/algebraicNode";
 import { SqrtNode } from "../../../tree/nodes/functions/sqrtNode";
 import { Nombre, NumberType } from "../nombre";
 export declare abstract class RealConstructor {
-    static random(): Real;
+    static random(): Real | SquareRoot;
 }
 export declare class Real implements Nombre {
     value: number;