math-exercises 1.0.1 → 1.1.0

package/src/sets/discreteSet.js

@@ -6,13 +6,13 @@ var DiscreteSet = /** @class */ (function () {
     function DiscreteSet(elements) {
         var _this = this;
         this.elements = Array.from(new Set(elements));
-        var tex = "{";
+        var tex = "\\{";
         this.elements.forEach(function (el, index) {
-            tex += el;
+            tex += el.tex;
             if (index < _this.elements.length - 1)
                 tex += ";";
             else
-                tex += "}";
+                tex += "\\}";
         });
         this.tex = tex;
     }
@@ -20,7 +20,7 @@ var DiscreteSet = /** @class */ (function () {
         return this.tex;
     };
     DiscreteSet.prototype.includes = function (el) {
-        return this.elements.includes(el);
+        return this.elements.some(function (nb) { return nb.value === el.value && nb.tex === el.tex; });
     };
     DiscreteSet.prototype.getRandomElement = function () {
         return (0, random_1.random)(this.elements);

package/src/sets/discreteSet.ts

@@ -1,16 +1,17 @@
+import { Nombre } from "../numbers/nombre";
 import { random } from "../utils/random";
 import { MathSetInterface } from "./mathSetInterface";
 
-export class DiscreteSet<T> implements MathSetInterface<T> {
-  elements: T[];
+export class DiscreteSet implements MathSetInterface {
+  elements: Nombre[];
   tex: string;
-  constructor(elements: T[]) {
+  constructor(elements: Nombre[]) {
     this.elements = Array.from(new Set(elements));
-    let tex = "{";
+    let tex = "\\{";
     this.elements.forEach((el, index) => {
-      tex += el;
+      tex += el.tex;
       if (index < this.elements.length - 1) tex += ";";
-      else tex += "}";
+      else tex += "\\}";
     });
     this.tex = tex;
   }
@@ -19,11 +20,11 @@ export class DiscreteSet<T> implements MathSetInterface<T> {
     return this.tex;
   }
 
-  includes(el: T): boolean {
-    return this.elements.includes(el);
+  includes(el: Nombre): boolean {
+    return this.elements.some((nb) => nb.value === el.value && nb.tex === el.tex);
   }
 
-  getRandomElement(): T {
+  getRandomElement(): Nombre {
     return random(this.elements);
   }
 }

package/src/sets/emptySet.ts

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

package/src/sets/intervals/intervals.js

@@ -2,9 +2,11 @@
 exports.__esModule = true;
 exports.Interval = void 0;
 var epsilon_1 = require("../../numbers/epsilon");
-var number_1 = require("../../numbers/number");
+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[";
@@ -20,10 +22,12 @@ var Interval = /** @class */ (function () {
         if (tex === void 0) { tex = "[-10; 10]"; }
         this.tex = tex;
         var isInt = tex[1] === "[" || tex[1] === "]";
-        this.type = isInt ? number_1.NumberType.Integer : number_1.NumberType.Real;
+        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];
+        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;
@@ -38,7 +42,6 @@ var Interval = /** @class */ (function () {
                 this.boundType = BoundType.OF;
                 break;
             default:
-                console.log("".concat(left, "a;b").concat(right));
                 throw console.error("wrong interval");
         }
         function getBound(bound) {
@@ -62,6 +65,17 @@ var Interval = /** @class */ (function () {
     //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 () {
@@ -74,15 +88,25 @@ var Interval = /** @class */ (function () {
         return new mathSet_1.MathSet(this.toTex() + "\\ ".concat(set.toTex()), rand);
     };
     Interval.prototype.toTex = function () {
-        return;
+        return this.tex;
     };
     Interval.prototype.getRandomElement = function (precision) {
-        if (precision === void 0) { precision = this.type === number_1.NumberType.Integer ? 0 : 2; }
+        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;
-        return (0, round_1.round)(min + Math.random() * (max - this.min), precision);
+        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;
 }());

package/src/sets/intervals/intervals.ts

@@ -1,9 +1,11 @@
 import { EPSILON } from "../../numbers/epsilon";
-import { NumberType } from "../../numbers/number";
+import { Nombre, NumberType } from "../../numbers/nombre";
 import { round } from "../../mathutils/round";
 import { MathSetInterface } from "../mathSetInterface";
 import { DiscreteSet } from "../discreteSet";
 import { MathSet } from "../mathSet";
+import { Integer } from "../../numbers/integer/integer";
+import { Real } from "../../numbers/reals/real";
 
 enum BoundType {
   OO = "]a;b[",
@@ -12,7 +14,7 @@ enum BoundType {
   FF = "[a;b]",
 }
 
-export class Interval implements MathSetInterface<Number> {
+export class Interval implements MathSetInterface {
   min: number;
   max: number;
   boundType: BoundType;
@@ -27,7 +29,9 @@ export class Interval implements MathSetInterface<Number> {
     this.type = isInt ? NumberType.Integer : 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(";");
+    const [a, b] = tex
+      .slice(isInt ? 2 : 1, isInt ? tex.length - 2 : tex.length - 1)
+      .split(";");
 
     switch (`${left}a;b${right}`) {
       case "[a;b]":
@@ -43,7 +47,6 @@ export class Interval implements MathSetInterface<Number> {
         this.boundType = BoundType.OF;
         break;
       default:
-        console.log(`${left}a;b${right}`);
         throw console.error("wrong interval");
     }
     function getBound(bound: string) {
@@ -68,8 +71,18 @@ export class Interval implements MathSetInterface<Number> {
   //res = a
   // return new MathSet();
   // }
+  exclude(nb: number) {
+    const rand = () => {
+      let x;
+      do {
+        x = this.getRandomElement();
+      } while (x.value === nb);
+      return x;
+    };
+    return new MathSet(this.toTex() + `\\{${nb}\\}`, rand);
+  }
 
-  difference(set: DiscreteSet<number>) {
+  difference(set: DiscreteSet): MathSet {
     const rand = () => {
       let x;
       do {
@@ -81,13 +94,29 @@ export class Interval implements MathSetInterface<Number> {
     return new MathSet(this.toTex() + `\\ ${set.toTex()}`, rand);
   }
 
-  toTex() {
-    return;
+  toTex(): string {
+    return this.tex;
   }
-  getRandomElement(precision: number = this.type === NumberType.Integer ? 0 : 2): number {
-    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 : this.min;
-    let max = this.boundType === BoundType.OO || this.boundType === BoundType.FO ? this.max - EPSILON : this.max;
-    return round(min + Math.random() * (max - this.min), precision);
+
+  getRandomElement(
+    precision: number = this.type === NumberType.Integer ? 0 : 2
+  ): Nombre {
+    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
+        : this.min;
+    let max =
+      this.boundType === BoundType.OO || this.boundType === BoundType.FO
+        ? this.max - EPSILON
+        : this.max;
+    const value = round(min + Math.random() * (max - this.min), precision);
+    switch (this.type) {
+      case NumberType.Integer:
+        return new Integer(value);
+      default:
+        return new Real(value, value.toString());
+    }
   }
 }

package/src/sets/mathSet.ts

@@ -1,9 +1,11 @@
+import { Nombre } from "../numbers/nombre";
+import { DiscreteSet } from "./discreteSet";
 import { MathSetInterface } from "./mathSetInterface";
 
-export class MathSet<T> implements MathSetInterface<T> {
+export class MathSet implements MathSetInterface {
   tex: string;
-  getRandomElement: () => T;
-  constructor(tex: string, getRandomElement: () => T) {
+  getRandomElement: () => Nombre;
+  constructor(tex: string, getRandomElement: () => Nombre) {
     this.tex = tex;
     this.getRandomElement = getRandomElement;
   }

package/src/sets/mathSetInterface.ts

@@ -1,6 +1,8 @@
-export interface MathSetInterface<T> {
+import { Nombre } from "../numbers/nombre";
+
+export interface MathSetInterface {
   tex: string;
-  getRandomElement: () => T;
+  getRandomElement: () => Nombre;
   //   constructor(tex: string, getRandomElement: () => number) {
   //     this.tex = tex;
   //     this.getRandomElement = getRandomElement;

package/src/tree/latexParser/latexParse.js

@@ -0,0 +1,76 @@
+"use strict";
+exports.__esModule = true;
+exports.latexParse = void 0;
+var node_1 = require("../nodes/node");
+function latexParse(node) {
+    if (!node) {
+        console.log("parsing a null node ???");
+        return "";
+    }
+    switch (node.type) {
+        case node_1.NodeType.variable:
+            return node.tex;
+        case node_1.NodeType.number:
+            return node.tex;
+        case node_1.NodeType.operator:
+            var rightTex = latexParse(node.rightChild);
+            var leftTex = latexParse(node.leftChild);
+            var leftChild = node.leftChild, rightChild = node.rightChild;
+            switch (node.id) {
+                case "add":
+                    return "".concat(leftTex, " ").concat(rightTex[0] === "-" ? "" : "+ ").concat(rightTex);
+                case "opposite":
+                    var needBrackets = leftChild.id === "add" ||
+                        leftChild.id === "substract" ||
+                        leftTex[0] === "-";
+                    if (needBrackets)
+                        leftTex = "(".concat(leftTex, ")");
+                    return "-".concat(leftTex);
+                case "substract": {
+                    var needBrackets_1 = rightChild.id === "add" ||
+                        rightChild.id === "substract" ||
+                        rightTex[0] === "-";
+                    if (needBrackets_1)
+                        rightTex = "(".concat(rightTex, ")");
+                    return "".concat(leftTex, " - ").concat(rightTex);
+                }
+                case "multiply": {
+                    if (leftChild.id === "add" || leftChild.id === "substract")
+                        leftTex = "(".concat(leftTex, ")");
+                    var needBrackets_2 = rightChild.id === "add" ||
+                        rightChild.id === "substract" ||
+                        rightTex[0] === "-";
+                    if (needBrackets_2)
+                        rightTex = "(".concat(rightTex, ")");
+                    var showTimesSign = !isNaN(+rightTex[0]); //permet de gérer le cas 3*2^x
+                    return "".concat(leftTex).concat(showTimesSign ? "\\times " : "").concat(rightTex);
+                }
+                case "divide": {
+                    return "\\frac{".concat(leftTex, "}{").concat(rightTex, "}");
+                }
+                case "power": {
+                    if (leftChild.id === "add" ||
+                        leftChild.id === "substract" ||
+                        leftChild.id === "multiply")
+                        leftTex = "(".concat(leftTex, ")");
+                    return "".concat(leftTex, "^{").concat(rightTex, "}");
+                }
+                case "equal": {
+                    return "".concat(leftTex, " = ").concat(rightTex);
+                }
+                default:
+                    return node.tex;
+            }
+        case node_1.NodeType["function"]: {
+            var leftTex_1 = latexParse(node.leftChild);
+            switch (node.id) {
+                case "sqrt": {
+                    return "\\sqrt{".concat(leftTex_1, "}");
+                }
+            }
+        }
+        default:
+            return "";
+    }
+}
+exports.latexParse = latexParse;

package/src/tree/latexParser/latexParse.ts

@@ -0,0 +1,82 @@
+import { Node, NodeType } from "../nodes/node";
+import { OperatorNode } from "../nodes/operators/operatorNode";
+
+export function latexParse(node: Node | null): string {
+  if (!node) {
+    console.log("parsing a null node ???");
+    return "";
+  }
+  switch (node.type) {
+    case NodeType.variable:
+      return node.tex;
+    case NodeType.number:
+      return node.tex;
+    case NodeType.operator:
+      let rightTex = latexParse(node.rightChild);
+      let leftTex = latexParse(node.leftChild);
+      const { leftChild, rightChild } = node;
+      switch (node.id) {
+        case "add":
+          return `${leftTex} ${rightTex[0] === "-" ? "" : "+ "}${rightTex}`;
+
+        case "opposite":
+          const needBrackets =
+            leftChild!.id === "add" ||
+            leftChild!.id === "substract" ||
+            leftTex[0] === "-";
+          if (needBrackets) leftTex = `(${leftTex})`;
+          return `-${leftTex}`;
+
+        case "substract": {
+          const needBrackets =
+            rightChild!.id === "add" ||
+            rightChild!.id === "substract" ||
+            rightTex[0] === "-";
+          if (needBrackets) rightTex = `(${rightTex})`;
+          return `${leftTex} - ${rightTex}`;
+        }
+
+        case "multiply": {
+          if (leftChild!.id === "add" || leftChild!.id === "substract")
+            leftTex = `(${leftTex})`;
+          const needBrackets =
+            rightChild!.id === "add" ||
+            rightChild!.id === "substract" ||
+            rightTex[0] === "-";
+          if (needBrackets) rightTex = `(${rightTex})`;
+          const showTimesSign = !isNaN(+rightTex[0]); //permet de gérer le cas 3*2^x
+          return `${leftTex}${showTimesSign ? "\\times " : ""}${rightTex}`;
+        }
+
+        case "divide": {
+          return `\\frac{${leftTex}}{${rightTex}}`;
+        }
+
+        case "power": {
+          if (
+            leftChild!.id === "add" ||
+            leftChild!.id === "substract" ||
+            leftChild!.id === "multiply"
+          )
+            leftTex = `(${leftTex})`;
+          return `${leftTex}^{${rightTex}}`;
+        }
+
+        case "equal": {
+          return `${leftTex} = ${rightTex}`;
+        }
+        default:
+          return node.tex;
+      }
+    case NodeType.function: {
+      let leftTex = latexParse(node.leftChild);
+      switch (node.id) {
+        case "sqrt": {
+          return `\\sqrt{${leftTex}}`;
+        }
+      }
+    }
+    default:
+      return "";
+  }
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+exports.__esModule = true;
+exports.SqrtNode = void 0;
+var node_1 = require("../node");
+var SqrtNode = /** @class */ (function () {
+    function SqrtNode(leftChild) {
+        this.type = node_1.NodeType["function"];
+        this.id = "sqrt";
+        this.tex = "\\sqrt";
+        this.leftChild = leftChild;
+        this.rightChild = null;
+    }
+    SqrtNode.prototype.toString = function () {
+        return "sqrt(".concat(this.leftChild, ")");
+    };
+    return SqrtNode;
+}());
+exports.SqrtNode = SqrtNode;

package/src/tree/nodes/functions/sqrtNode.ts

@@ -0,0 +1,16 @@
+import { Node, NodeType } from "../node";
+
+export class SqrtNode implements Node {
+  leftChild: Node;
+  rightChild: null;
+  type: NodeType = NodeType.function;
+  id: string = "sqrt";
+  tex = "\\sqrt";
+  constructor(leftChild: Node) {
+    this.leftChild = leftChild;
+    this.rightChild = null;
+  }
+  toString(): string {
+    return `sqrt(${this.leftChild})`;
+  }
+}

package/src/tree/nodes/node.js

@@ -0,0 +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 = {}));

package/src/tree/nodes/node.ts

@@ -0,0 +1,14 @@
+export enum NodeType {
+  number,
+  variable,
+  operator,
+  function,
+}
+
+export interface Node {
+  type: NodeType;
+  tex: string;
+  id: string;
+  leftChild: Node | null;
+  rightChild: Node | null;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+exports.__esModule = true;
+exports.NumberNode = void 0;
+var node_1 = require("../node");
+var NumberNode = /** @class */ (function () {
+    function NumberNode(value) {
+        this.id = "number";
+        this.leftChild = null;
+        this.rightChild = null;
+        this.value = value;
+        this.tex = value + "";
+        this.type = node_1.NodeType.number;
+    }
+    NumberNode.prototype.toString = function () {
+        return "".concat(this.tex);
+    };
+    return NumberNode;
+}());
+exports.NumberNode = NumberNode;

package/src/tree/nodes/numbers/numberNode.ts

@@ -0,0 +1,19 @@
+import { Node, NodeType } from "../node";
+
+export class NumberNode implements Node {
+  tex: string;
+  value: number;
+  type: NodeType;
+  id = "number";
+  leftChild = null;
+  rightChild = null;
+  constructor(value: number) {
+    this.value = value;
+    this.tex = value + "";
+    this.type = NodeType.number;
+  }
+
+  toString(): string {
+    return `${this.tex}`;
+  }
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+exports.__esModule = true;
+exports.AddNode = void 0;
+var node_1 = require("../node");
+var AddNode = /** @class */ (function () {
+    function AddNode(leftChild, rightChild) {
+        this.type = node_1.NodeType.operator;
+        this.id = "add";
+        this.tex = "+";
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+    }
+    AddNode.prototype.toString = function () {
+        return "".concat(this.leftChild, " + ").concat(this.rightChild);
+    };
+    return AddNode;
+}());
+exports.AddNode = AddNode;

package/src/tree/nodes/operators/addNode.ts

@@ -0,0 +1,17 @@
+import { Node, NodeType } from "../node";
+import { OperatorNode } from "./operatorNode";
+
+export class AddNode implements Node, OperatorNode {
+  leftChild: Node;
+  rightChild: Node;
+  type: NodeType = NodeType.operator;
+  id: string = "add";
+  tex = "+";
+  constructor(leftChild: Node, rightChild: Node) {
+    this.leftChild = leftChild;
+    this.rightChild = rightChild;
+  }
+  toString(): string {
+    return `${this.leftChild} + ${this.rightChild}`;
+  }
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+exports.__esModule = true;
+exports.DivideNode = void 0;
+var node_1 = require("../node");
+var DivideNode = /** @class */ (function () {
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    function DivideNode(leftChild, rightChild) {
+        this.type = node_1.NodeType.operator;
+        this.id = "divide";
+        this.tex = "\\frac";
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+    }
+    DivideNode.prototype.toString = function () {
+        return "\\frac{".concat(this.leftChild, "}{").concat(this.rightChild, "}");
+    };
+    return DivideNode;
+}());
+exports.DivideNode = DivideNode;

package/src/tree/nodes/operators/divideNode.ts

@@ -0,0 +1,23 @@
+import { Node, NodeType } from "../node";
+import { OperatorNode } from "./operatorNode";
+
+export class DivideNode implements Node, OperatorNode {
+  leftChild: Node;
+  rightChild: Node;
+  type: NodeType = NodeType.operator;
+  id: string = "divide";
+  tex = "\\frac";
+
+  /**
+   * @param leftChild num
+   * @param rightChild denum
+   */
+  constructor(leftChild: Node, rightChild: Node) {
+    this.leftChild = leftChild;
+    this.rightChild = rightChild;
+  }
+
+  toString(): string {
+    return `\\frac{${this.leftChild}}{${this.rightChild}}`;
+  }
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+exports.__esModule = true;
+exports.EqualNode = void 0;
+var node_1 = require("../node");
+var EqualNode = /** @class */ (function () {
+    function EqualNode(leftChild, rightChild) {
+        this.type = node_1.NodeType.operator;
+        this.id = "equal";
+        this.tex = "=";
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+    }
+    EqualNode.prototype.toString = function () {
+        return "".concat(this.leftChild, " = ").concat(this.rightChild);
+    };
+    return EqualNode;
+}());
+exports.EqualNode = EqualNode;