math-exercises 2.2.81 → 2.2.83

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.81",
+  "version": "2.2.83",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [