math-exercises 2.0.28 → 2.0.30

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

@@ -1,53 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Interval = exports.IntervalConstructor = void 0;
-const epsilon_1 = require("../../../math/numbers/epsilon");
-const integer_1 = require("../../../math/numbers/integer/integer");
-const nombre_1 = require("../../../math/numbers/nombre");
-const real_1 = require("../../../math/numbers/reals/real");
 const randint_1 = require("../../../math/utils/random/randint");
-const round_1 = require("../../../math/utils/round");
 const infiniteNode_1 = require("../../../tree/nodes/numbers/infiniteNode");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const mathSet_1 = require("../mathSet");
 class IntervalConstructor {
     static random() {
-        let tex = "";
         const randType = (0, randint_1.randint)(0, 6);
         let a, b;
+        let min, max, closure;
         switch (randType) {
             case 0:
-                b = (0, randint_1.randint)(-10, 10);
-                tex = `]-\\infty;${b}${(0, coinFlip_1.coinFlip)() ? "]" : "["}`;
+                min = infiniteNode_1.MinusInfinityNode;
+                max = (0, randint_1.randint)(-10, 10).toTree();
+                closure = (0, coinFlip_1.coinFlip)() ? intervalNode_1.ClosureType.OF : intervalNode_1.ClosureType.OO;
                 break;
             case 1:
-                a = (0, randint_1.randint)(-10, 10);
-                tex = `${(0, coinFlip_1.coinFlip)() ? "]" : "["}${a};+\\infty[`;
+                min = (0, randint_1.randint)(-10, 10).toTree();
+                max = infiniteNode_1.PlusInfinityNode;
+                closure = (0, coinFlip_1.coinFlip)() ? intervalNode_1.ClosureType.OO : intervalNode_1.ClosureType.FO;
                 break;
             case 2:
                 a = (0, randint_1.randint)(-10, 10);
-                b = (0, randint_1.randint)(a + 1, a + 10);
-                tex = `[${a};${b}]`;
+                min = a.toTree();
+                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
+                closure = intervalNode_1.ClosureType.FF;
                 break;
             case 3:
                 a = (0, randint_1.randint)(-10, 10);
-                b = (0, randint_1.randint)(a + 1, a + 10);
-                tex = `]${a};${b}]`;
+                min = a.toTree();
+                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
+                closure = intervalNode_1.ClosureType.OF;
                 break;
             case 4:
                 a = (0, randint_1.randint)(-10, 10);
-                b = (0, randint_1.randint)(a + 1, a + 10);
-                tex = `[${a};${b}[`;
+                min = a.toTree();
+                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
+                closure = intervalNode_1.ClosureType.FO;
                 break;
             case 5:
+            default:
                 a = (0, randint_1.randint)(-10, 10);
-                b = (0, randint_1.randint)(a + 1, a + 10);
-                tex = `]${a};${b}[`;
+                min = a.toTree();
+                max = (0, randint_1.randint)(a + 1, a + 10).toTree();
+                closure = intervalNode_1.ClosureType.OO;
                 break;
         }
-        return new Interval(tex);
+        return new Interval(min, max, closure);
     }
     static differentRandoms(nb) {
         const res = [];
@@ -55,7 +56,7 @@ class IntervalConstructor {
             let interval;
             do {
                 interval = this.random();
-            } while (res.some((int) => int.tex === interval.tex));
+            } while (res.some((int) => int.equals(interval)));
             res.push(this.random());
         }
         return res;
@@ -63,63 +64,26 @@ class IntervalConstructor {
 }
 exports.IntervalConstructor = IntervalConstructor;
 class Interval {
-    /**
-     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
-     */
-    constructor(tex = "[-10; 10]") {
-        if (!tex.includes(";"))
-            throw Error("wrong interval format");
-        this.tex = tex;
-        const isInt = tex[1] === "[" || tex[1] === "]";
-        this.type = isInt ? nombre_1.NumberType.Integer : nombre_1.NumberType.Real;
-        const left = tex[0];
-        const right = tex[tex.length - 1];
-        const [a, b] = tex
-            .slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1)
-            .split(";");
-        this.minTex = a;
-        this.maxTex = b;
-        switch (`${left}a;b${right}`) {
-            case "[a;b]":
-                this.leftBracket = "[";
-                this.leftInequalitySymbol = "\\le";
-                this.rightInequalitySymbol = "\\le";
-                this.rightBracket = "]";
-                this.closure = intervalNode_1.ClosureType.FF;
-                break;
-            case "]a;b[":
-                this.leftBracket = "]";
-                this.rightBracket = "[";
-                this.leftInequalitySymbol = "<";
-                this.rightInequalitySymbol = "<";
-                this.closure = intervalNode_1.ClosureType.OO;
-                break;
-            case "[a;b[":
-                this.leftBracket = "[";
-                this.rightBracket = "[";
-                this.leftInequalitySymbol = "\\le";
-                this.rightInequalitySymbol = "<";
-                this.closure = intervalNode_1.ClosureType.FO;
-                break;
-            case "]a;b]":
-                this.leftBracket = "]";
-                this.rightBracket = "]";
-                this.leftInequalitySymbol = "<";
-                this.rightInequalitySymbol = "\\le";
-                this.closure = intervalNode_1.ClosureType.OF;
-                break;
-            default:
-                throw console.error("wrong interval format");
-        }
-        function getBound(bound) {
-            return bound === "-\\infty"
-                ? Number.NEGATIVE_INFINITY
-                : bound === "+\\infty"
-                    ? Number.POSITIVE_INFINITY
-                    : Number(bound);
-        }
-        this.min = getBound(a);
-        this.max = getBound(b);
+    constructor(min, max, closure) {
+        this.closure = closure;
+        this.minNode = min;
+        this.maxNode = max;
+        this.min = min.evaluate({});
+        this.max = max.evaluate({});
+        this.minTex = min.toTex();
+        this.maxTex = max.toTex();
+        this.leftBracket =
+            closure === intervalNode_1.ClosureType.FF || closure === intervalNode_1.ClosureType.FO ? "[" : "]";
+        this.rightBracket =
+            closure === intervalNode_1.ClosureType.FF || closure === intervalNode_1.ClosureType.OF ? "]" : "[";
+        this.leftInequalitySymbol = this.leftBracket === "[" ? "\\le" : "<";
+        this.rightInequalitySymbol = this.rightBracket === "]" ? "\\le" : "<";
+        this.tex = this.toTex();
+    }
+    equals(interval) {
+        return (this.min === interval.min &&
+            this.max === interval.max &&
+            this.closure === interval.closure);
     }
     union(interval) {
         let unionRightBracket = this.max > interval.max
@@ -136,10 +100,8 @@ class Interval {
                     ? "["
                     : "]"
                 : interval.leftBracket;
-        let min = Math.min(this.min, interval.min);
-        let minTex = this.min < interval.min ? this.minTex : interval.minTex;
-        let max = Math.max(this.max, interval.max);
-        let maxTex = this.max > interval.max ? this.maxTex : interval.maxTex;
+        let min = this.min < interval.min ? this.minNode : interval.minNode;
+        let max = this.max > interval.max ? this.maxNode : interval.maxNode;
         if (this.max < interval.min ||
             this.min > interval.max ||
             (this.max === interval.min &&
@@ -150,12 +112,13 @@ 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());
         }
         else {
-            return new Interval(`${unionLeftBracket}${minTex};${maxTex}${unionRightBracket}`);
+            const closure = (0, intervalNode_1.closureFromBrackets)(unionLeftBracket, unionRightBracket);
+            return new Interval(min, max, closure);
         }
     }
     intersection(interval) {
@@ -174,88 +137,51 @@ class Interval {
         }
         const winningLeftBracket = (brack1, brack2) => brack1 === "]" || brack2 === "]" ? "]" : "[";
         const winningRightBracket = (brack1, brack2) => brack1 === "[" || brack2 === "[" ? "[" : "]";
-        let min = Math.max(a, c);
-        let minTex = a >= c ? this.minTex : interval.minTex;
+        let min = a >= c ? this.minNode : interval.minNode;
         let leftBracket = a === c
             ? winningLeftBracket(this.leftBracket, interval.leftBracket)
             : a > c
                 ? this.leftBracket
                 : interval.leftBracket;
-        const max = Math.min(b, d);
-        let maxTex = b <= d ? this.maxTex : interval.maxTex;
+        const max = b <= d ? this.maxNode : interval.maxNode;
         let rightBracket = b === d
             ? winningRightBracket(this.rightBracket, interval.rightBracket)
             : b < d
                 ? this.rightBracket
                 : interval.rightBracket;
-        return new Interval(`${leftBracket}${minTex};${maxTex}${rightBracket}`);
-    }
-    exclude(nb) {
-        const rand = () => {
-            let x;
-            do {
-                x = this.getRandomElement();
-            } while (x.value === nb);
-            return x;
-        };
-        return new mathSet_1.MathSet(this.toTex() + `\\left\\{${nb}\\right\\}`, rand);
-    }
-    difference(set) {
-        const rand = () => {
-            let x;
-            do {
-                x = this.getRandomElement();
-            } while (set.includes(x));
-            return x;
-        };
-        return new mathSet_1.MathSet(this.toTex() + `\\ ${set.toTex()}`, rand);
+        const closure = (0, intervalNode_1.closureFromBrackets)(leftBracket, rightBracket);
+        return new Interval(min, max, closure);
     }
     insideToTex() {
-        return this.tex.replaceAll("[", "").replaceAll("]", "");
+        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 === intervalNode_1.ClosureType.FO || this.closure === intervalNode_1.ClosureType.FF;
         const isRightClosed = this.closure === intervalNode_1.ClosureType.FF || this.closure === intervalNode_1.ClosureType.OF;
         if (this.max === Infinity) {
             if (isLeftClosed) {
-                return `x\\ge${this.min}`;
+                return `x\\ge${this.minTex}`;
             }
             else
-                return `x>${this.min}`;
+                return `x>${this.minTex}`;
         }
         else if (this.min === -Infinity) {
             if (this.closure === intervalNode_1.ClosureType.OF) {
-                return `x\\le${this.max}`;
+                return `x\\le${this.maxTex}`;
             }
             else
-                return `x<${this.max}`;
+                return `x<${this.maxTex}`;
         }
-        return `${this.min}${isLeftClosed ? "\\le x" : "<x"}${isRightClosed ? "\\le" : "<"}${this.max}`;
+        return `${this.minTex}${isLeftClosed ? "\\le x" : "<x"}${isRightClosed ? "\\le" : "<"}${this.maxTex}`;
     }
-    getRandomElement(precision = this.type === nombre_1.NumberType.Integer ? 0 : 2) {
-        if (this.min === -Infinity || this.max === Infinity)
-            throw Error("Can't chose amongst infinity");
-        let min = this.closure === intervalNode_1.ClosureType.OO || this.closure === intervalNode_1.ClosureType.OF
-            ? this.min + epsilon_1.EPSILON
-            : this.min;
-        let max = this.closure === intervalNode_1.ClosureType.OO || this.closure === intervalNode_1.ClosureType.FO
-            ? this.max - epsilon_1.EPSILON
-            : this.max;
-        const value = (0, round_1.round)(min + Math.random() * (max - this.min), precision);
-        switch (this.type) {
-            case nombre_1.NumberType.Integer:
-                return new integer_1.Integer(value);
-            default:
-                return new real_1.Real(value, value.toString());
-        }
+    getRandomElement() {
+        throw Error("not implemented");
     }
     toTree() {
-        const a = this.min === -Infinity ? infiniteNode_1.MinusInfinityNode : new numberNode_1.NumberNode(this.min);
-        const b = this.max === Infinity ? infiniteNode_1.PlusInfinityNode : new numberNode_1.NumberNode(this.max);
-        return new intervalNode_1.IntervalNode(a, b, this.closure);
+        return new intervalNode_1.IntervalNode(this.minNode, this.maxNode, this.closure);
     }
 }
 exports.Interval = Interval;

package/lib/math/utils/random/randint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randint.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/random/randint.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,OAAO,MAAO,MAAM,MAAM,MAAM,aAAa,MAAM,EAAE,KAAG,MAQpE,CAAC"}
+{"version":3,"file":"randint.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/random/randint.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,OAAO,MAAO,MAAM,MAAM,MAAM,aAAa,MAAM,EAAE,KAAG,MAQpE,CAAC"}

package/lib/math/utils/random/randint.js

@@ -1,9 +1,9 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.randint = void 0;
 /**
  * @returns random [[a, b[[
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randint = void 0;
 const randint = (a, b, excludes) => {
     if (b === undefined)
         return Math.floor(Math.random() * a);

package/lib/server.d.ts

@@ -1,3 +1,9 @@
 import * as Exercises from "./exercises";
 export { Exercises };
+import { AlgebraicNode } from "./tree/nodes/algebraicNode";
+declare global {
+    interface Number {
+        toTree: () => AlgebraicNode;
+    }
+}
 //# sourceMappingURL=server.d.ts.map

package/lib/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAGzC,OAAO,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAGzC,OAAO,EAAE,SAAS,EAAE,CAAC;AAarB,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAe3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF"}

package/lib/server.js

@@ -35,8 +35,18 @@ const express_1 = __importDefault(require("express"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const cors_1 = __importDefault(require("cors"));
+const numberNode_1 = require("./tree/nodes/numbers/numberNode");
+const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const jsonParser = body_parser_1.default.json();
 const allExercises = [...exercises];
+Number.prototype.toTree = function () {
+    const value = this.valueOf();
+    if (value === Infinity)
+        return infiniteNode_1.PlusInfinityNode;
+    if (value === -Infinity)
+        return infiniteNode_1.MinusInfinityNode;
+    return new numberNode_1.NumberNode(value);
+};
 const runServer = () => {
     dotenv_1.default.config();
     const app = (0, express_1.default)();

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

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,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,YAAY,IAAI,MAAM;IAItB,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAyF/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,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,YAAY,IAAI,MAAM;IAItB,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA2BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAaf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAgJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAOrC"}

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

@@ -78,6 +78,9 @@ class FractionNode {
         const simplifiedNum = this.leftChild.simplify(opts);
         const simplifiedDenum = this.rightChild.simplify(opts);
         const copy = new FractionNode(simplifiedNum, simplifiedDenum, this.opts);
+        if ((0, numberNode_1.isNumberNode)(simplifiedNum) && simplifiedNum.value === 0) {
+            return new numberNode_1.NumberNode(0);
+        }
         if ((0, numberNode_1.isNumberNode)(simplifiedDenum) && simplifiedDenum.value === 1) {
             return simplifiedNum;
         }
@@ -86,11 +89,16 @@ class FractionNode {
         }
         const externalsNums = [];
         const externalsDenums = [];
+        let oppositesCount = 0;
         const recursiveNums = (node) => {
             if ((0, multiplyNode_1.isMultiplyNode)(node)) {
                 recursiveNums(node.leftChild);
                 recursiveNums(node.rightChild);
             }
+            else if ((0, oppositeNode_1.isOppositeNode)(node)) {
+                oppositesCount++;
+                recursiveNums(node.child);
+            }
             else {
                 externalsNums.push(node);
             }
@@ -100,19 +108,51 @@ class FractionNode {
                 recursiveDenums(node.leftChild);
                 recursiveDenums(node.rightChild);
             }
+            else if ((0, oppositeNode_1.isOppositeNode)(node)) {
+                oppositesCount++;
+                recursiveNums(node.child);
+            }
             else {
                 externalsDenums.push(node);
             }
         };
         recursiveNums(copy.leftChild);
         recursiveDenums(copy.rightChild);
+        if (oppositesCount % 2 === 1) {
+            externalsNums.unshift(new numberNode_1.NumberNode(-1));
+        }
         const simplifyExternalNodes = (num, denum) => {
             if ((0, numberNode_1.isNumberNode)(num) && (0, numberNode_1.isNumberNode)(denum)) {
+                // console.log("num nb, denum nb", num.toTex(), denum.toTex());
+                if (denum.value < 0) {
+                    if (num.value < 0) {
+                        return new FractionNode(new numberNode_1.NumberNode(-num.value), new numberNode_1.NumberNode(-denum.value));
+                    }
+                    return new oppositeNode_1.OppositeNode(new FractionNode(num, new numberNode_1.NumberNode(-denum.value)));
+                }
                 const frac = new rational_1.Rational(num.value, denum.value);
                 if (frac.isIrreductible())
                     return null;
                 return frac.simplify().toTree();
             }
+            if ((0, numberNode_1.isNumberNode)(num) &&
+                (isFractionNode(denum) ||
+                    ((0, oppositeNode_1.isOppositeNode)(denum) && isFractionNode(denum.child)))) {
+                const trueDenum = isFractionNode(denum)
+                    ? denum
+                    : denum.child;
+                return new multiplyNode_1.MultiplyNode(num, new FractionNode(trueDenum.rightChild, trueDenum.leftChild)).simplify();
+            }
+            if ((0, numberNode_1.isNumberNode)(denum) &&
+                (isFractionNode(num) ||
+                    ((0, oppositeNode_1.isOppositeNode)(num) && isFractionNode(num.child)))) {
+                // console.log("num frac, denum nb, ", num.toTex(), denum.toTex());
+                const trueNum = isFractionNode(num) ? num : num.child;
+                return new FractionNode(trueNum.leftChild, new multiplyNode_1.MultiplyNode(trueNum.rightChild, denum)).simplify();
+            }
+            if (isFractionNode(denum) && isFractionNode(num)) {
+                return new multiplyNode_1.MultiplyNode(num, new FractionNode(denum.rightChild, denum.leftChild)).simplify();
+            }
             //!ya mieux à faire pour gérer tous les cas d'un coup
             //! s'insiprer de multiply
             if (num.equals(denum))

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

@@ -7,6 +7,7 @@ export declare enum ClosureType {
     OF = 2,
     OO = 3
 }
+export declare const closureFromBrackets: (left: "[" | "]", right: "]" | "[") => ClosureType;
 export declare function isIntervalNode(a: Node): a is IntervalNode;
 export declare class IntervalNode implements SetNode {
     type: NodeType;

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":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGtD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AAEvD,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AACD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,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,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW;IAStE,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAoBpC,YAAY,CAAC,WAAW,CAAC,EAAE,IAAI;IA4B/B,YAAY;IAIZ,QAAQ;IAIR,KAAK;CAWN"}
+{"version":3,"file":"intervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/intervalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGtD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AAEvD,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AACD,eAAO,MAAM,mBAAmB,SAAU,GAAG,GAAG,GAAG,SAAS,GAAG,GAAG,GAAG,gBAMpE,CAAC;AACF,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,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,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW;IAStE,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAoBpC,YAAY,CAAC,WAAW,CAAC,EAAE,IAAI;IA4B/B,YAAY;IAIZ,QAAQ;IAIR,KAAK;CAWN"}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntervalNode = exports.isIntervalNode = exports.ClosureType = void 0;
+exports.IntervalNode = exports.isIntervalNode = exports.closureFromBrackets = exports.ClosureType = void 0;
 const cartesianProducts_1 = require("../../../utils/cartesianProducts");
 const inequationNode_1 = require("../inequations/inequationNode");
 const node_1 = require("../node");
@@ -14,6 +14,18 @@ var ClosureType;
     ClosureType[ClosureType["OF"] = 2] = "OF";
     ClosureType[ClosureType["OO"] = 3] = "OO";
 })(ClosureType || (exports.ClosureType = ClosureType = {}));
+const closureFromBrackets = (left, right) => {
+    if (left === "[")
+        if (right === "]")
+            return ClosureType.FF;
+        else
+            return ClosureType.FO;
+    else if (right === "[")
+        return ClosureType.OO;
+    else
+        return ClosureType.OF;
+};
+exports.closureFromBrackets = closureFromBrackets;
 function isIntervalNode(a) {
     return (0, setNode_1.isSetNode)(a) && a.id === setNode_1.SetIds.interval;
 }
@@ -71,7 +83,7 @@ class IntervalNode {
         const right = this.closure === ClosureType.FF || this.closure === ClosureType.OF
             ? "]"
             : "[";
-        return `${left}${this.a.toTex()};${this.b.toTex()}${right}`;
+        return `${left}\\ ${this.a.toTex()};${this.b.toTex()}\\ ${right}\\ `;
     }
 }
 exports.IntervalNode = IntervalNode;

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

@@ -0,0 +1 @@
+//# sourceMappingURL=majorSets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"majorSets.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/majorSets.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -1,3 +1,4 @@
+import { AlgebraicNode } from "../algebraicNode";
 import { Node, NodeOptions, NodeType } from "../node";
 import { SetIds, SetNode } from "./setNode";
 export declare enum ClosureType {
@@ -7,6 +8,9 @@ export declare enum ClosureType {
     OO = 3
 }
 export declare function isUnionIntervalNode(a: Node): a is UnionIntervalNode;
+export declare abstract class UnionIntervalNodeBuilder {
+    static realMinus(a: AlgebraicNode): UnionIntervalNode;
+}
 export declare class UnionIntervalNode implements Node {
     type: NodeType;
     id: SetIds;

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

@@ -1 +1 @@
-{"version":3,"file":"unionIntervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/unionIntervalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AAEvD,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AACD,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,iBAAiB,CAEnE;AACD,qBAAa,iBAAkB,YAAW,IAAI;IAC5C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,OAAO,EAAE,CAAC;gBACJ,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAO/C,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAcpC,YAAY;IAIZ,QAAQ;IAIR,KAAK;CAGN"}
+{"version":3,"file":"unionIntervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/unionIntervalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGtD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAa,MAAM,WAAW,CAAC;AAEvD,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AACD,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,iBAAiB,CAEnE;AACD,8BAAsB,wBAAwB;IAC5C,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,aAAa;CAMlC;AACD,qBAAa,iBAAkB,YAAW,IAAI;IAC5C,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,OAAO,EAAE,CAAC;gBACJ,IAAI,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAO/C,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAcpC,YAAY;IAIZ,QAAQ;IAIR,KAAK;CAGN"}

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

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnionIntervalNode = exports.isUnionIntervalNode = exports.ClosureType = void 0;
+exports.UnionIntervalNode = exports.UnionIntervalNodeBuilder = exports.isUnionIntervalNode = exports.ClosureType = void 0;
 const cartesianProducts_1 = require("../../../utils/cartesianProducts");
 const permutations_1 = require("../../../utils/permutations");
 const node_1 = require("../node");
+const infiniteNode_1 = require("../numbers/infiniteNode");
+const intervalNode_1 = require("./intervalNode");
 const setNode_1 = require("./setNode");
 var ClosureType;
 (function (ClosureType) {
@@ -16,6 +18,15 @@ function isUnionIntervalNode(a) {
     return (0, setNode_1.isSetNode)(a) && a.id === setNode_1.SetIds.union;
 }
 exports.isUnionIntervalNode = isUnionIntervalNode;
+class UnionIntervalNodeBuilder {
+    static realMinus(a) {
+        return new UnionIntervalNode([
+            new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, a, ClosureType.OO),
+            new intervalNode_1.IntervalNode(a, infiniteNode_1.MinusInfinityNode, ClosureType.OO),
+        ]);
+    }
+}
+exports.UnionIntervalNodeBuilder = UnionIntervalNodeBuilder;
 class UnionIntervalNode {
     constructor(sets, opts) {
         this.type = node_1.NodeType.set;
@@ -44,7 +55,7 @@ class UnionIntervalNode {
         return this.toTex();
     }
     toTex() {
-        return this.sets.map((set) => set.toTex()).join("\\cup");
+        return this.sets.map((set) => set.toTex()).join("\\ \\cup\\ ");
     }
 }
 exports.UnionIntervalNode = UnionIntervalNode;

package/lib/types/numberType.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=numberType.d.ts.map

package/lib/types/numberType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberType.d.ts","sourceRoot":"","sources":["../../src/types/numberType.ts"],"names":[],"mappings":""}

package/lib/types/numberType.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

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