math-exercises 1.2.8 → 1.2.10

package/lib/sets/discreteSet.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscreteSet = void 0;
+const random_1 = require("../utils/random");
+class DiscreteSet {
+    constructor(elements) {
+        this.elements = Array.from(new Set(elements));
+        let tex = "\\{";
+        this.elements.forEach((el, index) => {
+            tex += el.tex;
+            if (index < this.elements.length - 1)
+                tex += ";";
+            else
+                tex += "\\}";
+        });
+        this.tex = tex;
+    }
+    toTex() {
+        return this.tex;
+    }
+    includes(el) {
+        return this.elements.some((nb) => nb.value === el.value && nb.tex === el.tex);
+    }
+    getRandomElement() {
+        return (0, random_1.random)(this.elements);
+    }
+}
+exports.DiscreteSet = DiscreteSet;

package/{src/sets/emptySet.ts → lib/sets/emptySet.js}

@@ -1,6 +1,6 @@
-// import { MathSetInterface } from "./mathSetInterface";
-
-// export abstract class EmptySet implements MathSetInterface {
-//   tex: string = "\\emptyset";
-//   getRandomElement = () => null;
-// }
+"use strict";
+// import { MathSetInterface } from "./mathSetInterface";
+// export abstract class EmptySet implements MathSetInterface {
+//   tex: string = "\\emptyset";
+//   getRandomElement = () => null;
+// }

package/{src → lib}/sets/intervals/intervals.js

@@ -1,113 +1,108 @@
-"use strict";
-exports.__esModule = true;
-exports.Interval = void 0;
-var epsilon_1 = require("../../numbers/epsilon");
-var nombre_1 = require("../../numbers/nombre");
-var round_1 = require("../../mathutils/round");
-var mathSet_1 = require("../mathSet");
-var integer_1 = require("../../numbers/integer/integer");
-var real_1 = require("../../numbers/reals/real");
-var BoundType;
-(function (BoundType) {
-    BoundType["OO"] = "]a;b[";
-    BoundType["OF"] = "]a;b]";
-    BoundType["FO"] = "[a;b[";
-    BoundType["FF"] = "[a;b]";
-})(BoundType || (BoundType = {}));
-var Interval = /** @class */ (function () {
-    /**
-     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
-     */
-    function Interval(tex) {
-        if (tex === void 0) { tex = "[-10; 10]"; }
-        this.tex = tex;
-        var isInt = tex[1] === "[" || tex[1] === "]";
-        this.type = isInt ? nombre_1.NumberType.Integer : nombre_1.NumberType.Real;
-        var left = tex[0];
-        var right = tex[tex.length - 1];
-        var _a = tex
-            .slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1)
-            .split(";"), a = _a[0], b = _a[1];
-        switch ("".concat(left, "a;b").concat(right)) {
-            case "[a;b]":
-                this.boundType = BoundType.FF;
-                break;
-            case "]a;b[":
-                this.boundType = BoundType.OO;
-                break;
-            case "[a;b[":
-                this.boundType = BoundType.FO;
-                break;
-            case "]a;b]":
-                this.boundType = BoundType.OF;
-                break;
-            default:
-                throw console.error("wrong interval");
-        }
-        function getBound(bound) {
-            return bound === "-\\infty"
-                ? Number.NEGATIVE_INFINITY
-                : bound === "+\\infty"
-                    ? Number.POSITIVE_INFINITY
-                    : Number(bound);
-        }
-        this.min = getBound(a);
-        this.max = getBound(b);
-    }
-    // union(interval: Interval): MathSet {
-    //[a,b] [c,d]
-    //si a=c return a, max(b,d)
-    //si si b = d return min(a,c), b
-    //si a=d return c,b sauf si  OXXO
-    //si b=c return a,d sauf si XOOX
-    //si c > b ou d < a alors union disjointe avec plus petit en 1er
-    //sinon return min(a,c), max(b,d)
-    //res = a
-    // return new MathSet();
-    // }
-    Interval.prototype.exclude = function (nb) {
-        var _this = this;
-        var rand = function () {
-            var x;
-            do {
-                x = _this.getRandomElement();
-            } while (x.value === nb);
-            return x;
-        };
-        return new mathSet_1.MathSet(this.toTex() + "\\{".concat(nb, "\\}"), rand);
-    };
-    Interval.prototype.difference = function (set) {
-        var _this = this;
-        var rand = function () {
-            var x;
-            do {
-                x = _this.getRandomElement();
-            } while (set.includes(x));
-            return x;
-        };
-        return new mathSet_1.MathSet(this.toTex() + "\\ ".concat(set.toTex()), rand);
-    };
-    Interval.prototype.toTex = function () {
-        return this.tex;
-    };
-    Interval.prototype.getRandomElement = function (precision) {
-        if (precision === void 0) { precision = this.type === nombre_1.NumberType.Integer ? 0 : 2; }
-        if (this.min === -Infinity || this.max === Infinity)
-            throw Error("Can't chose amongst infinity");
-        var min = this.boundType === BoundType.OO || this.boundType === BoundType.OF
-            ? this.min + epsilon_1.EPSILON
-            : this.min;
-        var max = this.boundType === BoundType.OO || this.boundType === BoundType.FO
-            ? this.max - epsilon_1.EPSILON
-            : this.max;
-        var 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());
-        }
-    };
-    return Interval;
-}());
-exports.Interval = Interval;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interval = void 0;
+const epsilon_1 = require("../../numbers/epsilon");
+const nombre_1 = require("../../numbers/nombre");
+const round_1 = require("../../mathutils/round");
+const mathSet_1 = require("../mathSet");
+const integer_1 = require("../../numbers/integer/integer");
+const real_1 = require("../../numbers/reals/real");
+var BoundType;
+(function (BoundType) {
+    BoundType["OO"] = "]a;b[";
+    BoundType["OF"] = "]a;b]";
+    BoundType["FO"] = "[a;b[";
+    BoundType["FF"] = "[a;b]";
+})(BoundType || (BoundType = {}));
+class Interval {
+    /**
+     * [[a; b]] pour un interval d'integer;  [a;b] pour des réels
+     */
+    constructor(tex = "[-10; 10]") {
+        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(";");
+        switch (`${left}a;b${right}`) {
+            case "[a;b]":
+                this.boundType = BoundType.FF;
+                break;
+            case "]a;b[":
+                this.boundType = BoundType.OO;
+                break;
+            case "[a;b[":
+                this.boundType = BoundType.FO;
+                break;
+            case "]a;b]":
+                this.boundType = BoundType.OF;
+                break;
+            default:
+                throw console.error("wrong interval");
+        }
+        function getBound(bound) {
+            return bound === "-\\infty"
+                ? Number.NEGATIVE_INFINITY
+                : bound === "+\\infty"
+                    ? Number.POSITIVE_INFINITY
+                    : Number(bound);
+        }
+        this.min = getBound(a);
+        this.max = getBound(b);
+    }
+    // union(interval: Interval): MathSet {
+    //[a,b] [c,d]
+    //si a=c return a, max(b,d)
+    //si si b = d return min(a,c), b
+    //si a=d return c,b sauf si  OXXO
+    //si b=c return a,d sauf si XOOX
+    //si c > b ou d < a alors union disjointe avec plus petit en 1er
+    //sinon return min(a,c), max(b,d)
+    //res = a
+    // return new MathSet();
+    // }
+    exclude(nb) {
+        const rand = () => {
+            let x;
+            do {
+                x = this.getRandomElement();
+            } while (x.value === nb);
+            return x;
+        };
+        return new mathSet_1.MathSet(this.toTex() + `\\{${nb}\\}`, 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);
+    }
+    toTex() {
+        return this.tex;
+    }
+    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.boundType === BoundType.OO || this.boundType === BoundType.OF
+            ? this.min + epsilon_1.EPSILON
+            : this.min;
+        let max = this.boundType === BoundType.OO || this.boundType === BoundType.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());
+        }
+    }
+}
+exports.Interval = Interval;

package/lib/sets/intervals/union.js

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

package/lib/sets/mathSet.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathSet = void 0;
+class MathSet {
+    constructor(tex, getRandomElement) {
+        this.tex = tex;
+        this.getRandomElement = getRandomElement;
+    }
+}
+exports.MathSet = MathSet;

package/lib/sets/mathSetInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{src → lib}/tree/nodes/functions/functionNode.js

@@ -1,19 +1,18 @@
-"use strict";
-exports.__esModule = true;
-exports.FunctionNode = exports.FunctionsIds = void 0;
-var node_1 = require("../node");
-var FunctionsIds;
-(function (FunctionsIds) {
-    FunctionsIds[FunctionsIds["opposite"] = 0] = "opposite";
-    FunctionsIds[FunctionsIds["sqrt"] = 1] = "sqrt";
-})(FunctionsIds = exports.FunctionsIds || (exports.FunctionsIds = {}));
-var FunctionNode = /** @class */ (function () {
-    function FunctionNode(id, child, tex) {
-        this.type = node_1.NodeType["function"];
-        this.id = id;
-        this.child = child;
-        this.tex = tex;
-    }
-    return FunctionNode;
-}());
-exports.FunctionNode = FunctionNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionNode = exports.FunctionsIds = void 0;
+const node_1 = require("../node");
+var FunctionsIds;
+(function (FunctionsIds) {
+    FunctionsIds[FunctionsIds["opposite"] = 0] = "opposite";
+    FunctionsIds[FunctionsIds["sqrt"] = 1] = "sqrt";
+})(FunctionsIds = exports.FunctionsIds || (exports.FunctionsIds = {}));
+class FunctionNode {
+    constructor(id, child, tex) {
+        this.type = node_1.NodeType.function;
+        this.id = id;
+        this.child = child;
+        this.tex = tex;
+    }
+}
+exports.FunctionNode = FunctionNode;

package/lib/tree/nodes/functions/oppositeNode.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OppositeNode = void 0;
+const functionNode_1 = require("./functionNode");
+class OppositeNode extends functionNode_1.FunctionNode {
+    constructor(child) {
+        super(functionNode_1.FunctionsIds.opposite, child, "-");
+    }
+    toString() {
+        return `-(${this.child})`;
+    }
+}
+exports.OppositeNode = OppositeNode;

package/lib/tree/nodes/functions/sqrtNode.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqrtNode = void 0;
+const node_1 = require("../node");
+const functionNode_1 = require("./functionNode");
+class SqrtNode extends functionNode_1.FunctionNode {
+    constructor(child) {
+        super(functionNode_1.FunctionsIds.sqrt, child, "\\sqrt");
+        this.type = node_1.NodeType.function;
+    }
+    toString() {
+        return `sqrt(${this.child})`;
+    }
+}
+exports.SqrtNode = SqrtNode;

package/{src → lib}/tree/nodes/node.js

@@ -1,10 +1,10 @@
-"use strict";
-exports.__esModule = true;
-exports.NodeType = void 0;
-var NodeType;
-(function (NodeType) {
-    NodeType[NodeType["number"] = 0] = "number";
-    NodeType[NodeType["variable"] = 1] = "variable";
-    NodeType[NodeType["operator"] = 2] = "operator";
-    NodeType[NodeType["function"] = 3] = "function";
-})(NodeType = exports.NodeType || (exports.NodeType = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeType = void 0;
+var NodeType;
+(function (NodeType) {
+    NodeType[NodeType["number"] = 0] = "number";
+    NodeType[NodeType["variable"] = 1] = "variable";
+    NodeType[NodeType["operator"] = 2] = "operator";
+    NodeType[NodeType["function"] = 3] = "function";
+})(NodeType = exports.NodeType || (exports.NodeType = {}));

package/lib/tree/nodes/numbers/numberNode.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberNode = void 0;
+const node_1 = require("../node");
+class NumberNode {
+    constructor(value, tex) {
+        this.type = node_1.NodeType.number;
+        this.value = value;
+        this.tex = tex || value + '';
+    }
+    toString() {
+        return `${this.tex}`;
+    }
+    toTex() {
+        return `${this.tex}`;
+    }
+}
+exports.NumberNode = NumberNode;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddNode = void 0;
+const operatorNode_1 = require("./operatorNode");
+class AddNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.add, leftChild, rightChild, true, "+");
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+    }
+    toString() {
+        return `${this.leftChild} + ${this.rightChild}`;
+    }
+}
+exports.AddNode = AddNode;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DivideNode = void 0;
+const operatorNode_1 = require("./operatorNode");
+class DivideNode extends operatorNode_1.OperatorNode {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.divide, leftChild, rightChild, false, "\\div");
+    }
+    toString() {
+        return `(${this.leftChild}) \\div (${this.rightChild})`;
+    }
+}
+exports.DivideNode = DivideNode;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EqualNode = void 0;
+const operatorNode_1 = require("./operatorNode");
+class EqualNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.equal, leftChild, rightChild, true, "=");
+    }
+    toString() {
+        return `${this.leftChild} = ${this.rightChild}`;
+    }
+}
+exports.EqualNode = EqualNode;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FractionNode = void 0;
+const operatorNode_1 = require("./operatorNode");
+class FractionNode extends operatorNode_1.OperatorNode {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.fraction, leftChild, rightChild, false, "\\frac");
+    }
+    toString() {
+        return `\\frac{${this.leftChild}}{${this.rightChild}}`;
+    }
+}
+exports.FractionNode = FractionNode;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiplyNode = void 0;
+const operatorNode_1 = require("./operatorNode");
+class MultiplyNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.multiply, leftChild, rightChild, true, "\\times");
+    }
+    toString() {
+        return `(${this.leftChild})*(${this.rightChild})`;
+    }
+}
+exports.MultiplyNode = MultiplyNode;

package/{src → lib}/tree/nodes/operators/operatorNode.js

@@ -1,37 +1,35 @@
-"use strict";
-exports.__esModule = true;
-exports.OperatorNode = exports.OperatorIds = void 0;
-var coin_1 = require("../../../utils/coin");
-var node_1 = require("../node");
-var OperatorIds;
-(function (OperatorIds) {
-    OperatorIds[OperatorIds["add"] = 0] = "add";
-    OperatorIds[OperatorIds["substract"] = 1] = "substract";
-    OperatorIds[OperatorIds["multiply"] = 2] = "multiply";
-    OperatorIds[OperatorIds["fraction"] = 3] = "fraction";
-    OperatorIds[OperatorIds["divide"] = 4] = "divide";
-    OperatorIds[OperatorIds["power"] = 5] = "power";
-    OperatorIds[OperatorIds["equal"] = 6] = "equal";
-})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
-var OperatorNode = /** @class */ (function () {
-    function OperatorNode(id, leftChild, rightChild, isCommutative, tex) {
-        this.type = node_1.NodeType.operator;
-        this.id = id;
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-        this.isCommutative = isCommutative;
-        this.tex = tex;
-    }
-    /**shuffles in place */
-    OperatorNode.prototype.shuffle = function () {
-        var _a;
-        if (!this.isCommutative)
-            return this;
-        if ((0, coin_1.coin)())
-            return this;
-        _a = [this.rightChild, this.leftChild], this.leftChild = _a[0], this.rightChild = _a[1];
-        return this;
-    };
-    return OperatorNode;
-}());
-exports.OperatorNode = OperatorNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorNode = exports.OperatorIds = void 0;
+const coin_1 = require("../../../utils/coin");
+const node_1 = require("../node");
+var OperatorIds;
+(function (OperatorIds) {
+    OperatorIds[OperatorIds["add"] = 0] = "add";
+    OperatorIds[OperatorIds["substract"] = 1] = "substract";
+    OperatorIds[OperatorIds["multiply"] = 2] = "multiply";
+    OperatorIds[OperatorIds["fraction"] = 3] = "fraction";
+    OperatorIds[OperatorIds["divide"] = 4] = "divide";
+    OperatorIds[OperatorIds["power"] = 5] = "power";
+    OperatorIds[OperatorIds["equal"] = 6] = "equal";
+})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
+class OperatorNode {
+    constructor(id, leftChild, rightChild, isCommutative, tex) {
+        this.type = node_1.NodeType.operator;
+        this.id = id;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.isCommutative = isCommutative;
+        this.tex = tex;
+    }
+    /**shuffles in place */
+    shuffle() {
+        if (!this.isCommutative)
+            return this;
+        if ((0, coin_1.coin)())
+            return this;
+        [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+        return this;
+    }
+}
+exports.OperatorNode = OperatorNode;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerNode = void 0;
+const operatorNode_1 = require("./operatorNode");
+class PowerNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.power, leftChild, rightChild, false, "^");
+    }
+    toString() {
+        return `(${this.leftChild})^{${this.rightChild}}`;
+    }
+}
+exports.PowerNode = PowerNode;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstractNode = void 0;
+const operatorNode_1 = require("./operatorNode");
+class SubstractNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, "-");
+    }
+    toString() {
+        return `${this.leftChild}-(${this.rightChild})`;
+    }
+}
+exports.SubstractNode = SubstractNode;

package/lib/tree/nodes/variables/variableNode.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableNode = void 0;
+const node_1 = require("../node");
+class VariableNode {
+    constructor(tex) {
+        this.type = node_1.NodeType.variable;
+        if (tex.length !== 1 || !tex.match("[a-zA-Z]"))
+            throw Error("variable must be a letter");
+        this.tex = tex;
+    }
+    toString() {
+        return `${this.tex}`;
+    }
+}
+exports.VariableNode = VariableNode;