math-exercises 2.0.3 → 2.0.5

package/lib/exercises/derivation/derivative/lnDerivativeThree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lnDerivativeThree.d.ts","sourceRoot":"","sources":["../../../../src/exercises/derivation/derivative/lnDerivativeThree.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8FF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAYvD,CAAC"}
+{"version":3,"file":"lnDerivativeThree.d.ts","sourceRoot":"","sources":["../../../../src/exercises/derivation/derivative/lnDerivativeThree.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8FF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAYvD,CAAC"}

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

@@ -2,8 +2,8 @@ import { MathExercise } from "../../../exercises/exercise";
 type Identifiers = {
     xValue: number;
     yValue: number;
-    affineCoeffs: number[];
-    trinomCoeffs: number[];
+    affineCoeffs?: number[];
+    trinomCoeffs?: number[];
     isAffine: boolean;
 };
 export declare const inverseImageFunctionGeogebra: MathExercise<Identifiers>;

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

@@ -1 +1 @@
-{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA8LF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAalE,CAAC"}
+{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAgLF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAalE,CAAC"}

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

@@ -11,56 +11,30 @@ const shuffle_1 = require("../../../utils/shuffle");
 const getInverseImageFunctionGeogebra = () => {
     const isAffine = (0, coinFlip_1.coinFlip)();
     const xValue = (0, randint_1.randint)(-5, 6);
-    const yValue = (0, randint_1.randint)(-5, 6);
+    // const yValue = randint(-5, 6);
+    let yValue;
     let affine;
-    do {
-        affine = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
-    } while (affine.calculate(xValue) > 10 || affine.calculate(xValue) < -10);
-    let trinom = new polynomial_1.Polynomial([
-        (0, randint_1.randint)(-9, 10) - yValue,
-        (0, randint_1.randint)(-9, 10),
-        (0, randint_1.randint)(-4, 5, [0]),
-    ]);
-    let roots = trinom.getRoots();
-    if (roots.length === 2)
-        while (roots[0] > 10 || roots[0] < -10 || roots[1] > 10 || roots[1] < -10) {
-            trinom = new polynomial_1.Polynomial([
-                (0, randint_1.randint)(-9, 10) - yValue,
-                (0, randint_1.randint)(-9, 10),
-                (0, randint_1.randint)(-4, 5, [0]),
-            ]);
-            roots = trinom.getRoots();
-        }
-    else if (roots.length === 1)
-        while (roots[0] < -10 || roots[0] > 10) {
-            trinom = new polynomial_1.Polynomial([
-                (0, randint_1.randint)(-9, 10) - yValue,
-                (0, randint_1.randint)(-9, 10),
-                (0, randint_1.randint)(-4, 5, [0]),
-            ]);
-            roots = trinom.getRoots();
-        }
-    const statement = isAffine
-        ? `Déterminer le ou les antécédents de $${affine.calculate(xValue)}$ par la fonction $f$ représentée ci dessous.`
-        : `Déterminer le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.`;
-    let answer = isAffine
-        ? xValue
-        : roots.length === 2
-            ? `${(0, round_1.round)(roots[0], 1).toString().replace(".", ",")}\\text{ et }${(0, round_1.round)(roots[1], 1)
-                .toString()
-                .replace(".", ",")}`
-            : roots.length === 1
-                ? roots[0].toString().replace(".", ",")
-                : `\\text{Aucun}`;
-    const optimum = trinom.derivate().getRoots()[0];
-    let xmin = 0, xmax = 0, ymin = 0, ymax = 0;
+    let trinom;
+    let statement = "";
+    let answer = "";
+    let xmin = -1;
+    let xmax = 1;
+    let ymin = -1;
+    let ymax = 1;
+    let commands;
     if (isAffine) {
-        if (affine.calculate(xValue) > 0) {
-            ymax = affine.calculate(xValue) + 1;
+        do {
+            affine = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
+            yValue = affine.calculate(xValue);
+        } while (Math.abs(yValue) > 10);
+        statement = `Déterminer le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.`;
+        answer = xValue.toString().replace(".", ",");
+        if (yValue > 0) {
+            ymax = yValue + 1;
             ymin = -1;
         }
         else {
-            ymin = affine.calculate(xValue) - 1;
+            ymin = yValue - 1;
             ymax = 1;
         }
         if (xValue > 0) {
@@ -71,16 +45,35 @@ const getInverseImageFunctionGeogebra = () => {
             xmin = xValue - 1;
             xmax = 1;
         }
+        commands = [affine.toString()];
     }
     else {
+        let roots;
+        yValue = (0, randint_1.randint)(-5, 6);
+        do {
+            trinom = new polynomial_1.Polynomial([
+                (0, randint_1.randint)(-9, 10) - yValue,
+                (0, randint_1.randint)(-9, 10),
+                (0, randint_1.randint)(-4, 5, [0]),
+            ]);
+            roots = trinom.getRoots();
+        } while (roots.some((root) => Math.abs(root) > 10));
+        statement = `Déterminer le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.`;
+        answer = !roots.length
+            ? "\\text{Aucun}"
+            : roots
+                .map((r) => (0, round_1.round)(r, 1).toString().replace(".", ","))
+                .join("\\text{ et }");
+        const alpha = trinom.derivate().getRoots()[0];
+        const beta = trinom.calculate(alpha);
         if (roots.length === 2) {
-            if (yValue > trinom.calculate(optimum) + yValue) {
+            if (yValue > beta + yValue) {
                 ymax = yValue + 2;
-                ymin = trinom.calculate(optimum) + yValue - 2;
+                ymin = beta + yValue - 2;
             }
             else {
                 ymin = yValue - 2;
-                ymax = trinom.calculate(optimum) + yValue + 2;
+                ymax = beta + yValue + 2;
             }
             xmax = Math.max(roots[0], roots[1]) + 1;
             xmin = Math.min(roots[0], roots[1]) - 1;
@@ -94,30 +87,27 @@ const getInverseImageFunctionGeogebra = () => {
                 ymin = yValue - 5;
                 ymax = yValue + 1;
             }
-            xmax = optimum + 5;
-            xmin = optimum - 5;
+            xmax = alpha + 5;
+            xmin = alpha - 5;
         }
         if (roots.length === 0) {
-            if (yValue > trinom.calculate(optimum) + yValue) {
+            if (yValue > beta + yValue) {
                 ymax = yValue + 1;
-                ymin = trinom.calculate(optimum) + yValue - 3;
+                ymin = beta + yValue - 3;
             }
             else {
                 ymin = yValue - 1;
-                ymax = trinom.calculate(optimum) + yValue + 3;
+                ymax = beta + yValue + 3;
             }
-            xmax = optimum + 5;
-            xmin = optimum - 5;
+            xmax = alpha + 5;
+            xmin = alpha - 5;
         }
-    }
-    const commands = [
-        isAffine
-            ? affine.toString()
-            : yValue !== 0
+        commands = [
+            yValue !== 0
                 ? trinom.add(new polynomial_1.Polynomial([yValue])).toString()
                 : trinom.toString(),
-    ];
-    answer = (answer + "").replaceAll(".", ",");
+        ];
+    }
     const question = {
         instruction: statement,
         answer,
@@ -127,8 +117,8 @@ const getInverseImageFunctionGeogebra = () => {
         answerFormat: "tex",
         identifiers: {
             xValue,
-            affineCoeffs: affine.coefficients,
-            trinomCoeffs: trinom.coefficients,
+            affineCoeffs: isAffine ? affine.coefficients : undefined,
+            trinomCoeffs: isAffine ? undefined : trinom.coefficients,
             yValue,
             isAffine,
         },
@@ -138,17 +128,20 @@ const getInverseImageFunctionGeogebra = () => {
 const getPropositions = (n, { answer, xValue, affineCoeffs, trinomCoeffs, yValue, isAffine }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const polynome1 = new polynomial_1.Polynomial(affineCoeffs);
-    const roots = new polynomial_1.Polynomial(trinomCoeffs).getRoots();
+    (0, exercise_1.tryToAddWrongProp)(propositions, "\\text{Aucun}");
+    if (isAffine) {
+        const affine = new polynomial_1.Polynomial(affineCoeffs);
+        (0, exercise_1.tryToAddWrongProp)(propositions, affine.calculate(yValue).toString().replace(".", ","));
+    }
+    else {
+        const trinom = new polynomial_1.Polynomial(trinomCoeffs);
+        (0, exercise_1.tryToAddWrongProp)(propositions, trinom.calculate(yValue).toString().replace(".", ","));
+    }
     while (propositions.length < n) {
-        const wrongAnswer = isAffine
-            ? (0, randint_1.randint)(-9, 10, [polynome1.calculate(xValue)])
-            : roots.length === 2
-                ? `${(0, randint_1.randint)(-9, 10)}\\text{ et }${(0, randint_1.randint)(-9, 10)}`.replaceAll(".", ",")
-                : roots.length === 1
-                    ? (0, randint_1.randint)(-9, 10, [roots[0]]).toString().replace(".", ",")
-                    : `\\text{Aucun}`;
-        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer + "");
+        const wrongAnswer = (0, coinFlip_1.coinFlip)()
+            ? `${(0, randint_1.randint)(-9, 10)}`
+            : `${(0, randint_1.randint)(-9, 10)}\\text{ et }${(0, randint_1.randint)(-9, 10)}`;
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
     }
     return (0, shuffle_1.shuffle)(propositions);
 };

package/lib/exercises/primitive/index.d.ts

@@ -4,5 +4,6 @@ export { exponentialPrimitive } from "./exponentialPrimitive";
 export { logarithmePrimitive } from "./logarithmePrimitive";
 export { polynomialPrimitive } from "./polynomialPrimitive";
 export { sinCosPrimitive } from "./sinCosPrimitive";
+export { sinUCosUPrimitive } from "./sinUCosUPrimitive";
 export * from "./usualPrimitives";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/primitive/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,cAAc,mBAAmB,CAAC"}

package/lib/exercises/primitive/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sinCosPrimitive = exports.polynomialPrimitive = exports.logarithmePrimitive = exports.exponentialPrimitive = exports.expUPrimitive = exports.constantPrimitive = void 0;
+exports.sinUCosUPrimitive = exports.sinCosPrimitive = exports.polynomialPrimitive = exports.logarithmePrimitive = exports.exponentialPrimitive = exports.expUPrimitive = exports.constantPrimitive = void 0;
 var constantPrimitive_1 = require("./constantPrimitive");
 Object.defineProperty(exports, "constantPrimitive", { enumerable: true, get: function () { return constantPrimitive_1.constantPrimitive; } });
 var expUPrimitive_1 = require("./expUPrimitive");
@@ -27,5 +27,6 @@ var polynomialPrimitive_1 = require("./polynomialPrimitive");
 Object.defineProperty(exports, "polynomialPrimitive", { enumerable: true, get: function () { return polynomialPrimitive_1.polynomialPrimitive; } });
 var sinCosPrimitive_1 = require("./sinCosPrimitive");
 Object.defineProperty(exports, "sinCosPrimitive", { enumerable: true, get: function () { return sinCosPrimitive_1.sinCosPrimitive; } });
-// export { sinUCosUPrimitive } from "./sinUCosUPrimitive";
+var sinUCosUPrimitive_1 = require("./sinUCosUPrimitive");
+Object.defineProperty(exports, "sinUCosUPrimitive", { enumerable: true, get: function () { return sinUCosUPrimitive_1.sinUCosUPrimitive; } });
 __exportStar(require("./usualPrimitives"), exports);

package/lib/exercises/primitive/sinCosPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sinCosPrimitive.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/sinCosPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,CAAC,WAAW,CA2B7D,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CA4BpE,CAAC;AACF,eAAO,MAAM,4BAA4B,EAAE,GAAG,CAAC,WAAW,CAYzD,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,WAAW,CAYrD,CAAC"}
+{"version":3,"file":"sinCosPrimitive.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/sinCosPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,CAAC,WAAW,CA2B7D,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CA4BpE,CAAC;AACF,eAAO,MAAM,4BAA4B,EAAE,GAAG,CAAC,WAAW,CAYzD,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,WAAW,CAYrD,CAAC"}

package/lib/exercises/primitive/sinUCosUPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sinUCosUPrimitive.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/sinUCosUPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,0BAA0B,CAAC;AAkBlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,CAAC,WAAW,CA0B/D,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CAAC,WAAW,CA8BtE,CAAC;AACF,eAAO,MAAM,8BAA8B,EAAE,GAAG,CAAC,WAAW,CAa3D,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAYvD,CAAC"}
+{"version":3,"file":"sinUCosUPrimitive.d.ts","sourceRoot":"","sources":["../../../src/exercises/primitive/sinUCosUPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAEZ,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,0BAA0B,CAAC;AAmBlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,CAAC,WAAW,CA0B/D,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CAAC,WAAW,CA8BtE,CAAC;AACF,eAAO,MAAM,8BAA8B,EAAE,GAAG,CAAC,WAAW,CAa3D,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAYvD,CAAC"}

package/lib/index.d.ts

@@ -352,8 +352,8 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     xValue: number;
     yValue: number;
-    affineCoeffs: number[];
-    trinomCoeffs: number[];
+    affineCoeffs?: number[] | undefined;
+    trinomCoeffs?: number[] | undefined;
     isAffine: boolean;
 }> | import("./exercises/exercise").MathExercise<{
     k: number;
@@ -546,6 +546,9 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     a: number;
     isCos: boolean;
+}> | import("./exercises/exercise").MathExercise<{
+    coeffs: number[];
+    isCos: boolean;
 }> | import("./exercises/exercise").MathExercise<{
     type: number;
     a?: number | undefined;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/math/complex/complex.d.ts

@@ -19,7 +19,7 @@ export declare class Complex {
     opposite(): Complex;
     conjugate(): Complex;
     toArgumentTree(): NumberNode | FractionNode | OppositeNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | undefined;
-    toModuleTree(): import("../../tree/nodes/node").Node;
+    toModuleTree(): import("../../tree/nodes/algebraicNode").AlgebraicNode;
     toTree(): ComplexNode;
 }
 //# sourceMappingURL=complex.d.ts.map

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

@@ -1,13 +1,13 @@
-import { Node } from "../../tree/nodes/node";
 import { MathSet } from "../sets/mathSet";
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 export declare abstract class PointConstructor {
     static random(domainX?: MathSet, domainY?: MathSet): Point;
 }
 export declare class Point {
     name: string;
-    x: Node;
-    y: Node;
-    constructor(name: string, x: Node, y: Node);
+    x: AlgebraicNode;
+    y: AlgebraicNode;
+    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode);
     toTex(): string;
     toTexWithCoords(): string;
     toCoords(): string;

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":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAI1C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CACX,OAAO,GAAE,OAAqC,EAC9C,OAAO,GAAE,OAAqC,GAC7C,KAAK;CAOT;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAM1C,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;CAK7B;AAED;;;;;;;;;;;;GAYG"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAG1C,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CACX,OAAO,GAAE,OAAqC,EAC9C,OAAO,GAAE,OAAqC,GAC7C,KAAK;CAOT;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;CAK7B;AAED;;;;;;;;;;;;GAYG"}

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

@@ -1,12 +1,12 @@
-import { Point } from './point';
-import { Node } from '../../tree/nodes/node';
+import { Point } from "./point";
+import { SqrtNode } from "../../tree/nodes/functions/sqrtNode";
 export declare abstract class TriangleConstructor {
-    static createRandomRightTriangle({ minRapport, maxRapport, names }: {
+    static createRandomRightTriangle({ minRapport, maxRapport, names, }: {
         minRapport?: number | undefined;
         maxRapport?: number | undefined;
         names?: string[] | undefined;
     }): Triangle;
-    static createRandomTriangle({ minAngle, maxAngle, names }: {
+    static createRandomTriangle({ minAngle, maxAngle, names, }: {
         minAngle?: number | undefined;
         maxAngle?: number | undefined;
         names?: string[] | undefined;
@@ -31,9 +31,9 @@ export declare class Triangle {
     getSideBnumber(): number;
     getSideCnumber(): number;
     getTriangleName(): string;
-    getSideAnode(): Node;
-    getSideBnode(): Node;
-    getSideCnode(): Node;
+    getSideAnode(): SqrtNode;
+    getSideBnode(): SqrtNode;
+    getSideCnode(): SqrtNode;
     getAngleA(): number;
     getAngleB(): number;
     getAngleC(): number;

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

@@ -1 +1 @@
-{"version":3,"file":"triangles.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAO7C,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,yBAAyB,CAAC,EAAE,UAAc,EAAE,UAAc,EAAE,KAAuB,EAAE;;;;KAAA,GAAG,QAAQ;IAkBvG,MAAM,CAAC,oBAAoB,CAAC,EAAE,QAAe,EAAE,QAAc,EAAE,KAAuB,EAAE;;;;KAAA,GAAG,QAAQ;CAmBpG;AAED,KAAK,qBAAqB,GAAG;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,qBAAa,QAAQ;IACnB,OAAO,EAAE,KAAK,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;gBAEH,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK;IAM1D,cAAc,IAAI,MAAM;IAOxB,cAAc,IAAI,MAAM;IAOxB,cAAc,IAAI,MAAM;IAIxB,eAAe,IAAI,MAAM;IAIzB,YAAY,IAAI,IAAI;IASpB,YAAY,IAAI,IAAI;IASpB,YAAY,IAAI,IAAI;IASpB,SAAS,IAAI,MAAM;IAOnB,SAAS,IAAI,MAAM;IAOnB,SAAS,IAAI,MAAM;IAOnB,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IAKjB,OAAO,IAAI,OAAO;IAOlB,aAAa,IAAI,OAAO;IAIxB,WAAW,IAAI,OAAO;IAQtB,SAAS,IAAI,OAAO;IAQpB,aAAa,IAAI,MAAM;IAOvB,gBAAgB,CAAC,EACf,gBAAgB,EAAE,gBAAgB,EAClC,qBAAqB,EAAE,qBAAqB,EAC5C,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,eAAe,EAChC,oBAAoB,EAAE,oBAAoB,EAC1C,QAAQ,EACR,QAAQ,GACT,EAAE,qBAAqB,GAAG,MAAM,EAAE;IAiDnC,cAAc,IAAI,MAAM,EAAE;IAS1B,YAAY,IAAI,MAAM;IAItB,YAAY,IAAI,MAAM;IAItB,YAAY,IAAI,MAAM;CAGvB"}
+{"version":3,"file":"triangles.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAKhC,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAI/D,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,yBAAyB,CAAC,EAC/B,UAAc,EACd,UAAc,EACd,KAAuB,GACxB;;;;KAAA,GAAG,QAAQ;IAkBZ,MAAM,CAAC,oBAAoB,CAAC,EAC1B,QAAe,EACf,QAAc,EACd,KAAuB,GACxB;;;;KAAA,GAAG,QAAQ;CA+Bb;AAED,KAAK,qBAAqB,GAAG;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,qBAAa,QAAQ;IACnB,OAAO,EAAE,KAAK,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;gBAEH,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK;IAM1D,cAAc,IAAI,MAAM;IAOxB,cAAc,IAAI,MAAM;IAOxB,cAAc,IAAI,MAAM;IAIxB,eAAe,IAAI,MAAM;IAIzB,YAAY;IAeZ,YAAY;IAeZ,YAAY;IAeZ,SAAS,IAAI,MAAM;IASnB,SAAS,IAAI,MAAM;IASnB,SAAS,IAAI,MAAM;IASnB,YAAY,IAAI,MAAM;IAMtB,OAAO,IAAI,MAAM;IAUjB,OAAO,IAAI,OAAO;IAOlB,aAAa,IAAI,OAAO;IAOxB,WAAW,IAAI,OAAO;IAQtB,SAAS,IAAI,OAAO;IAQpB,aAAa,IAAI,MAAM;IAOvB,gBAAgB,CAAC,EACf,gBAAgB,EAAE,gBAAgB,EAClC,qBAAqB,EAAE,qBAAqB,EAC5C,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,eAAe,EAChC,oBAAoB,EAAE,oBAAoB,EAC1C,QAAQ,EACR,QAAQ,GACT,EAAE,qBAAqB,GAAG,MAAM,EAAE;IAsEnC,cAAc,IAAI,MAAM,EAAE;IAyB1B,YAAY,IAAI,MAAM;IAItB,YAAY,IAAI,MAAM;IAItB,YAAY,IAAI,MAAM;CAGvB"}

package/lib/math/geometry/triangles.js

@@ -9,7 +9,7 @@ const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
 const randint_1 = require("../utils/random/randint");
 class TriangleConstructor {
-    static createRandomRightTriangle({ minRapport = 0, maxRapport = 5, names = ['A', 'B', 'C'] }) {
+    static createRandomRightTriangle({ minRapport = 0, maxRapport = 5, names = ["A", "B", "C"], }) {
         let pointA, pointB, pointC, d1, d2;
         do {
             const xA = (0, randint_1.randint)(-10, 11);
@@ -26,7 +26,7 @@ class TriangleConstructor {
         } while (!d1 || !d2 || d1 / d2 < minRapport || d1 / d2 > maxRapport);
         return new Triangle(pointA, pointB, pointC);
     }
-    static createRandomTriangle({ minAngle = 0.69, maxAngle = 1.5, names = ['A', 'B', 'C'] }) {
+    static createRandomTriangle({ minAngle = 0.69, maxAngle = 1.5, names = ["A", "B", "C"], }) {
         let pointA, pointB, pointC, triangle;
         do {
             pointA = new point_1.Point(names[0], new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)), new numberNode_1.NumberNode((0, randint_1.randint)(-10, 11)));
@@ -73,23 +73,32 @@ class Triangle {
         return new sqrtNode_1.SqrtNode(new addNode_1.AddNode(new powerNode_1.PowerNode(new substractNode_1.SubstractNode(this.vertexA.x, this.vertexB.x), new numberNode_1.NumberNode(2)), new powerNode_1.PowerNode(new substractNode_1.SubstractNode(this.vertexC.y, this.vertexB.y), new numberNode_1.NumberNode(2))));
     }
     getAngleA() {
-        return Math.acos((this.getSideBnumber() ** 2 + this.getSideCnumber() ** 2 - this.getSideAnumber() ** 2) /
+        return Math.acos((this.getSideBnumber() ** 2 +
+            this.getSideCnumber() ** 2 -
+            this.getSideAnumber() ** 2) /
             (2 * this.getSideBnumber() * this.getSideCnumber()));
     }
     getAngleB() {
-        return Math.acos((this.getSideAnumber() ** 2 + this.getSideCnumber() ** 2 - this.getSideBnumber() ** 2) /
+        return Math.acos((this.getSideAnumber() ** 2 +
+            this.getSideCnumber() ** 2 -
+            this.getSideBnumber() ** 2) /
             (2 * this.getSideAnumber() * this.getSideCnumber()));
     }
     getAngleC() {
-        return Math.acos((this.getSideAnumber() ** 2 + this.getSideBnumber() ** 2 - this.getSideCnumber() ** 2) /
+        return Math.acos((this.getSideAnumber() ** 2 +
+            this.getSideBnumber() ** 2 -
+            this.getSideCnumber() ** 2) /
             (2 * this.getSideAnumber() * this.getSideBnumber()));
     }
     getPerimeter() {
-        return this.getSideAnumber() + this.getSideBnumber() + this.getSideCnumber();
+        return (this.getSideAnumber() + this.getSideBnumber() + this.getSideCnumber());
     }
     getArea() {
         const s = this.getPerimeter() / 2;
-        return Math.sqrt(s * (s - this.getSideAnumber()) * (s - this.getSideBnumber()) * (s - this.getSideCnumber()));
+        return Math.sqrt(s *
+            (s - this.getSideAnumber()) *
+            (s - this.getSideBnumber()) *
+            (s - this.getSideCnumber()));
     }
     isRight() {
         if (Math.abs(Math.cos(this.getAngleA())) < 0.001)
@@ -101,7 +110,8 @@ class Triangle {
         return false;
     }
     isEquilateral() {
-        return this.getSideAnumber() === this.getSideBnumber() && this.getSideAnumber() === this.getSideCnumber();
+        return (this.getSideAnumber() === this.getSideBnumber() &&
+            this.getSideAnumber() === this.getSideCnumber());
     }
     isIsosceles() {
         return (this.getSideAnumber() === this.getSideBnumber() ||
@@ -120,7 +130,7 @@ class Triangle {
             return this.vertexB.name;
         if (Math.abs(Math.cos(this.getAngleC())) < 0.001)
             return this.vertexC.name;
-        return '';
+        return "";
     }
     generateCommands({ highlightedAngle: highlightedAngle, colorHighlightedAngle: colorHighlightedAngle, showLabels: showLabels, setCaptions: setCaptions, highlightedSide: highlightedSide, colorHighlightedSide: colorHighlightedSide, showAxes, showGrid, }) {
         let commands = [
@@ -141,9 +151,9 @@ class Triangle {
         ];
         if (this.isRight())
             commands.push(`alpha = Angle(${this.vertexB.name},${this.vertexA.name},${this.vertexC.name}, Line(${this.vertexB.name},${this.vertexA.name}))`, `ShowLabel(alpha, false)`);
-        const defautColor = 'Red';
+        const defautColor = "Red";
         if (highlightedAngle) {
-            let temp = [''];
+            let temp = [""];
             if (highlightedAngle === this.vertexB.name)
                 temp = [this.vertexA.name, this.vertexB.name, this.vertexC.name];
             if (highlightedAngle === this.vertexC.name)

package/lib/math/numbers/decimals/decimal.d.ts

@@ -1,4 +1,5 @@
-import { Node } from "../../../tree/nodes/node";
+import { NumberNode } from "../../../tree/nodes/numbers/numberNode";
+import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode";
 import { Nombre, NumberType } from "../nombre";
 export declare abstract class DecimalConstructor {
     static randomFracPart(precision: number, leadingZeros?: number): string;
@@ -21,8 +22,8 @@ export declare class Decimal implements Nombre {
      */
     round(precision: number): Nombre;
     multiplyByPowerOfTen(power: number): Decimal;
-    toScientificPart(): Node;
-    toScientificNotation(): Node;
-    toTree(): Node;
+    toScientificPart(): NumberNode;
+    toScientificNotation(): NumberNode | MultiplyNode;
+    toTree(): NumberNode;
 }
 //# sourceMappingURL=decimal.d.ts.map

package/lib/math/numbers/decimals/decimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAK7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAW1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAI/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;gBACR,KAAK,EAAE,MAAM;IASzB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAsEhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IA2BlC,gBAAgB,IAAI,IAAI;IAgBxB,oBAAoB,IAAI,IAAI;IAmB5B,MAAM,IAAI,IAAI;CAGf"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAGvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAW1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAI/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;gBACR,KAAK,EAAE,MAAM;IASzB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAsEhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IA2BlC,gBAAgB;IAgBhB,oBAAoB;IAmBpB,MAAM;CAGP"}

package/lib/math/numbers/integer/integer.d.ts

@@ -1,4 +1,4 @@
-import { Node } from "../../../tree/nodes/node";
+import { NumberNode } from "../../../tree/nodes/numbers/numberNode";
 import { Nombre, NumberType } from "../nombre";
 import { Rational } from "../rationals/rational";
 export declare abstract class IntegerConstructor {
@@ -11,11 +11,11 @@ export declare class Integer implements Nombre {
     tex: string;
     type: NumberType;
     constructor(value: number, tex?: string);
-    toTree(): Node;
+    toTree(): NumberNode;
     round(precision: number): Integer;
     divide(nb: Nombre): Nombre;
     multiply(nb: Nombre): Rational | Integer;
     opposite(): Integer;
-    add(nb: Nombre): Nombre;
+    add(nb: Nombre): Nombre | Integer;
 }
 //# sourceMappingURL=integer.d.ts.map

package/lib/math/numbers/integer/integer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAG7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM,IAAI,IAAI;IAId,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}
+{"version":3,"file":"integer.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/integer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAGrD,MAAM,CAAC,WAAW,CAAC,GAAG,GAAE,MAAW;IAGnC,MAAM,CAAC,gBAAgB,CACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,MAAM,EAAE;CAYtB;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;gBAEL,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAMvC,MAAM;IAIN,KAAK,CAAC,SAAS,EAAE,MAAM;IAkCvB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAc1B,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAYxC,QAAQ;IAGR,GAAG,CAAC,EAAE,EAAE,MAAM;CAYf"}

package/lib/math/numbers/integer/power.d.ts

@@ -1,4 +1,5 @@
-import { Node } from "../../../tree/nodes/node";
+import { NumberNode } from "../../../tree/nodes/numbers/numberNode";
+import { PowerNode } from "../../../tree/nodes/operators/powerNode";
 import { Nombre, NumberType } from "../nombre";
 export declare class Power implements Nombre {
     value: number;
@@ -7,8 +8,8 @@ export declare class Power implements Nombre {
     operand: number;
     power: number;
     constructor(a: number, b: number);
-    simplify(): Node;
+    simplify(): NumberNode | PowerNode;
     toDecimalWriting(): Nombre;
-    toTree(): Node;
+    toTree(): PowerNode;
 }
 //# sourceMappingURL=power.d.ts.map

package/lib/math/numbers/integer/power.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"power.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/power.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAG7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG/C,qBAAa,KAAM,YAAW,MAAM;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;gBACF,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAOhC,QAAQ,IAAI,IAAI;IAShB,gBAAgB,IAAI,MAAM;IAmB1B,MAAM,IAAI,IAAI;CAMf"}
+{"version":3,"file":"power.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/integer/power.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG/C,qBAAa,KAAM,YAAW,MAAM;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;gBACF,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAOhC,QAAQ;IASR,gBAAgB,IAAI,MAAM;IAmB1B,MAAM;CAMP"}

package/lib/math/numbers/nombre.d.ts

@@ -1,4 +1,5 @@
-import { Node, NodeOptions } from "../../tree/nodes/node";
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { NodeOptions } from "../../tree/nodes/node";
 import { Integer } from "./integer/integer";
 export declare enum NumberType {
     Integer = 0,
@@ -10,7 +11,7 @@ export interface Nombre {
     value: number;
     tex: string;
     type: NumberType;
-    toTree: (opts?: NodeOptions) => Node;
+    toTree: (opts?: NodeOptions) => AlgebraicNode;
 }
 export declare abstract class NombreConstructor {
     static random(): import("./decimals/decimal").Decimal | Integer | import("./rationals/rational").Rational | import("./reals/real").Real;

package/lib/math/numbers/nombre.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nombre.d.ts","sourceRoot":"","sources":["../../../src/math/numbers/nombre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAI5C,oBAAY,UAAU;IACpB,OAAO,IAAA;IACP,OAAO,IAAA;IACP,QAAQ,IAAA;IACR,IAAI,IAAA;CACL;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,CAAC;CACtC;AAED,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM;CAkBd"}
+{"version":3,"file":"nombre.d.ts","sourceRoot":"","sources":["../../../src/math/numbers/nombre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAI5C,oBAAY,UAAU;IACpB,OAAO,IAAA;IACP,OAAO,IAAA;IACP,QAAQ,IAAA;IACR,IAAI,IAAA;CACL;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC;CAC/C;AAED,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM;CAkBd"}

package/lib/math/numbers/rationals/rational.d.ts

@@ -1,4 +1,6 @@
-import { Node, NodeOptions } from "../../../tree/nodes/node";
+import { OppositeNode } from "../../../tree/nodes/functions/oppositeNode";
+import { NodeOptions } from "../../../tree/nodes/node";
+import { FractionNode } from "../../../tree/nodes/operators/fractionNode";
 import { Integer } from "../integer/integer";
 import { Nombre, NumberType } from "../nombre";
 export declare abstract class RationalConstructor {
@@ -22,7 +24,7 @@ export declare class Rational implements Nombre {
     multiply(nb: Nombre): Rational | Integer;
     divide(nb: Nombre): Nombre;
     opposite(): Rational;
-    toTree(opts?: NodeOptions): Node;
+    toTree(opts?: NodeOptions): FractionNode | OppositeNode;
     isIrreductible(): boolean;
     simplify(): Integer | Rational;
 }

package/lib/math/numbers/rationals/rational.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAM1D,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;IAO1C,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;CAQnD;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI;IAgBhC,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAY/B"}
+{"version":3,"file":"rational.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/rationals/rational.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAQ,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAIvE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,8BAAsB,mBAAmB;IACvC;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAE,MAAW;IAW7C,MAAM,CAAC,kBAAkB,CAAC,GAAG,GAAE,MAAW;IAO1C,MAAM,CAAC,0BAA0B,CAAC,GAAG,GAAE,MAAW;CAQnD;AAED,qBAAa,QAAS,YAAW,MAAM;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,CAAC;gBAEL,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAYlD,KAAK;IAML,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAkBvB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO;IAgBxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAgB1B,QAAQ,IAAI,QAAQ;IAIpB,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAgBzB,cAAc;IAId,QAAQ,IAAI,OAAO,GAAG,QAAQ;CAY/B"}

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

@@ -10,6 +10,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/node").Node | NumberNode | SubstractNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | SubstractNode;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

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

@@ -1,4 +1,5 @@
-import { Node } from "../../../tree/nodes/node";
+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;
@@ -8,7 +9,7 @@ export declare class Real implements Nombre {
     tex: string;
     type: NumberType;
     constructor(value: number, tex: string);
-    toTree(): Node;
+    toTree(): AlgebraicNode;
 }
 export declare abstract class SquareRootConstructor {
     /**
@@ -27,6 +28,6 @@ export declare class SquareRoot extends Real {
     getSimplifiedCoeffs(): [number, number];
     simplify(): Nombre;
     toTex(): string;
-    toTree(): Node;
+    toTree(): SqrtNode;
 }
 //# sourceMappingURL=real.d.ts.map