math-exercises 2.2.9 → 2.2.11

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.js

@@ -112,6 +112,6 @@ exports.recognizeRefractionOrReflectionAngles = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    answerType: "QCM",
+    answerType: "QCU",
     subject: "Physique",
 };

package/lib/index.d.ts

@@ -129,7 +129,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
     c: number;
-    d: number;
+    d: number | undefined;
 }> | import("./exercises/exercise").Exercise<{
     type: number;
     flip: number;
@@ -137,6 +137,16 @@ 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<{
+    nodeIds: any;
+    type: number;
+}> | import("./exercises/exercise").Exercise<{
+    nodeIds: any;
+    type: number;
 }> | import("./exercises/exercise").Exercise<{
     randQuation: number;
     x1: string | number;
@@ -173,6 +183,25 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
+}> | import("./exercises/exercise").Exercise<{
+    type: number;
+    a: number;
+    b: number;
+}> | import("./exercises/exercise").Exercise<{
+    type: number;
+    nbIds: any;
+    nbValue: number;
+    pow: number;
+}> | import("./exercises/exercise").Exercise<{
+    dec: number;
+    pow: number;
+    isDivide: boolean;
+}> | import("./exercises/exercise").Exercise<{
+    dec: number;
+    pow: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
@@ -1070,6 +1099,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     lefties: number;
 }> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     evolution: number;
+}> | import("./exercises/exercise").Exercise<{
+    TVA: number;
+    ht: number;
+}> | import("./exercises/exercise").Exercise<{
+    TTC: number;
+    TVA: number;
 }> | import("./exercises/exercise").Exercise<{
     int: number;
     power: number;
@@ -1162,6 +1197,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 +1339,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 +1353,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;
@@ -1436,15 +1489,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":"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"}
+{"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/decimals/decimal.d.ts

@@ -32,5 +32,7 @@ export declare class Decimal implements Nombre {
     toRational(): Rational | import("../integer/integer").Integer;
     toTree(): NumberNode;
     toPercentNode(): PercentNode;
+    toLowerBound(tenthPower: number): Decimal;
+    toUpperBound(tenthPower: number): Decimal;
 }
 //# 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":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,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,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,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,GAAG,MAAM;IASlC,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAwCtC,cAAc,CAAC,IAAI,EAAE,MAAM;IAS3B,UAAU;IAMV,MAAM;IAIN,aAAa;CAGd"}
+{"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,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,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,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,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,GAAG,MAAM;IASlC,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAkClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAwCtC,cAAc,CAAC,IAAI,EAAE,MAAM;IAS3B,UAAU;IAMV,MAAM;IAIN,aAAa;IAIb,YAAY,CAAC,UAAU,EAAE,MAAM;IAS/B,YAAY,CAAC,UAAU,EAAE,MAAM;CAShC"}

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

@@ -171,5 +171,23 @@ class Decimal {
     toPercentNode() {
         return new percentNode_1.PercentNode(this.multiplyByPowerOfTen(2).value);
     }
+    toLowerBound(tenthPower) {
+        if (tenthPower > 0)
+            throw Error("not implemented : lower bound positive");
+        const rounded = (0, round_1.round)(this.value, -tenthPower);
+        if (rounded > this.value)
+            return new Decimal((0, round_1.round)(rounded - Math.pow(10, tenthPower), -tenthPower));
+        else
+            return new Decimal(rounded);
+    }
+    toUpperBound(tenthPower) {
+        if (tenthPower > 0)
+            throw Error("not implemented : lower bound positive");
+        const rounded = (0, round_1.round)(this.value, -tenthPower);
+        if (rounded < this.value)
+            return new Decimal((0, round_1.round)(rounded + Math.pow(10, tenthPower), -tenthPower));
+        else
+            return new Decimal(rounded);
+    }
 }
 exports.Decimal = Decimal;

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;

package/lib/math/polynomials/trinom.d.ts

@@ -65,7 +65,7 @@ export declare class Trinom extends Polynomial {
     getAlphaNode(): NumberNode | FractionNode | OppositeNode;
     getBeta(): number;
     getBetaNode(): NumberNode | FractionNode | OppositeNode;
-    getFactorizedForm(): AlgebraicNode;
+    getFactorizedForm(): AlgebraicNode | MultiplyNode;
     getCanonicalForm(): MultiplyNode | AddNode;
     getSommet(): Point;
     getCoords(): number[];

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

@@ -1,6 +1,7 @@
 import { Nombre } from "../../../math/numbers/nombre";
 import { AlgebraicNode } from "../../../tree/nodes/algebraicNode";
 import { ClosureType } from "../../../tree/nodes/sets/closure";
+import { DiscreteSetNode } from "../../../tree/nodes/sets/discreteSetNode";
 import { IntervalNode } from "../../../tree/nodes/sets/intervalNode";
 import { MathSet } from "../mathSet";
 import { MathSetInterface } from "../mathSetInterface";
@@ -21,10 +22,11 @@ export declare class Interval implements MathSetInterface {
     leftInequalitySymbol: "\\le" | "<";
     rightInequalitySymbol: "\\le" | "<";
     tex: string;
+    isEmpty: boolean;
     constructor(min: AlgebraicNode, max: AlgebraicNode, closure: ClosureType);
     equals(interval: Interval): boolean;
     union(interval: Interval): MathSet;
-    intersection(interval: Interval): MathSet;
+    intersection(interval: Interval): DiscreteSetNode | IntervalNode;
     insideToTex(): string;
     toTex(): string;
     toInequality(): string;

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

@@ -1 +1 @@
-{"version":3,"file":"intervals.d.ts","sourceRoot":"","sources":["../../../../src/math/sets/intervals/intervals.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAc,MAAM,2BAA2B,CAAC;AAI/D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAM/D,OAAO,EAAW,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAIlE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,MAAM;IA2Cb,MAAM,CAAC,gBAAgB,CAAC,EAAE,EAAE,MAAM;CAWnC;AAED,qBAAa,QAAS,YAAW,gBAAgB;IAC/C,OAAO,EAAE,aAAa,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,WAAW,CAAC;IACrB,WAAW,EAAE,GAAG,GAAG,GAAG,CAAC;IACvB,YAAY,EAAE,GAAG,GAAG,GAAG,CAAC;IACxB,oBAAoB,EAAE,MAAM,GAAG,GAAG,CAAC;IACnC,qBAAqB,EAAE,MAAM,GAAG,GAAG,CAAC;IACpC,GAAG,EAAE,MAAM,CAAC;gBACA,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW;IAiBxE,MAAM,CAAC,QAAQ,EAAE,QAAQ;IAOzB,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IA6ClC,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAyCzC,WAAW,IAAI,MAAM;IAGrB,KAAK,IAAI,MAAM;IAMf,YAAY,IAAI,MAAM;IAmBtB,gBAAgB,IAAI,MAAM;IAI1B,MAAM;CAGP"}
+{"version":3,"file":"intervals.d.ts","sourceRoot":"","sources":["../../../../src/math/sets/intervals/intervals.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAc,MAAM,2BAA2B,CAAC;AAI/D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAM/D,OAAO,EAAW,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EACL,eAAe,EAEhB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAGlE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,MAAM;IA2Cb,MAAM,CAAC,gBAAgB,CAAC,EAAE,EAAE,MAAM;CAWnC;AAED,qBAAa,QAAS,YAAW,gBAAgB;IAC/C,OAAO,EAAE,aAAa,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,WAAW,CAAC;IACrB,WAAW,EAAE,GAAG,GAAG,GAAG,CAAC;IACvB,YAAY,EAAE,GAAG,GAAG,GAAG,CAAC;IACxB,oBAAoB,EAAE,MAAM,GAAG,GAAG,CAAC;IACnC,qBAAqB,EAAE,MAAM,GAAG,GAAG,CAAC;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;gBACL,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW;IAkBxE,MAAM,CAAC,QAAQ,EAAE,QAAQ;IAOzB,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IA6ClC,YAAY,CAAC,QAAQ,EAAE,QAAQ;IA0C/B,WAAW,IAAI,MAAM;IAGrB,KAAK,IAAI,MAAM;IAIf,YAAY,IAAI,MAAM;IAmBtB,gBAAgB,IAAI,MAAM;IAI1B,MAAM;CAGP"}

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

@@ -4,6 +4,7 @@ exports.Interval = exports.IntervalConstructor = void 0;
 const randint_1 = require("../../../math/utils/random/randint");
 const infiniteNode_1 = require("../../../tree/nodes/numbers/infiniteNode");
 const closure_1 = require("../../../tree/nodes/sets/closure");
+const discreteSetNode_1 = require("../../../tree/nodes/sets/discreteSetNode");
 const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const mathSet_1 = require("../mathSet");
@@ -80,6 +81,7 @@ class Interval {
         this.leftInequalitySymbol = this.leftBracket === "[" ? "\\le" : "<";
         this.rightInequalitySymbol = this.rightBracket === "]" ? "\\le" : "<";
         this.tex = this.toTex();
+        this.isEmpty = false;
     }
     equals(interval) {
         return (this.min === interval.min &&
@@ -113,7 +115,7 @@ class Interval {
                 interval.rightBracket === "[")) {
             const firstInterval = this.min < interval.min ? this : interval;
             const secondInterval = this.min < interval.min ? interval : this;
-            return new mathSet_1.MathSet(`${unionLeftBracket}\\ ${firstInterval.minTex};${firstInterval.maxTex}\\ ${firstInterval.rightBracket}\\ \\cup\\ ${secondInterval.leftBracket}\\ ${secondInterval.minTex};${secondInterval.maxTex}\\ ${unionRightBracket}\\ `, () => (0, coinFlip_1.coinFlip)()
+            return new mathSet_1.MathSet(`${unionLeftBracket}${firstInterval.minTex};${firstInterval.maxTex}${firstInterval.rightBracket}\\cup${secondInterval.leftBracket}${secondInterval.minTex};${secondInterval.maxTex}${unionRightBracket}`, () => (0, coinFlip_1.coinFlip)()
                 ? firstInterval.getRandomElement()
                 : secondInterval.getRandomElement());
         }
@@ -134,30 +136,32 @@ class Interval {
                 (this.rightBracket === "[" || interval.leftBracket === "]")) ||
             (a === d && (interval.rightBracket === "[" || this.leftBracket === "]"));
         if (isDisjoint) {
-            return new mathSet_1.MathSet("\\varnothing", () => null);
+            return discreteSetNode_1.EmptySet;
         }
         const winningLeftBracket = (brack1, brack2) => brack1 === "]" || brack2 === "]" ? "]" : "[";
         const winningRightBracket = (brack1, brack2) => brack1 === "[" || brack2 === "[" ? "[" : "]";
         let min = a >= c ? this.minNode : interval.minNode;
+        const max = b <= d ? this.maxNode : interval.maxNode;
+        if (min === max)
+            return new discreteSetNode_1.DiscreteSetNode([min]);
         let leftBracket = a === c
             ? winningLeftBracket(this.leftBracket, interval.leftBracket)
             : a > c
                 ? this.leftBracket
                 : interval.leftBracket;
-        const max = b <= d ? this.maxNode : interval.maxNode;
         let rightBracket = b === d
             ? winningRightBracket(this.rightBracket, interval.rightBracket)
             : b < d
                 ? this.rightBracket
                 : interval.rightBracket;
         const closure = closure_1.Closure.fromBrackets(leftBracket, rightBracket);
-        return new Interval(min, max, closure);
+        return new Interval(min, max, closure).toTree();
     }
     insideToTex() {
         return `${this.minTex};${this.maxTex}`;
     }
     toTex() {
-        return `${this.leftBracket}\\ ${this.insideToTex()}\\ ${this.rightBracket}\\ `;
+        return `${this.leftBracket}${this.insideToTex()}${this.rightBracket}`;
     }
     toInequality() {
         const isLeftClosed = this.closure === closure_1.ClosureType.FO || this.closure === closure_1.ClosureType.FF;

package/lib/math/sets/mathSet.d.ts

@@ -1,5 +1,5 @@
-import { Nombre } from '../numbers/nombre';
-import { MathSetInterface } from './mathSetInterface';
+import { Nombre } from "../numbers/nombre";
+import { MathSetInterface } from "./mathSetInterface";
 export declare class MathSet implements MathSetInterface {
     tex: string;
     toTex: () => string;

package/lib/math/sets/mathSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mathSet.d.ts","sourceRoot":"","sources":["../../../src/math/sets/mathSet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,qBAAa,OAAQ,YAAW,gBAAgB;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;gBAC1B,GAAG,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,MAAM,GAAG,IAAI;CAK/D"}
+{"version":3,"file":"mathSet.d.ts","sourceRoot":"","sources":["../../../src/math/sets/mathSet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,qBAAa,OAAQ,YAAW,gBAAgB;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;gBAC1B,GAAG,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,MAAM,GAAG,IAAI;CAK/D"}

package/lib/math/sets/mathSetInterface.d.ts

@@ -1,4 +1,4 @@
-import { Nombre } from '../numbers/nombre';
+import { Nombre } from "../numbers/nombre";
 export interface MathSetInterface {
     tex: string;
     toTex: () => string;

package/lib/playground.d.ts.map

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

package/lib/playground.js

@@ -1,8 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
-const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const playground = () => {
-    console.log(infiniteNode_1.MinusInfinityNode.evaluate({}));
+    // const node = new AddNode(
+    //   new MultiplyNode(new Affine(1, 0).toTree(), new Affine(3, 1).toTree()),
+    //   new MultiplyNode(
+    //     new ExpNode(new SqrtNode((3).toTree())),
+    //     new CosNode((3).toTree()),
+    //   ),
+    // );
+    // const node = new NumberNode(3);
+    // const node = new MultiplyNode((2).toTree(), (3).toTree());
+    // const ids = node.toIdentifiers();
+    // const parsed = NodeConstructor.fromIdentifiers(ids);
+    // console.log(node);
+    // console.log(parsed);
 };
 exports.playground = playground;

package/lib/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAuC3D,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"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAwC3D,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"}

package/lib/tree/nodes/algebraicNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IAEzC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACnD,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;CACpB"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACnD,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;CACpB"}

package/lib/tree/nodes/algebraicNode.js

@@ -1,5 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//tous les operators et function
-// tous les externals (number, variable, constant, length)
-//implémenter les opérations add, substract, divide, power etc

package/lib/tree/nodes/complex/complexNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeOptions, NodeType } from "../node";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { AlgebraicNode } from "../algebraicNode";
 export declare class ComplexNode implements Node {
     re: AlgebraicNode;
@@ -6,6 +6,15 @@ export declare class ComplexNode implements Node {
     opts?: NodeOptions;
     type: NodeType;
     constructor(re: AlgebraicNode, im: AlgebraicNode, opts?: NodeOptions);
+    toIdentifiers(): {
+        id: NodeIds;
+        re: {
+            id: NodeIds;
+        } & Record<string, any>;
+        im: {
+            id: NodeIds;
+        } & Record<string, any>;
+    };
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
     toAllValidTexs(opts?: NodeOptions): string[];
     toMathString(): string;

package/lib/tree/nodes/complex/complexNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complexNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/complex/complexNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAItD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,qBAAa,WAAY,YAAW,IAAI;IACtC,EAAE,EAAE,aAAa,CAAC;IAClB,EAAE,EAAE,aAAa,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAmB;gBAErB,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAKpE,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAkBtD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;CAiBhB"}
+{"version":3,"file":"complexNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/complex/complexNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAI/D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,qBAAa,WAAY,YAAW,IAAI;IACtC,EAAE,EAAE,aAAa,CAAC;IAClB,EAAE,EAAE,aAAa,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAmB;gBAErB,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAKpE,aAAa;;;;;;;;;IAOb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAkBtD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;CAiBhB"}

package/lib/tree/nodes/complex/complexNode.js

@@ -13,6 +13,13 @@ class ComplexNode {
         this.im = im;
         this.opts = opts;
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.complex,
+            re: this.re.toIdentifiers(),
+            im: this.im.toIdentifiers(),
+        };
+    }
     toEquivalentNodes(opts) {
         const options = opts ?? this.opts;
         const res = [];

package/lib/tree/nodes/equations/equalNode.d.ts

@@ -1,10 +1,19 @@
-import { Node, NodeOptions, NodeType } from "../node";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 export declare class EqualNode implements Node {
     leftChild: Node;
     rightChild: Node;
     opts?: NodeOptions;
     type: NodeType;
     constructor(leftChild: Node, rightChild: Node, opts?: NodeOptions);
+    toIdentifiers(): {
+        id: NodeIds;
+        leftChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+        rightChild: {
+            id: NodeIds;
+        } & Record<string, any>;
+    };
     toEquivalentNodes(opts?: NodeOptions): Node[];
     toAllValidTexs(opts?: NodeOptions): string[];
     toMathString(): string;

package/lib/tree/nodes/equations/equalNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEtD,qBAAa,SAAU,YAAW,IAAI;IACpC,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;IAOjE,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;CAUhB"}
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/D,qBAAa,SAAU,YAAW,IAAI;IACpC,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;IAOjE,aAAa;;;;;;;;;IAOb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;CAUhB"}

package/lib/tree/nodes/equations/equalNode.js

@@ -9,6 +9,13 @@ class EqualNode {
         this.type = node_1.NodeType.equality;
         this.opts = opts;
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.equal,
+            leftChild: this.leftChild.toIdentifiers(),
+            rightChild: this.rightChild.toIdentifiers(),
+        };
+    }
     toEquivalentNodes(opts) {
         const options = opts ?? this.opts;
         const res = [];

package/lib/tree/nodes/equations/equationSolutionNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeOptions, NodeType } from "../node";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { DiscreteSetNode } from "../sets/discreteSetNode";
 type EquationSolutionNodeOptions = {
     variable?: string;
@@ -10,6 +10,15 @@ export declare class EquationSolutionNode implements Node {
     solutionsSet: DiscreteSetNode;
     opts?: NodeOptions;
     constructor(solutionsSet: DiscreteSetNode, params?: EquationSolutionNodeOptions);
+    toIdentifiers(): {
+        id: NodeIds;
+        solutionsSet: {
+            id: NodeIds;
+            children: ({
+                id: NodeIds;
+            } & Record<string, any>)[];
+        };
+    };
     toAllValidTexs(): string[];
     toAllTexs(): string[];
     toEquivalentNodes(opts?: NodeOptions): EquationSolutionNode[];

package/lib/tree/nodes/equations/equationSolutionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,KAAK,2BAA2B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC7E,qBAAa,oBAAqB,YAAW,IAAI;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,YAAY,EAAE,eAAe,EAC7B,MAAM,CAAC,EAAE,2BAA2B;IActC,cAAc;IAId,SAAS;IAiBT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAQpC,YAAY;IAGZ,QAAQ;IAGR,KAAK;CAGN"}
+{"version":3,"file":"equationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,KAAK,2BAA2B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC7E,qBAAa,oBAAqB,YAAW,IAAI;IAC/C,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,YAAY,EAAE,eAAe,EAC7B,MAAM,CAAC,EAAE,2BAA2B;IActC,aAAa;;;;;;;;;IAMb,cAAc;IAId,SAAS;IAiBT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAQpC,YAAY;IAGZ,QAAQ;IAGR,KAAK;CAGN"}

package/lib/tree/nodes/equations/equationSolutionNode.js

@@ -14,6 +14,12 @@ class EquationSolutionNode {
             }
             : { allowRawRightChildAsSolution: true };
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.equationSolution,
+            solutionsSet: this.solutionsSet.toIdentifiers(),
+        };
+    }
     toAllValidTexs() {
         return this.toEquivalentNodes(this.opts).flatMap((el) => el.toAllTexs());
     }

package/lib/tree/nodes/equations/multiEqualNode.d.ts

@@ -1,10 +1,16 @@
-import { Node, NodeOptions, NodeType } from "../node";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 export declare class MultiEqualNode implements Node {
     children: Node[];
     opts?: NodeOptions;
     type: NodeType;
     constructor(children: Node[], opts?: NodeOptions);
     toEquivalentNodes(): MultiEqualNode[];
+    toIdentifiers(): {
+        id: NodeIds;
+        children: ({
+            id: NodeIds;
+        } & Record<string, any>)[];
+    };
     toAllTexs(): string[];
     toAllValidTexs(): string[];
     toMathString(): string;

package/lib/tree/nodes/equations/multiEqualNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiEqualNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/multiEqualNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAItD,qBAAa,cAAe,YAAW,IAAI;IACzC,QAAQ,EAAE,IAAI,EAAE,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAMhD,iBAAiB;IAUjB,SAAS;IAMT,cAAc,IAAI,MAAM,EAAE;IAI1B,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAGT"}
+{"version":3,"file":"multiEqualNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/multiEqualNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAI/D,qBAAa,cAAe,YAAW,IAAI;IACzC,QAAQ,EAAE,IAAI,EAAE,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAMhD,iBAAiB;IAUjB,aAAa;;;;;;IAMb,SAAS;IAMT,cAAc,IAAI,MAAM,EAAE;IAI1B,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;CAGT"}

package/lib/tree/nodes/equations/multiEqualNode.js

@@ -19,6 +19,12 @@ class MultiEqualNode {
         });
         return res;
     }
+    toIdentifiers() {
+        return {
+            id: node_1.NodeIds.multiEqual,
+            children: this.children.map((e) => e.toIdentifiers()),
+        };
+    }
     toAllTexs() {
         const permutations = (0, permutations_1.permute)(this.children);
         return permutations.flatMap((permutation) => `${permutation.map((node) => node.toTex()).join("=")}`);

package/lib/tree/nodes/functions/absNode.d.ts

@@ -1,4 +1,4 @@
-import { Node, NodeType } from "../node";
+import { Node, NodeIds, NodeType } from "../node";
 import { FunctionNode, FunctionsIds } from "./functionNode";
 import { AlgebraicNode } from "../algebraicNode";
 export declare function isAbsNode(a: Node): a is AbsNode;
@@ -8,6 +8,12 @@ export declare class AbsNode implements FunctionNode {
     type: NodeType;
     isNumeric: boolean;
     constructor(child: AlgebraicNode);
+    toIdentifiers(): {
+        id: NodeIds;
+        child: {
+            id: NodeIds;
+        } & Record<string, any>;
+    };
     toMathString(): string;
     toTex(): string;
     toEquivalentNodes(): AlgebraicNode[];

package/lib/tree/nodes/functions/absNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"absNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/absNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa;IAOhC,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAOf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ;IAIR,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}
+{"version":3,"file":"absNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/absNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AACD,qBAAa,OAAQ,YAAW,YAAY;IAC1C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa;IAMhC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAOf,iBAAiB,IAAI,aAAa,EAAE;IASpC,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ;IAIR,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}