math-exercises 2.2.80 → 2.2.82

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,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;IAkBT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAQpC,YAAY;IAGZ,QAAQ;IAGR,KAAK;IAGL,QAAQ;CAGT"}
+{"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;IAkBT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAQpC,YAAY;IAIZ,KAAK;IAGL,QAAQ;CAGT"}

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

@@ -49,9 +49,6 @@ class EquationSolutionNode {
     toMathString() {
         return "";
     }
-    toMathjs() {
-        return `S={${this.solutionsSet.toMathjs()}}`;
-    }
     toTex() {
         return `S=${this.solutionsSet.toTex()}`;
     }

package/lib/tree/nodes/inequations/inequationNode.d.ts

@@ -18,12 +18,13 @@ export declare class InequationNode implements Node {
         symbols: InegalitySymbols[];
     };
     toInterval(): IntervalNode;
+    /**turns x<3 into 3>x */
     toReversed(): InequationNode;
     toSwitched(): InequationNode;
+    toSwicthedStrictness(): InequationNode;
     toAllValidTexs(): string[];
     toEquivalentNodes(opts?: NodeOptions | undefined): InequationNode[];
     toMathString(): string;
-    toMathjs(): string;
     toAllTexs(): string[];
     toTex(): string;
     simplify(opts?: SimplifyOptions): InequationNode;

package/lib/tree/nodes/inequations/inequationNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequationNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationNode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEjB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAG/D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAMvD,qBAAa,cAAe,YAAW,IAAI;IACzC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,gBAAgB,EAAE,CAAC;gBAE1B,QAAQ,EAAE,aAAa,EAAE,EACzB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAuBhD,aAAa;;;;;;;IAOb,UAAU;IA6CV,UAAU;IAQV,UAAU;IAMV,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,QAAQ;IAGR,SAAS;IAGT,KAAK;IAGL,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,cAAc;CAcjD;AAED,eAAO,MAAM,kCAAkC,WACrC,MAAM,SACP,gBAAgB,SAChB,aAAa,WAuBrB,CAAC"}
+{"version":3,"file":"inequationNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationNode.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEjB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAG/D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAMvD,qBAAa,cAAe,YAAW,IAAI;IACzC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,gBAAgB,EAAE,CAAC;gBAE1B,QAAQ,EAAE,aAAa,EAAE,EACzB,OAAO,EAAE,gBAAgB,EAAE,GAAG,gBAAgB;IAuBhD,aAAa;;;;;;;IAOb,UAAU;IA8CV,wBAAwB;IACxB,UAAU;IAQV,UAAU;IAMV,oBAAoB;IAMpB,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS;IAYhD,YAAY;IAGZ,SAAS;IAGT,KAAK;IAGL,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,cAAc;CAcjD;AAED,eAAO,MAAM,kCAAkC,WACrC,MAAM,SACP,gBAAgB,SAChB,aAAa,WAuBrB,CAAC"}

package/lib/tree/nodes/inequations/inequationNode.js

@@ -79,6 +79,7 @@ class InequationNode {
             return new intervalNode_1.IntervalNode(leftIsInf ? infiniteNode_1.MinusInfinityNode : this.children[1], rightIsInf ? infiniteNode_1.PlusInfinityNode : this.children[1], closure);
         }
     }
+    /**turns x<3 into 3>x */
     toReversed() {
         const newChildren = [...this.children].reverse();
         const newSymbols = this.symbols.map((el) => new inequation_1.InequationSymbol(el).reversed());
@@ -87,6 +88,9 @@ class InequationNode {
     toSwitched() {
         return new InequationNode(this.children, this.symbols.map((el) => new inequation_1.InequationSymbol(el).reversed()));
     }
+    toSwicthedStrictness() {
+        return new InequationNode(this.children, this.symbols.map((el) => new inequation_1.InequationSymbol(el).strictnessToggled()));
+    }
     toAllValidTexs() {
         return this.toEquivalentNodes().map((node) => node.toTex());
     }
@@ -105,9 +109,6 @@ class InequationNode {
     toMathString() {
         return this.tex;
     }
-    toMathjs() {
-        return this.tex;
-    }
     toAllTexs() {
         return [this.toTex()];
     }

package/lib/tree/nodes/inequations/inequationSolutionNode.d.ts

@@ -24,7 +24,6 @@ export declare class InequationSolutionNode implements Node {
     toAllValidTexs(): string[];
     toEquivalentNodes(opts?: NodeOptions): (import("./inequationNode").InequationNode | InequationSolutionNode)[];
     toMathString(): string;
-    toMathjs(): string;
     toTex(): string;
     simplify(): this;
 }

package/lib/tree/nodes/inequations/inequationSolutionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAkB,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,KAAK,6BAA6B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC/E,qBAAa,sBAAuB,YAAW,IAAI;IACjD,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,YAAY,GAAG,iBAAiB,CAAC;IACnD,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,gBAAgB,EAAE,YAAY,GAAG,iBAAiB,EAClD,MAAM,CAAC,EAAE,6BAA6B;IAaxC,aAAa;;;;;;;;;IAMb,SAAS;IAUT,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAepC,YAAY;IAGZ,QAAQ;IAGR,KAAK;IAGL,QAAQ;CAGT"}
+{"version":3,"file":"inequationSolutionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/inequations/inequationSolutionNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAkB,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,KAAK,6BAA6B,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,CAAC;AAC/E,qBAAa,sBAAuB,YAAW,IAAI;IACjD,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,YAAY,GAAG,iBAAiB,CAAC;IACnD,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,gBAAgB,EAAE,YAAY,GAAG,iBAAiB,EAClD,MAAM,CAAC,EAAE,6BAA6B;IAaxC,aAAa;;;;;;;;;IAMb,SAAS;IAUT,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAepC,YAAY;IAIZ,KAAK;IAGL,QAAQ;CAGT"}

package/lib/tree/nodes/inequations/inequationSolutionNode.js

@@ -51,9 +51,6 @@ class InequationSolutionNode {
     toMathString() {
         return "";
     }
-    toMathjs() {
-        return `S={${this.intervalSolution.toMathjs()}}`;
-    }
     toTex() {
         return `S=\\ ${this.intervalSolution.toTex()}`;
     }

package/lib/tree/nodes/numbers/numberNode.d.ts

@@ -24,7 +24,7 @@ export declare class NumberNode implements AlgebraicNode {
     toAllValidTexs(): string[];
     toEquivalentNodes(): this[];
     evaluate(vars?: Record<string, number>): number;
-    simplify(opts?: SimplifyOptions): NumberNode | import("../operators/fractionNode").FractionNode | OppositeNode<import("../operators/fractionNode").FractionNode>;
+    simplify(opts?: SimplifyOptions): AlgebraicNode | NumberNode;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): this;
     derivative(varName?: string | undefined): AlgebraicNode;

package/lib/tree/nodes/operators/multiplyNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,kBAAkB,CAAC;AAS1B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,MAChB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IA4ErC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAiK/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,kBAAkB,CAAC;AAU1B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,MAChB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAgFrC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAiK/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}

package/lib/tree/nodes/operators/multiplyNode.js

@@ -20,6 +20,7 @@ const addNode_1 = require("./addNode");
 const round_1 = require("../../../math/utils/round");
 const colorize_1 = require("../../../utils/latex/colorize");
 const substractNode_1 = require("./substractNode");
+const constantNode_1 = require("../numbers/constantNode");
 function isMultiplyNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.multiply;
 }
@@ -91,10 +92,14 @@ class MultiplyNode {
             return (0, colorize_1.colorize)("-" + rightTex, color);
             // }
         }
+        //!this is atrocious
         let showTimesSign = !opts?.forceDotSign &&
             (opts?.forceTimesSign ||
                 !isNaN(+rightTex[0]) ||
-                (this.rightChild.isNumeric && this.leftChild.isNumeric) ||
+                (this.rightChild.isNumeric &&
+                    this.leftChild.isNumeric &&
+                    !(0, constantNode_1.isConstantNode)(this.rightChild) &&
+                    !(0, sqrtNode_1.isSqrtNode)(this.rightChild)) ||
                 (0, numberNode_1.isNumberNode)(this.rightChild) ||
                 ((0, variableNode_1.isVariableNode)(this.leftChild) &&
                     (0, variableNode_1.isVariableNode)(this.rightChild) &&

package/lib/tree/nodes/sets/closure.d.ts

@@ -11,7 +11,12 @@ export declare abstract class Closure {
     static rightReverse(closure: ClosureType): ClosureType;
     static switch(closure: ClosureType): ClosureType;
     static fromBrackets(left: "[" | "]", right: "]" | "["): ClosureType;
+    static toBrackets(closure: ClosureType): string[];
     static isLeftOpen(closure: ClosureType): boolean;
     static isRightOpen(closure: ClosureType): boolean;
+    static getLessLeftStrict: (a: "[" | "]", b: "[" | "]") => "[" | "]";
+    static getLessRightStrict: (a: "[" | "]", b: "[" | "]") => "[" | "]";
+    static getMostLeftStrict: (a: "[" | "]", b: "[" | "]") => "[" | "]";
+    static getMostRightStrict: (a: "[" | "]", b: "[" | "]") => "[" | "]";
 }
 //# sourceMappingURL=closure.d.ts.map

package/lib/tree/nodes/sets/closure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"closure.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/closure.ts"],"names":[],"mappings":"AAEA,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AAED,8BAAsB,OAAO;IAC3B,MAAM,CAAC,MAAM;IAcb,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,WAAW;IAYnC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW;IAYvC,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,WAAW;IAYxC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW;IAYlC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG;IAQrD,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW;IAUtC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW;CAUxC"}
+{"version":3,"file":"closure.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/closure.ts"],"names":[],"mappings":"AAEA,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AAED,8BAAsB,OAAO;IAC3B,MAAM,CAAC,MAAM;IAcb,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,WAAW;IAYnC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW;IAYvC,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,WAAW;IAYxC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW;IAYlC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG;IAQrD,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW;IAatC,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW;IAUtC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW;IAWvC,MAAM,CAAC,iBAAiB,MAAO,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,eAGpD;IACF,MAAM,CAAC,kBAAkB,MAAO,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,eAGrD;IACF,MAAM,CAAC,iBAAiB,MAAO,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,eAGpD;IACF,MAAM,CAAC,kBAAkB,MAAO,GAAG,GAAG,GAAG,KAAK,GAAG,GAAG,GAAG,eAGrD;CACH"}

package/lib/tree/nodes/sets/closure.js

@@ -83,6 +83,18 @@ class Closure {
         else
             return ClosureType.OF;
     }
+    static toBrackets(closure) {
+        switch (closure) {
+            case ClosureType.FF:
+                return ["[", "]"];
+            case ClosureType.FO:
+                return ["[", "["];
+            case ClosureType.OF:
+                return ["]", "]"];
+            case ClosureType.OO:
+                return ["]", "["];
+        }
+    }
     static isLeftOpen(closure) {
         switch (closure) {
             case ClosureType.FF:
@@ -105,3 +117,23 @@ class Closure {
     }
 }
 exports.Closure = Closure;
+Closure.getLessLeftStrict = (a, b) => {
+    if (a === "[" || b === "[")
+        return "[";
+    return "]";
+};
+Closure.getLessRightStrict = (a, b) => {
+    if (a === "]" || b === "]")
+        return "]";
+    return "[";
+};
+Closure.getMostLeftStrict = (a, b) => {
+    if (a === "]" || b === "]")
+        return "]";
+    return "[";
+};
+Closure.getMostRightStrict = (a, b) => {
+    if (a === "[" || b === "[")
+        return "[";
+    return "]";
+};

package/lib/tree/nodes/sets/discreteSetNode.d.ts

@@ -1,3 +1,4 @@
+import { AlgebraicNode } from "../algebraicNode";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { SetIds, SetNode } from "./setNode";
 export declare function isDiscreteSetNode(a: Node): a is DiscreteSetNode;
@@ -5,9 +6,9 @@ export declare class DiscreteSetNode implements SetNode {
     type: NodeType;
     id: SetIds;
     opts?: NodeOptions | undefined;
-    elements: Node[];
+    elements: AlgebraicNode[];
     isEmpty: boolean;
-    constructor(elements: Node[], opts?: NodeOptions);
+    constructor(elements: AlgebraicNode[], opts?: NodeOptions);
     isEmptySet(): boolean;
     toAllValidTexs(): string[];
     toIdentifiers(): {
@@ -18,10 +19,9 @@ export declare class DiscreteSetNode implements SetNode {
     };
     toEquivalentNodes(opts?: NodeOptions): DiscreteSetNode[];
     toMathString(): string;
-    toMathjs(): string;
     toTex(): string;
     toDeleteRandomElement(): DiscreteSetNode;
-    simplify(): this;
+    simplify(): DiscreteSetNode;
 }
 export declare const EmptySet: DiscreteSetNode;
 //# sourceMappingURL=discreteSetNode.d.ts.map

package/lib/tree/nodes/sets/discreteSetNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discreteSetNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/discreteSetNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AACvD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,eAAe,CAE/D;AACD,qBAAa,eAAgB,YAAW,OAAO;IAC7C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,IAAI,EAAE,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;gBACL,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAOhD,UAAU;IAGV,cAAc;IAGd,aAAa;;;;;;IAMb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAyBpC,YAAY;IAGZ,QAAQ;IAGR,KAAK;IAOL,qBAAqB;IAMrB,QAAQ;CAGT;AAED,eAAO,MAAM,QAAQ,iBAA0B,CAAC"}
+{"version":3,"file":"discreteSetNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/discreteSetNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AACvD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,eAAe,CAE/D;AACD,qBAAa,eAAgB,YAAW,OAAO;IAC7C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;gBACL,QAAQ,EAAE,aAAa,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAOzD,UAAU;IAGV,cAAc;IAGd,aAAa;;;;;;IAMb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAyBpC,YAAY;IAIZ,KAAK;IAOL,qBAAqB;IAMrB,QAAQ;CAOT;AAED,eAAO,MAAM,QAAQ,iBAA0B,CAAC"}

package/lib/tree/nodes/sets/discreteSetNode.js

@@ -55,9 +55,6 @@ class DiscreteSetNode {
     toMathString() {
         return `{${this.elements.map((el) => el.toTex()).join(";")}}`;
     }
-    toMathjs() {
-        return `{${this.elements.map((el) => el.toTex()).join(";")}}`;
-    }
     toTex() {
         if (!this.elements.length)
             return `\\varnothing`;
@@ -72,7 +69,9 @@ class DiscreteSetNode {
         return new DiscreteSetNode(newElements);
     }
     simplify() {
-        return this;
+        return new DiscreteSetNode(this.elements
+            .map((el) => el.simplify())
+            .sort((a, b) => a.evaluate() - b.evaluate()));
     }
 }
 exports.DiscreteSetNode = DiscreteSetNode;

package/lib/tree/nodes/sets/intervalNode.d.ts

@@ -3,9 +3,15 @@ import { InequationNode } from "../inequations/inequationNode";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { NodeIdentifiers } from "../nodeConstructor";
 import { ClosureType } from "./closure";
+import { DiscreteSetNode } from "./discreteSetNode";
 import { SetIds, SetNode } from "./setNode";
 import { UnionIntervalNode } from "./unionIntervalNode";
 export declare function isIntervalNode(a: Node): a is IntervalNode;
+export declare abstract class IntervalNodeConstructor {
+    static random(): IntervalNode;
+    static differentRandoms(nb: number): IntervalNode[];
+    static fromIdentifiers(ids: IntervalNodeIdentifiers): IntervalNode;
+}
 export type IntervalNodeIdentifiers = {
     id: NodeIds;
     leftChild: NodeIdentifiers;
@@ -26,7 +32,7 @@ export declare class IntervalNode implements SetNode {
     toEquivalentNodes(opts?: NodeOptions): IntervalNode[];
     toInequality(middleChild?: AlgebraicNode): InequationNode;
     toMathString(): string;
-    toMathjs(): string;
+    equals(i: IntervalNode): boolean;
     toReversedClosure(): IntervalNode;
     toLeftReversedClosure(): IntervalNode;
     toRightReversedClosure(): IntervalNode;
@@ -37,5 +43,11 @@ export declare class IntervalNode implements SetNode {
     toIdentifiers(): IntervalNodeIdentifiers;
     toText(isPlural: boolean, isFeminine: boolean): string;
     simplify(opts?: SimplifyOptions): IntervalNode;
+    isLeftClosed(): boolean;
+    isRightClosed(): boolean;
+    includes(a: AlgebraicNode): boolean;
+    isDisjoint(otherInt: IntervalNode): void;
+    intersection(otherInt: IntervalNode): DiscreteSetNode | IntervalNode;
+    union(otherInt: IntervalNode): IntervalNode | UnionIntervalNode;
 }
 //# sourceMappingURL=intervalNode.d.ts.map

package/lib/tree/nodes/sets/intervalNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/intervalNode.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAIrD,OAAO,EAAW,WAAW,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AACF,qBAAa,YAAa,YAAW,OAAO;IAC1C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;gBAEf,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,OAAO,EAAE,WAAW,EACpB,IAAI,CAAC,EAAE,WAAW;IAWpB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW;IAMjC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAoBpC,YAAY,CAAC,WAAW,CAAC,EAAE,aAAa;IA4BxC,YAAY;IAIZ,QAAQ;IAIR,iBAAiB;IAGjB,qBAAqB;IAGrB,sBAAsB;IAGtB,wBAAwB;IAYxB,YAAY;IAkCZ,KAAK;IAWL,SAAS,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAOvC,aAAa,IAAI,uBAAuB;IAUxC,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO;IAiB7C,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;CAQhC"}
+{"version":3,"file":"intervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/intervalNode.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAkB,MAAM,oBAAoB,CAAC;AAIrE,OAAO,EAAW,WAAW,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,eAAe,EAAY,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,8BAAsB,uBAAuB;IAC3C,MAAM,CAAC,MAAM;IA2Cb,MAAM,CAAC,gBAAgB,CAAC,EAAE,EAAE,MAAM;IAYlC,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,uBAAuB;CAQpD;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AACF,qBAAa,YAAa,YAAW,OAAO;IAC1C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;gBAEf,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,OAAO,EAAE,WAAW,EACpB,IAAI,CAAC,EAAE,WAAW;IAWpB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW;IAMjC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAoBpC,YAAY,CAAC,WAAW,CAAC,EAAE,aAAa;IA4BxC,YAAY;IAIZ,MAAM,CAAC,CAAC,EAAE,YAAY;IAMtB,iBAAiB;IAGjB,qBAAqB;IAGrB,sBAAsB;IAGtB,wBAAwB;IAYxB,YAAY;IAkCZ,KAAK;IAWL,SAAS,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAOvC,aAAa,IAAI,uBAAuB;IAUxC,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO;IAiB7C,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAS/B,YAAY;IAGZ,aAAa;IAGb,QAAQ,CAAC,CAAC,EAAE,aAAa,GAAG,OAAO;IAanC,UAAU,CAAC,QAAQ,EAAE,YAAY;IAEjC,YAAY,CAAC,QAAQ,EAAE,YAAY;IAwDnC,KAAK,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,GAAG,iBAAiB;CAkDhE"}

package/lib/tree/nodes/sets/intervalNode.js

@@ -1,20 +1,84 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntervalNode = exports.isIntervalNode = void 0;
+exports.IntervalNode = exports.IntervalNodeConstructor = exports.isIntervalNode = void 0;
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const random_1 = require("../../../utils/alea/random");
 const cartesianProducts_1 = require("../../../utils/arrays/cartesianProducts");
 const inequationNode_1 = require("../inequations/inequationNode");
 const node_1 = require("../node");
+const nodeConstructor_1 = require("../nodeConstructor");
 const constantNode_1 = require("../numbers/constantNode");
 const infiniteNode_1 = require("../numbers/infiniteNode");
 const variableNode_1 = require("../variables/variableNode");
 const closure_1 = require("./closure");
+const discreteSetNode_1 = require("./discreteSetNode");
 const setNode_1 = require("./setNode");
 const unionIntervalNode_1 = require("./unionIntervalNode");
 function isIntervalNode(a) {
     return (0, setNode_1.isSetNode)(a) && a.id === setNode_1.SetIds.interval;
 }
 exports.isIntervalNode = isIntervalNode;
+class IntervalNodeConstructor {
+    static random() {
+        const randType = (0, randint_1.randint)(0, 6);
+        let a, b;
+        let min, max, closure;
+        switch (randType) {
+            case 0:
+                min = infiniteNode_1.MinusInfinityNode;
+                max = (0, randint_1.randint)(-10, 10).toTree();
+                closure = (0, coinFlip_1.coinFlip)() ? closure_1.ClosureType.OF : closure_1.ClosureType.OO;
+                break;
+            case 1:
+                min = (0, randint_1.randint)(-10, 10).toTree();
+                max = infiniteNode_1.PlusInfinityNode;
+                closure = (0, coinFlip_1.coinFlip)() ? closure_1.ClosureType.OO : closure_1.ClosureType.FO;
+                break;
+            case 2:
+                a = (0, randint_1.randint)(-10, 10);
+                min = a.toTree();
+                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
+                closure = closure_1.ClosureType.FF;
+                break;
+            case 3:
+                a = (0, randint_1.randint)(-10, 10);
+                min = a.toTree();
+                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
+                closure = closure_1.ClosureType.OF;
+                break;
+            case 4:
+                a = (0, randint_1.randint)(-10, 10);
+                min = a.toTree();
+                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
+                closure = closure_1.ClosureType.FO;
+                break;
+            case 5:
+            default:
+                a = (0, randint_1.randint)(-10, 10);
+                min = a.toTree();
+                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
+                closure = closure_1.ClosureType.OO;
+                break;
+        }
+        return new IntervalNode(min, max, closure);
+    }
+    static differentRandoms(nb) {
+        const res = [];
+        for (let i = 0; i < nb; i++) {
+            let interval;
+            do {
+                interval = this.random();
+            } while (res.some((int) => int.equals(interval)));
+            res.push(this.random());
+        }
+        return res;
+    }
+    static fromIdentifiers(ids) {
+        return new IntervalNode((0, nodeConstructor_1.reifyAlgebraic)(ids.leftChild), (0, nodeConstructor_1.reifyAlgebraic)(ids.rightChild), ids.closure, ids.opts);
+    }
+}
+exports.IntervalNodeConstructor = IntervalNodeConstructor;
 class IntervalNode {
     constructor(a, b, closure, opts) {
         this.type = node_1.NodeType.set;
@@ -59,8 +123,8 @@ class IntervalNode {
     toMathString() {
         return this.toTex();
     }
-    toMathjs() {
-        return this.toTex();
+    equals(i) {
+        return (i.a.equals(this.a) && i.b.equals(this.b) && i.closure === this.closure);
     }
     toReversedClosure() {
         return new IntervalNode(this.a, this.b, closure_1.Closure.reverse(this.closure));
@@ -140,5 +204,92 @@ class IntervalNode {
     simplify(opts) {
         return new IntervalNode(this.a.simplify(opts), this.b.simplify(opts), this.closure, this.opts);
     }
+    isLeftClosed() {
+        return this.closure === closure_1.ClosureType.FF || this.closure === closure_1.ClosureType.FO;
+    }
+    isRightClosed() {
+        return this.closure === closure_1.ClosureType.FF || this.closure === closure_1.ClosureType.OF;
+    }
+    includes(a) {
+        const ev = a.evaluate();
+        const aEv = this.a.evaluate();
+        const bEv = this.b.evaluate();
+        if (ev === Number.NEGATIVE_INFINITY)
+            return aEv === Number.NEGATIVE_INFINITY;
+        if (ev === Number.POSITIVE_INFINITY)
+            return bEv === Number.POSITIVE_INFINITY;
+        if (Math.abs(ev - aEv) < 0.0000000001)
+            return this.isLeftClosed();
+        if (Math.abs(ev - bEv) < 0.0000000001)
+            return this.isRightClosed();
+        return ev > aEv && ev < bEv;
+    }
+    isDisjoint(otherInt) { }
+    intersection(otherInt) {
+        const [thisA, thisB] = [this.a.evaluate(), this.b.evaluate()];
+        const [otherA, otherB] = [otherInt.a.evaluate(), otherInt.b.evaluate()];
+        const ordered = thisA < otherA ? [this, otherInt] : [otherInt, this];
+        const orderedEv = ordered.map((e) => {
+            return [e.a.evaluate(), e.b.evaluate()];
+        });
+        const orderedBrackets = ordered.map((int) => closure_1.Closure.toBrackets(int.closure));
+        if (ordered[0].includes(ordered[1].a) ||
+            Math.abs(thisA - otherA) < 0.0000000001) {
+            if (Math.abs(orderedEv[0][1] - orderedEv[1][0]) < 0.0000000001) {
+                return new discreteSetNode_1.DiscreteSetNode([ordered[1].a]);
+            }
+            let leftBracket = "[";
+            if (Math.abs(thisA - otherA) < 0.0000000001) {
+                leftBracket = closure_1.Closure.getMostLeftStrict(orderedBrackets[0][0], orderedBrackets[1][0]);
+            }
+            else
+                leftBracket = orderedBrackets[1][0];
+            let rightBracket = "[";
+            if (Math.abs(thisB - otherB) < 0.0000000001) {
+                rightBracket = closure_1.Closure.getMostRightStrict(orderedBrackets[0][1], orderedBrackets[1][1]);
+                return new IntervalNode(ordered[1].a, ordered[1].b, closure_1.Closure.fromBrackets(leftBracket, rightBracket));
+            }
+            else {
+                const rightBornIndex = ordered[0].b.evaluate() < ordered[1].b.evaluate() ? 0 : 1;
+                const right = ordered[rightBornIndex].b;
+                rightBracket = orderedBrackets[rightBornIndex][1];
+                return new IntervalNode(ordered[1].a, right, closure_1.Closure.fromBrackets(leftBracket, rightBracket));
+            }
+        }
+        else {
+            return discreteSetNode_1.EmptySet;
+        }
+    }
+    union(otherInt) {
+        const [thisA, thisB] = [this.a.evaluate(), this.b.evaluate()];
+        const [otherA, otherB] = [otherInt.a.evaluate(), otherInt.b.evaluate()];
+        const ordered = thisA < otherA ? [this, otherInt] : [otherInt, this];
+        const orderedBrackets = ordered.map((int) => closure_1.Closure.toBrackets(int.closure));
+        if (ordered[0].includes(ordered[1].a) ||
+            ordered[1].includes(ordered[0].b) ||
+            ordered[1].includes(ordered[0].a) ||
+            Math.abs(thisA - otherA) < 0.0000000001) {
+            let leftBracket = "[";
+            if (Math.abs(thisA - otherA) < 0.0000000001) {
+                leftBracket = closure_1.Closure.getLessLeftStrict(orderedBrackets[0][0], orderedBrackets[1][0]);
+            }
+            else
+                leftBracket = orderedBrackets[0][0];
+            let rightBracket = "[";
+            if (Math.abs(thisB - otherB) < 0.0000000001) {
+                rightBracket = closure_1.Closure.getLessRightStrict(orderedBrackets[0][1], orderedBrackets[1][1]);
+                return new IntervalNode(ordered[0].a, ordered[1].b, closure_1.Closure.fromBrackets(leftBracket, rightBracket));
+            }
+            else {
+                const rightBornIndex = ordered[0].b.evaluate() > ordered[1].b.evaluate() ? 0 : 1;
+                const right = ordered[rightBornIndex].b;
+                rightBracket = orderedBrackets[rightBornIndex][1];
+                return new IntervalNode(ordered[0].a, right, closure_1.Closure.fromBrackets(leftBracket, rightBracket));
+            }
+        }
+        else {
+            return new unionIntervalNode_1.UnionIntervalNode([ordered[0], ordered[1]], this.opts);
+        }
+    }
 }
 exports.IntervalNode = IntervalNode;

package/lib/tree/parsers/discreteSetParser.d.ts

@@ -1,3 +1,3 @@
-import { AlgebraicNode } from "../nodes/algebraicNode";
-export declare const discreteSetParser: (str: string) => false | AlgebraicNode[];
+import { DiscreteSetNode } from "../nodes/sets/discreteSetNode";
+export declare const discreteSetParser: (str: string) => false | DiscreteSetNode;
 //# sourceMappingURL=discreteSetParser.d.ts.map

package/lib/tree/parsers/discreteSetParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discreteSetParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/discreteSetParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmB,MAAM,wBAAwB,CAAC;AAMxE,eAAO,MAAM,iBAAiB,QAAS,MAAM,4BAe5C,CAAC"}
+{"version":3,"file":"discreteSetParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/discreteSetParser.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAIhE,eAAO,MAAM,iBAAiB,QAAS,MAAM,4BAe5C,CAAC"}

package/lib/tree/parsers/discreteSetParser.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.discreteSetParser = void 0;
+const discreteSetNode_1 = require("../nodes/sets/discreteSetNode");
 const latexParser_1 = require("./latexParser");
 const discreteSetParser = (str) => {
     try {
@@ -14,7 +15,7 @@ const discreteSetParser = (str) => {
         const elements = formated.split(";").map((e) => (0, latexParser_1.parseAlgebraic)(e));
         if (elements.some((e) => !e))
             return false;
-        return elements;
+        return new discreteSetNode_1.DiscreteSetNode(elements);
     }
     catch (err) {
         return false;

package/lib/tree/parsers/equationSolutionParser.js

@@ -17,7 +17,7 @@ const equationSolutionParser = (str, variable = "x") => {
                     : undefined;
             if (varNode === undefined)
                 return false;
-            if (children[varNode].name !== "x")
+            if (children[varNode].name !== variable)
                 return false;
             const scalar = children[(varNode + 1) % 2];
             if (!(0, algebraicNode_1.isAlgebraicNode)(scalar) || !scalar.isNumeric)

package/lib/tree/parsers/powerParser.d.ts

@@ -1,2 +1,2 @@
-export declare const powerParser: (ans: string) => false | import("../nodes/operators/fractionNode").FractionNode | import("../nodes/functions/sqrtNode").SqrtNode | import("../nodes/operators/powerNode").PowerNode;
+export declare const powerParser: (ans: string) => false | import("../nodes/functions/sqrtNode").SqrtNode | import("../nodes/operators/powerNode").PowerNode | import("../nodes/operators/fractionNode").FractionNode;
 //# sourceMappingURL=powerParser.d.ts.map

package/lib/tree/parsers/rationalParser.d.ts

@@ -1,3 +1,3 @@
 import { FractionNode } from "../nodes/operators/fractionNode";
-export declare const rationalParser: (ans: string) => false | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/numbers/numberNode").NumberNode | FractionNode | import("../nodes/functions/oppositeNode").OppositeNode<import("../nodes/algebraicNode").AlgebraicNode>;
+export declare const rationalParser: (ans: string) => false | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/functions/oppositeNode").OppositeNode<import("../nodes/algebraicNode").AlgebraicNode> | FractionNode;
 //# sourceMappingURL=rationalParser.d.ts.map

package/lib/tree/parsers/unionIntervalParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unionIntervalParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/unionIntervalParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAIpE,KAAK,IAAI,GAAG;IACV,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,mBAAmB,QAAS,MAAM,SAAS,IAAI,6CAe3D,CAAC"}
+{"version":3,"file":"unionIntervalParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/unionIntervalParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAIpE,KAAK,IAAI,GAAG;IACV,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,mBAAmB,QAAS,MAAM,SAAS,IAAI,6CAmB3D,CAAC"}

package/lib/tree/parsers/unionIntervalParser.js

@@ -17,7 +17,9 @@ const unionIntervalParser = (ans, opts) => {
             return false;
         if (intervals.length === 1)
             return intervals[0];
-        return new unionIntervalNode_1.UnionIntervalNode(intervals);
+        return new unionIntervalNode_1.UnionIntervalNode(intervals.sort((a, b) => {
+            return a.a.evaluate() - b.a.evaluate();
+        }));
     }
     catch (err) {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.2.80",
+  "version": "2.2.82",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [