math-exercises 2.0.27 → 2.0.30

package/lib/exercises/sets/intervals/inequalityToInterval.js

@@ -38,12 +38,14 @@ const getInequalityToIntervalQuestion = () => {
         answerFormat: "tex",
         identifiers: {
             isIntervalToInequality: isIntervalToInequality,
-            intervalTex: interval.tex,
+            intervalMin: interval.min,
+            intervalMax: interval.max,
+            intervalClosure: interval.closure,
         },
     };
     return question;
 };
-const getPropositions = (n, { answer, isIntervalToInequality, intervalTex }) => {
+const getPropositions = (n, { answer, isIntervalToInequality, intervalClosure, intervalMax, intervalMin }) => {
     const reverseBracket = (bracket) => {
         return bracket === "[" ? "]" : "[";
     };
@@ -65,7 +67,7 @@ const getPropositions = (n, { answer, isIntervalToInequality, intervalTex }) =>
             return "<";
         return "\\le";
     };
-    const interval = new intervals_1.Interval(intervalTex);
+    const interval = new intervals_1.Interval(intervalMin.toTree(), intervalMax.toTree(), intervalClosure);
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
     const xNode = new variableNode_1.VariableNode("x");
@@ -117,17 +119,18 @@ const getPropositions = (n, { answer, isIntervalToInequality, intervalTex }) =>
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { intervalTex, isIntervalToInequality }) => {
-    const interval = new intervals_1.Interval(intervalTex).toTree();
-    console.log(interval.toTex());
+const isAnswerValid = (ans, { intervalClosure, intervalMax, intervalMin, isIntervalToInequality }) => {
+    const interval = new intervals_1.Interval(intervalMin.toTree(), intervalMax.toTree(), intervalClosure).toTree();
+    console.log("int", interval.toTex());
     const inequality = interval.toInequality();
     const answer = isIntervalToInequality
         ? inequality
         : new belongsNode_1.BelongsNode(new variableNode_1.VariableNode("x"), interval, {
             allowRawRightChildAsSolution: true,
         });
+    console.log("ans", answer);
     const texs = answer.toAllValidTexs();
-    console.log(texs);
+    console.log("texs", texs);
     return texs.includes(ans);
 };
 exports.inequalityToInterval = {

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

@@ -1,7 +1,12 @@
 import { MathExercise } from "../../../exercises/exercise";
+import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
 type Identifiers = {
-    int1Tex: string;
-    int2Tex: string;
+    int1Min: number;
+    int1Max: number;
+    int1Closure: ClosureType;
+    int2Min: number;
+    int2Max: number;
+    int2Closure: ClosureType;
 };
 export declare const intervalsIntersection: MathExercise<Identifiers>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAiDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAa3D,CAAC"}
+{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAGjE,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,YAAY,CAAC,WAAW,CAa3D,CAAC"}

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

@@ -22,15 +22,22 @@ const getIntervalsIntersectionQuestion = () => {
             "cap",
         ],
         answerFormat: "tex",
-        identifiers: { int1Tex: int1.tex, int2Tex: int2.tex },
+        identifiers: {
+            int1Closure: int1.closure,
+            int1Max: int1.max,
+            int1Min: int1.min,
+            int2Closure: int2.closure,
+            int2Max: int2.max,
+            int2Min: int2.min,
+        },
     };
     return question;
 };
-const getPropositions = (n, { answer, int1Tex, int2Tex }) => {
+const getPropositions = (n, { answer, int1Closure, int1Max, int1Min, int2Closure, int2Max, int2Min }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const int1 = new intervals_1.Interval(int1Tex);
-    const int2 = new intervals_1.Interval(int2Tex);
+    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.union(int2).tex);
     while (propositions.length < n) {
         const wrongAnswer = intervals_1.IntervalConstructor.random().tex;

package/lib/exercises/sets/intervals/intervalsUnion.d.ts

@@ -1,7 +1,12 @@
 import { MathExercise } from "../../../exercises/exercise";
+import { ClosureType } from "../../../tree/nodes/sets/intervalNode";
 type Identifiers = {
-    int1Tex: string;
-    int2Tex: string;
+    int1Min: number;
+    int1Max: number;
+    int1Closure: ClosureType;
+    int2Min: number;
+    int2Max: number;
+    int2Closure: ClosureType;
 };
 export declare const intervalsUnion: MathExercise<Identifiers>;
 export {};

package/lib/exercises/sets/intervals/intervalsUnion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAsCF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAGjE,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;AA6CF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,WAAW,CAapD,CAAC"}

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

@@ -14,15 +14,22 @@ const getIntervalsUnionQuestion = () => {
         instruction: `Soit $I = ${int1.tex}$ et $J = ${int2.tex}$. Déterminer $I\\cup J$.`,
         keys: ["infty", "lbracket", "rbracket", "semicolon", "cup", "cap"],
         answerFormat: "tex",
-        identifiers: { int1Tex: int1.tex, int2Tex: int2.tex },
+        identifiers: {
+            int1Closure: int1.closure,
+            int1Max: int1.max,
+            int1Min: int1.min,
+            int2Closure: int2.closure,
+            int2Max: int2.max,
+            int2Min: int2.min,
+        },
     };
     return question;
 };
-const getPropositions = (n, { answer, int1Tex, int2Tex }) => {
+const getPropositions = (n, { answer, int1Closure, int1Max, int1Min, int2Closure, int2Max, int2Min }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const int1 = new intervals_1.Interval(int1Tex);
-    const int2 = new intervals_1.Interval(int2Tex);
+    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);
     while (propositions.length < n) {
         const wrongAnswer = intervals_1.IntervalConstructor.random().tex;

package/lib/exercises/utils/keys/intervalKeys.d.ts

@@ -0,0 +1,3 @@
+import { KeyId } from "../../../types/keyIds";
+export declare const intervalKeys: KeyId[];
+//# sourceMappingURL=intervalKeys.d.ts.map

package/lib/exercises/utils/keys/intervalKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intervalKeys.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/keys/intervalKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3C,eAAO,MAAM,YAAY,EAAE,KAAK,EAM/B,CAAC"}

package/lib/exercises/utils/keys/intervalKeys.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intervalKeys = void 0;
+exports.intervalKeys = [
+    "lbracket",
+    "rbracket",
+    "semicolon",
+    "cup",
+    "infty",
+];

package/lib/geogebra/colors.d.ts

@@ -0,0 +1,25 @@
+export declare const red = "#FF3333";
+export declare const pinkDark = "#A10039";
+export declare const pinkMain = "#D83F63";
+export declare const pinkLight = "#FF7390";
+export declare const reds: string[];
+export declare const orangeDark = "#BE5F00";
+export declare const orange = "#F6A118";
+export declare const orangeLight = "#FFBE46";
+export declare const oranges: string[];
+export declare const greenLight = "#54B1B7";
+export declare const greenMain = "#168187";
+export declare const greenDark = "#00545A";
+export declare const greens: string[];
+export declare const blueLight = "#769DFF";
+export declare const blueDark = "#0045AB";
+export declare const blueMain = "#376FDE";
+export declare const blueExtraDark = "#00035D";
+export declare const blues: string[];
+export declare const purpleLight = "#BA86FF";
+export declare const purpleMain = "#8657DE";
+export declare const purpleDark = "#522AAB";
+export declare const purples: string[];
+export declare const colors: string[];
+export declare const randomColor: () => string;
+//# sourceMappingURL=colors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../src/geogebra/colors.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,YAAY,CAAC;AAC7B,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,IAAI,UAAuC,CAAC;AAEzD,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,MAAM,YAAY,CAAC;AAChC,eAAO,MAAM,WAAW,YAAY,CAAC;AACrC,eAAO,MAAM,OAAO,UAAoC,CAAC;AAEzD,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,MAAM,UAAqC,CAAC;AAEzD,eAAO,MAAM,SAAS,YAAY,CAAC;AACnC,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,QAAQ,YAAY,CAAC;AAClC,eAAO,MAAM,aAAa,YAAY,CAAC;AACvC,eAAO,MAAM,KAAK,UAAiD,CAAC;AAEpE,eAAO,MAAM,WAAW,YAAY,CAAC;AACrC,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,UAAU,YAAY,CAAC;AACpC,eAAO,MAAM,OAAO,UAAwC,CAAC;AAC7D,eAAO,MAAM,MAAM,UAAyD,CAAC;AAE7E,eAAO,MAAM,WAAW,cAEvB,CAAC"}

package/lib/geogebra/colors.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomColor = exports.colors = exports.purples = exports.purpleDark = exports.purpleMain = exports.purpleLight = exports.blues = exports.blueExtraDark = exports.blueMain = exports.blueDark = exports.blueLight = exports.greens = exports.greenDark = exports.greenMain = exports.greenLight = exports.oranges = exports.orangeLight = exports.orange = exports.orangeDark = exports.reds = exports.pinkLight = exports.pinkMain = exports.pinkDark = exports.red = void 0;
+const random_1 = require("../utils/random");
+exports.red = "#FF3333";
+exports.pinkDark = "#A10039";
+exports.pinkMain = "#D83F63";
+exports.pinkLight = "#FF7390";
+exports.reds = [exports.red, exports.pinkDark, exports.pinkLight, exports.pinkMain];
+exports.orangeDark = "#BE5F00";
+exports.orange = "#F6A118";
+exports.orangeLight = "#FFBE46";
+exports.oranges = [exports.orange, exports.orangeDark, exports.orangeLight];
+exports.greenLight = "#54B1B7";
+exports.greenMain = "#168187";
+exports.greenDark = "#00545A";
+exports.greens = [exports.greenDark, exports.greenLight, exports.greenMain];
+exports.blueLight = "#769DFF";
+exports.blueDark = "#0045AB";
+exports.blueMain = "#376FDE";
+exports.blueExtraDark = "#00035D";
+exports.blues = [exports.blueDark, exports.blueExtraDark, exports.blueLight, exports.blueMain];
+exports.purpleLight = "#BA86FF";
+exports.purpleMain = "#8657DE";
+exports.purpleDark = "#522AAB";
+exports.purples = [exports.purpleDark, exports.purpleLight, exports.purpleMain];
+exports.colors = [...exports.reds, ...exports.oranges, ...exports.greens, ...exports.blues, ...exports.purples];
+const randomColor = () => {
+    return (0, random_1.random)(exports.colors);
+};
+exports.randomColor = randomColor;

package/lib/geogebra/geogebraConstructor.js

@@ -16,10 +16,10 @@ class GeogebraConstructor {
         const xDelta = xMax - xMin;
         const yDelta = yMax - yMin;
         const coords = [
-            xMin === xMax ? xMin - 1 : xMin - 0.2 * Math.abs(xDelta),
-            xMin === xMax ? xMax + 1 : xMax + 0.2 * Math.abs(xDelta),
-            yMin === yMax ? yMin - 1 : yMin - 0.2 * Math.abs(yDelta),
-            yMin === yMax ? yMax + 1 : yMax + 0.2 * Math.abs(yDelta),
+            xMin === xMax ? xMin - 1 : xMin - Math.max(1, 0.2 * Math.abs(xDelta)),
+            xMin === xMax ? xMax + 1 : xMax + Math.max(1, 0.2 * Math.abs(xDelta)),
+            yMin === yMax ? yMin - 1 : yMin - Math.max(1, 0.2 * Math.abs(yDelta)),
+            yMin === yMax ? yMax + 1 : yMax + Math.max(1, 0.2 * Math.abs(yDelta)),
         ];
         if (showAxes) {
             coords[0] = Math.min(-1, coords[0]);

package/lib/index.d.ts

@@ -1,3 +1,9 @@
+declare global {
+    interface Number {
+        toTree: () => AlgebraicNode;
+    }
+}
+import { AlgebraicNode } from "./tree/nodes/algebraicNode";
 declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     chosenNumbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
@@ -32,6 +38,38 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     rationalNum: [number, number];
     rationalDenum: [number, number];
 }> | import("./exercises/exercise").MathExercise<{
+    /**
+     * TODO
+     * Décimal : permettre facilement -0.xxx
+     * Tree shaking export
+     *
+     * VEA:
+     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
+     *      ->> faire le meme delire que pour les power mais pour les opposite ?
+     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
+     *  -> faire des nodes pour les Ensembles de nombre
+     *
+     * !-> choses pour lesquelles la v1 ne marchera pas :
+     *  !-- fractions non réduites
+     *  !-- nbs décimaux avec des 0
+     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
+     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
+     *
+     * Passer les sqrtNode en tree-iable
+     *
+     *
+     *
+     * !!!à fix :
+     * ! fraction réductible
+     * ! 0,20 au lieu de 0,2
+     * ! moins partout dans fraction
+     * !puissances négatives vers inverse fraction
+     * ! simplification du ln
+     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
+     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
+     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
+    
+    */
     rational: [number, number];
     rational2: [number, number];
 }> | import("./exercises/exercise").MathExercise<{
@@ -453,6 +491,38 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     signs: number[];
     isLog10: boolean;
 }> | import("./exercises/exercise").MathExercise<{
+    /**
+     * TODO
+     * Décimal : permettre facilement -0.xxx
+     * Tree shaking export
+     *
+     * VEA:
+     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
+     *      ->> faire le meme delire que pour les power mais pour les opposite ?
+     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
+     *  -> faire des nodes pour les Ensembles de nombre
+     *
+     * !-> choses pour lesquelles la v1 ne marchera pas :
+     *  !-- fractions non réduites
+     *  !-- nbs décimaux avec des 0
+     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
+     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
+     *
+     * Passer les sqrtNode en tree-iable
+     *
+     *
+     *
+     * !!!à fix :
+     * ! fraction réductible
+     * ! 0,20 au lieu de 0,2
+     * ! moins partout dans fraction
+     * !puissances négatives vers inverse fraction
+     * ! simplification du ln
+     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
+     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
+     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
+    
+    */
     coin: boolean;
     radius: number;
     diametre: number;
@@ -588,6 +658,11 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     to: string;
     from: string | undefined;
     a: number | undefined;
+}> | import("./exercises/exercise").MathExercise<{
+    a: string;
+    b: string;
+    c: string;
+    d: string;
 }> | import("./exercises/exercise").MathExercise<{
     randNbr: number;
     randPercent: number;
@@ -596,7 +671,38 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     rate: number;
     nbMois: number;
 }> | import("./exercises/exercise").MathExercise<{
-    isFromEvolutionToCM: boolean;
+    isFromEvolutionToCM: boolean; /**
+     * TODO
+     * Décimal : permettre facilement -0.xxx
+     * Tree shaking export
+     *
+     * VEA:
+     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
+     *      ->> faire le meme delire que pour les power mais pour les opposite ?
+     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
+     *  -> faire des nodes pour les Ensembles de nombre
+     *
+     * !-> choses pour lesquelles la v1 ne marchera pas :
+     *  !-- fractions non réduites
+     *  !-- nbs décimaux avec des 0
+     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
+     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
+     *
+     * Passer les sqrtNode en tree-iable
+     *
+     *
+     *
+     * !!!à fix :
+     * ! fraction réductible
+     * ! 0,20 au lieu de 0,2
+     * ! moins partout dans fraction
+     * !puissances négatives vers inverse fraction
+     * ! simplification du ln
+     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
+     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
+     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
+    
+    */
     evolution: number;
 }> | import("./exercises/exercise").MathExercise<{
     evolutions: string[];
@@ -760,13 +866,23 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     coeffs: number[];
 }> | import("./exercises/exercise").MathExercise<{
     isIntervalToInequality: boolean;
-    intervalTex: string;
-}> | import("./exercises/exercise").MathExercise<{
-    int1Tex: string;
-    int2Tex: string;
-}> | import("./exercises/exercise").MathExercise<{
-    int1Tex: string;
-    int2Tex: string;
+    intervalMin: number;
+    intervalMax: number;
+    intervalClosure: import("./tree/nodes/sets/intervalNode").ClosureType;
+}> | import("./exercises/exercise").MathExercise<{
+    int1Min: number;
+    int1Max: number;
+    int1Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+    int2Min: number;
+    int2Max: number;
+    int2Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+}> | import("./exercises/exercise").MathExercise<{
+    int1Min: number;
+    int1Max: number;
+    int1Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
+    int2Min: number;
+    int2Max: number;
+    int2Closure: import("./tree/nodes/sets/intervalNode").ClosureType;
 }> | import("./exercises/exercise").MathExercise<{
     type: number;
     nb: string;

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":"AAGA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF;AA6CD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAtCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO4C,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/index.js

@@ -24,6 +24,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mathExercises = void 0;
+// import { exercises } from "./exercises/exercises";
+const numberNode_1 = require("./tree/nodes/numbers/numberNode");
+Number.prototype.toTree = function () {
+    const value = this.valueOf();
+    if (value === Infinity)
+        return infiniteNode_1.PlusInfinityNode;
+    if (value === -Infinity)
+        return infiniteNode_1.MinusInfinityNode;
+    return new numberNode_1.NumberNode(value);
+};
 /**
  * TODO
  * Décimal : permettre facilement -0.xxx
@@ -57,5 +67,6 @@ exports.mathExercises = void 0;
 
 */
 const Exercises = __importStar(require("./exercises"));
+const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const mathExercises = Object.values(Exercises);
 exports.mathExercises = mathExercises;

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":"AAKA,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;CAK7B"}
+{"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;CAK7B"}

package/lib/math/matrices/matrix.d.ts

@@ -0,0 +1,10 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+export declare class Matrix {
+    elements: AlgebraicNode[][];
+    rows: number;
+    columns: number;
+    constructor(elements: AlgebraicNode[][]);
+    determinant(): AlgebraicNode;
+    toTex(): string;
+}
+//# sourceMappingURL=matrix.d.ts.map

package/lib/math/matrices/matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../src/math/matrices/matrix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,qBAAa,MAAM;IACjB,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,QAAQ,EAAE,aAAa,EAAE,EAAE;IAKvC,WAAW;IAUX,KAAK;CAKN"}

package/lib/math/matrices/matrix.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Matrix = void 0;
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+class Matrix {
+    constructor(elements) {
+        this.elements = elements;
+        this.columns = elements[0].length;
+        this.rows = elements.length;
+    }
+    determinant() {
+        if (this.rows === 2 && this.columns === 2) {
+            return new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(this.elements[0][0], this.elements[1][1]), new multiplyNode_1.MultiplyNode(this.elements[0][1], this.elements[1][0])).simplify();
+        }
+        throw Error("general determinant not implemented yet");
+    }
+    toTex() {
+        return `\\begin{pmatrix}${this.elements
+            .map((row) => `${row.map((cell) => cell.toTex()).join("&")} \\\\[6pt]`)
+            .join("")}\\end{pmatrix}`;
+    }
+}
+exports.Matrix = Matrix;

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

@@ -16,6 +16,7 @@ export declare class Decimal implements Nombre {
     intPart: number;
     decimalPart: string;
     constructor(value: number);
+    equals(n: Nombre): boolean;
     /**
      *
      * @param precision 0 = unité, 1 = dixieme, ... , -1 : dizaine

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":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,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;IAK/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;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA2BhB,oBAAoB;IAsBpB,UAAU;IAMV,MAAM;CAGP"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,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;IAK/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,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA2BhB,oBAAoB;IAsBpB,UAAU;IAMV,MAAM;CAGP"}

package/lib/math/numbers/decimals/decimal.js

@@ -52,6 +52,9 @@ class Decimal {
         this.decimalPart = decimalPartString || "";
         this.precision = this.decimalPart.length;
     }
+    equals(n) {
+        return this.value === n.value;
+    }
     /**
      *
      * @param precision 0 = unité, 1 = dixieme, ... , -1 : dizaine

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

@@ -11,6 +11,7 @@ export declare class Integer implements Nombre {
     tex: string;
     type: NumberType;
     constructor(value: number, tex?: string);
+    equals(n: Nombre): boolean;
     toTree(): NumberNode;
     round(precision: number): Integer;
     divide(nb: Nombre): Nombre;

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":"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"}
+{"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,CAAC,CAAC,EAAE,MAAM;IAGhB,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/integer.js

@@ -33,6 +33,9 @@ class Integer {
         this.tex = tex || value + "";
         this.type = nombre_1.NumberType.Integer;
     }
+    equals(n) {
+        return this.value === n.value;
+    }
     toTree() {
         return new numberNode_1.NumberNode(this.value, this.tex);
     }

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

@@ -8,6 +8,7 @@ export declare class Power implements Nombre {
     operand: number;
     power: number;
     constructor(a: number, b: number);
+    equals(n: Nombre): boolean;
     simplify(): NumberNode | PowerNode;
     toDecimalWriting(): Nombre;
     toTree(): PowerNode;

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":"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"}
+{"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,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,QAAQ;IASR,gBAAgB,IAAI,MAAM;IAmB1B,MAAM;CAMP"}

package/lib/math/numbers/integer/power.js

@@ -13,6 +13,9 @@ class Power {
         this.tex = `${a}^{${b}}`;
         this.type = b < 0 ? nombre_1.NumberType.Rational : nombre_1.NumberType.Integer;
     }
+    equals(n) {
+        return this.value === n.value;
+    }
     simplify() {
         if (this.power === 0)
             return new numberNode_1.NumberNode(1);

package/lib/math/numbers/logarithms/ln.d.ts

@@ -6,6 +6,7 @@ export declare class Ln implements Nombre {
     type: NumberType;
     operand: Nombre;
     constructor(operand: Nombre);
+    equals(n: Nombre): boolean;
     toTree(): LogNode;
     simplify(): void;
 }

package/lib/math/numbers/logarithms/ln.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ln.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/logarithms/ln.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAE7D,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,qBAAa,EAAG,YAAW,MAAM;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAM3B,MAAM;IAGN,QAAQ;CACT"}
+{"version":3,"file":"ln.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/logarithms/ln.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAE7D,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/C,qBAAa,EAAG,YAAW,MAAM;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,EAAE,MAAM;IAM3B,MAAM,CAAC,CAAC,EAAE,MAAM;IAGhB,MAAM;IAGN,QAAQ;CACT"}

package/lib/math/numbers/logarithms/ln.js

@@ -10,6 +10,9 @@ class Ln {
         this.tex = `\\ln(${operand})`;
         this.operand = operand;
     }
+    equals(n) {
+        return this.value === n.value;
+    }
     toTree() {
         return new logNode_1.LogNode(this.operand.toTree());
     }

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

@@ -1,6 +1,5 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 import { NodeOptions } from "../../tree/nodes/node";
-import { Integer } from "./integer/integer";
 export declare enum NumberType {
     Integer = 0,
     Decimal = 1,
@@ -12,8 +11,12 @@ export interface Nombre {
     tex: string;
     type: NumberType;
     toTree: (opts?: NodeOptions) => AlgebraicNode;
+    equals: (n: Nombre) => boolean;
 }
 export declare abstract class NombreConstructor {
-    static random(): import("./rationals/rational").Rational | Integer | import("./decimals/decimal").Decimal | import("./reals/real").Real;
+    static random({ types, excludes, }?: {
+        types?: NumberType[];
+        excludes?: Nombre[];
+    }): Nombre;
 }
 //# sourceMappingURL=nombre.d.ts.map

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,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"}
+{"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;AAQ1D,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;IAC9C,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;CAChC;AAED,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,EACZ,KAAK,EACL,QAAQ,GACT,GAAE;QACD,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KAChB;CAiCP"}