math-exercises 1.1.0 → 1.2.0

package/src/numbers/decimals/decimal.ts

@@ -0,0 +1,140 @@
+import { randint } from "../../mathutils/random/randint";
+import { Node } from "../../tree/nodes/node";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+import { Integer } from "../integer/integer";
+import { Nombre, NumberType } from "../nombre";
+
+export abstract class DecimalConstructor {
+  static randomFracPart(precision: number): string {
+    let decimals = "";
+    for (let i = 0; i < precision; i++) {
+      decimals += randint(i === precision - 1 ? 1 : 0, 10);
+    }
+    return decimals;
+  }
+
+  static random(min: number, max: number, precision: number): Decimal {
+    const int = randint(min, max) + "";
+    const decimals = DecimalConstructor.randomFracPart(precision);
+    return DecimalConstructor.fromParts(int, decimals);
+  }
+  static fromParts(intPart: string, decimalPart: string): Decimal {
+    return new Decimal(Number("" + intPart + "." + decimalPart));
+  }
+}
+
+export class Decimal implements Nombre {
+  value: number;
+  tex: string;
+  type = NumberType.Decimal;
+  precision: number;
+  intPart: number;
+  decimalPart: string;
+  constructor(value: number) {
+    this.value = value;
+    this.tex = value + "";
+    let [intPartString, decimalPartString] = (value + "").split(".");
+    this.intPart = Number(intPartString);
+    this.decimalPart = decimalPartString || "";
+    this.precision = this.decimalPart.length;
+  }
+
+  /**
+   *
+   * @param precision 0 = unité, 1 = dizieme, ... , -1 : dizaine
+   * @returns
+   */
+  round(precision: number): Nombre {
+    const intPartString = this.intPart + "";
+
+    if (precision < 0) {
+      if (precision < -intPartString.length) throw Error("can't round to higher precision");
+      return new Integer(this.intPart).round(-precision);
+    }
+
+    if (precision > this.precision) throw Error("can't round to higher precision");
+    if (precision === this.precision) return this;
+
+    let newFracPart = "",
+      newIntPart = "";
+
+    const shouldRoundUp = Number(this.decimalPart[precision]) > 4;
+
+    if (shouldRoundUp) {
+      let retenue = true;
+      let i = precision - 1;
+      while (retenue) {
+        if (i > -1) {
+          const nb = (Number(this.decimalPart[i]) + 1) % 10;
+          if (nb || newFracPart) {
+            newFracPart = nb.toString() + newFracPart;
+          }
+          if (nb !== 0) {
+            retenue = false;
+            for (let j = i - 1; j > -1; j--) {
+              newFracPart = this.decimalPart[j] + newFracPart;
+            }
+            newIntPart = intPartString;
+          } else i--;
+        } else {
+          const nb = (Number(intPartString[i + intPartString.length]) + 1) % 10;
+          newIntPart = nb + "" + newIntPart;
+          if (nb !== 0) {
+            retenue = false;
+            for (let j = i + intPartString.length - 1; j > -1; j--) {
+              newIntPart = intPartString[j] + newIntPart;
+            }
+          } else i--;
+        }
+      }
+    } else {
+      let retenue = true;
+      let i = precision - 1;
+      while (retenue) {
+        if (i > -1) {
+          const nb = Number(this.decimalPart[i]);
+          if (nb || newFracPart) {
+            newFracPart = nb.toString() + newFracPart;
+          }
+          if (nb !== 0) {
+            retenue = false;
+            for (let j = i - 1; j > -1; j--) {
+              newFracPart = this.decimalPart[j] + newFracPart;
+            }
+            newIntPart = intPartString;
+          } else i--;
+        } else {
+          newIntPart = intPartString;
+          retenue = false;
+        }
+      }
+    }
+    return DecimalConstructor.fromParts(newIntPart, newFracPart);
+  }
+
+  multiplyByPowerOfTen(power: number) {
+    let newIntPart = "",
+      newFracPart = "";
+
+    if (power > -1) {
+      newIntPart = this.intPart + "";
+      for (let i = 0; i < power; i++) {
+        newIntPart += i > this.decimalPart.length - 1 ? "0" : this.decimalPart[i];
+      }
+      newFracPart = this.decimalPart.slice(power);
+    } else {
+      const intPartString = this.intPart + "";
+      newFracPart = this.decimalPart;
+      for (let i = intPartString.length - 1; i > intPartString.length - 1 + power; i--) {
+        newFracPart = (i < 0 ? "0" : intPartString[i]) + newFracPart;
+      }
+      if (power + intPartString.length < 1) newIntPart = "0";
+      else newIntPart = intPartString.slice(0, power + intPartString.length);
+    }
+    return DecimalConstructor.fromParts(newIntPart, newFracPart);
+  }
+
+  toTree(): Node {
+    return new NumberNode(this.value);
+  }
+}

package/src/numbers/integer/integer.js

@@ -1,14 +1,71 @@
 "use strict";
 exports.__esModule = true;
-exports.Integer = void 0;
+exports.Integer = exports.IntegerConstructor = void 0;
+var randint_1 = require("../../mathutils/random/randint");
 var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var nombre_1 = require("../nombre");
+var rational_1 = require("../rationals/rational");
+var IntegerConstructor = /** @class */ (function () {
+    function IntegerConstructor() {
+    }
+    IntegerConstructor.random = function (nbOfDigits) {
+        return (0, randint_1.randint)(0, Math.pow(10, nbOfDigits));
+    };
+    return IntegerConstructor;
+}());
+exports.IntegerConstructor = IntegerConstructor;
 var Integer = /** @class */ (function () {
-    function Integer(value) {
+    function Integer(value, tex) {
         this.value = value;
-        this.tex = value + "";
+        this.tex = tex || value + "";
+        this.type = nombre_1.NumberType.Integer;
     }
     Integer.prototype.toTree = function () {
-        return new numberNode_1.NumberNode(this.value);
+        return new numberNode_1.NumberNode(this.value, this.tex);
+    };
+    Integer.prototype.round = function (precision) {
+        var intString = this.value + "";
+        if (precision >= intString.length || precision < 1)
+            throw Error("can't round to higher precision");
+        var newInt = "";
+        var shouldRoundUp = Number(intString[intString.length - precision]) > 4;
+        if (shouldRoundUp) {
+            for (var i_1 = 0; i_1 < precision; i_1++) {
+                newInt += "0";
+            }
+            var retenue = true;
+            var i = intString.length - precision - 1;
+            while (retenue) {
+                var nb = (Number(intString[i]) + 1) % 10;
+                newInt = "" + nb + newInt;
+                if (nb === 0) {
+                    i--;
+                }
+                else {
+                    retenue = false;
+                    for (var j = i - 1; j > -1; j--) {
+                        newInt = intString[j] + newInt;
+                    }
+                }
+            }
+        }
+        else {
+            for (var i = 0; i < intString.length; i++) {
+                newInt += i < intString.length - precision ? intString[i] : "0";
+            }
+        }
+        return new Integer(Number(newInt));
+    };
+    Integer.prototype.divide = function (nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer:
+                return new rational_1.Rational(this.value, nb.value).simplify();
+            case nombre_1.NumberType.Rational:
+                var rational = nb;
+                return new rational_1.Rational(this.value * rational.denum, rational.num).simplify();
+            default:
+                throw Error("not implemented");
+        }
     };
     return Integer;
 }());

package/src/numbers/integer/integer.ts

@@ -1,21 +1,72 @@
-import { Expression } from "../../expression/expression";
+import { randint } from "../../mathutils/random/randint";
 import { Node } from "../../tree/nodes/node";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode";
-import { Nombre } from "../nombre";
+import { Nombre, NumberType } from "../nombre";
+import { Rational } from "../rationals/rational";
+
+export abstract class IntegerConstructor {
+  static random(nbOfDigits: number) {
+    return randint(0, 10 ** nbOfDigits);
+  }
+}
 
 export class Integer implements Nombre {
   value: number;
   tex: string;
+  type: NumberType;
 
-  constructor(value: number) {
+  constructor(value: number, tex?: string) {
     this.value = value;
-    this.tex = value + "";
+    this.tex = tex || value + "";
+    this.type = NumberType.Integer;
   }
 
   toTree(): Node {
-    return new NumberNode(this.value);
+    return new NumberNode(this.value, this.tex);
   }
-  // add(expression: Expression): Expression {
 
-  // }
+  round(precision: number) {
+    const intString = this.value + "";
+
+    if (precision >= intString.length || precision < 1) throw Error("can't round to higher precision");
+
+    let newInt = "";
+    const shouldRoundUp = Number(intString[intString.length - precision]) > 4;
+    if (shouldRoundUp) {
+      for (let i = 0; i < precision; i++) {
+        newInt += "0";
+      }
+      let retenue = true;
+      let i = intString.length - precision - 1;
+
+      while (retenue) {
+        const nb = (Number(intString[i]) + 1) % 10;
+        newInt = "" + nb + newInt;
+        if (nb === 0) {
+          i--;
+        } else {
+          retenue = false;
+          for (let j = i - 1; j > -1; j--) {
+            newInt = intString[j] + newInt;
+          }
+        }
+      }
+    } else {
+      for (let i = 0; i < intString.length; i++) {
+        newInt += i < intString.length - precision ? intString[i] : "0";
+      }
+    }
+    return new Integer(Number(newInt));
+  }
+  divide(nb: Nombre): Nombre {
+    switch (nb.type) {
+      case NumberType.Integer:
+        return new Rational(this.value, nb.value).simplify();
+      case NumberType.Rational:
+        const rational = nb as Rational;
+        return new Rational(this.value * rational.denum, rational.num).simplify();
+      default:
+        throw Error("not implemented");
+    }
+  }
 }

package/src/numbers/integer/power.js

@@ -0,0 +1,53 @@
+"use strict";
+exports.__esModule = true;
+exports.Power = void 0;
+var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var powerNode_1 = require("../../tree/nodes/operators/powerNode");
+var nombre_1 = require("../nombre");
+var integer_1 = require("./integer");
+var Power = /** @class */ (function () {
+    function Power(a, b) {
+        this.operand = a;
+        this.power = b;
+        this.value = Math.pow(a, b);
+        this.tex = "".concat(a, "^{").concat(b, "}");
+        this.type = b < 0 ? nombre_1.NumberType.Rational : nombre_1.NumberType.Integer;
+    }
+    Power.prototype.simplify = function () {
+        if (this.power === 0)
+            return new numberNode_1.NumberNode(1);
+        if (this.power === 1)
+            return new numberNode_1.NumberNode(this.operand);
+        if (this.operand === 1)
+            return new numberNode_1.NumberNode(1);
+        if (this.operand === 0)
+            return new numberNode_1.NumberNode(0);
+        if (this.operand === -1)
+            return new numberNode_1.NumberNode(this.power % 2 === 0 ? 1 : -1);
+        return this.toTree();
+    };
+    Power.prototype.toDecimalWriting = function () {
+        if (this.operand !== 10)
+            throw Error("only implemented for powers of ten so far");
+        var s = "";
+        if (this.power > -1) {
+            s += "1";
+            for (var i = 0; i < this.power; i++) {
+                s += 0;
+            }
+        }
+        else {
+            s += "1";
+            for (var i = 1; i < Math.abs(this.power); i++) {
+                s = "0" + s;
+            }
+            s = "0." + s;
+        }
+        return new integer_1.Integer(Number(s), s);
+    };
+    Power.prototype.toTree = function () {
+        return new powerNode_1.PowerNode(new numberNode_1.NumberNode(this.operand), new numberNode_1.NumberNode(this.power));
+    };
+    return Power;
+}());
+exports.Power = Power;

package/src/numbers/integer/power.ts

@@ -0,0 +1,49 @@
+import { Node } from "../../tree/nodes/node";
+import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+import { PowerNode } from "../../tree/nodes/operators/powerNode";
+import { Nombre, NumberType } from "../nombre";
+import { Integer } from "./integer";
+
+export class Power implements Nombre {
+  value: number;
+  tex: string;
+  type: NumberType;
+  operand: number;
+  power: number;
+  constructor(a: number, b: number) {
+    this.operand = a;
+    this.power = b;
+    this.value = Math.pow(a, b);
+    this.tex = `${a}^{${b}}`;
+    this.type = b < 0 ? NumberType.Rational : NumberType.Integer;
+  }
+  simplify(): Node {
+    if (this.power === 0) return new NumberNode(1);
+    if (this.power === 1) return new NumberNode(this.operand);
+    if (this.operand === 1) return new NumberNode(1);
+    if (this.operand === 0) return new NumberNode(0);
+    if (this.operand === -1) return new NumberNode(this.power % 2 === 0 ? 1 : -1);
+    return this.toTree();
+  }
+  toDecimalWriting(): Nombre {
+    if (this.operand !== 10) throw Error("only implemented for powers of ten so far");
+    let s = "";
+    if (this.power > -1) {
+      s += "1";
+      for (let i = 0; i < this.power; i++) {
+        s += 0;
+      }
+    } else {
+      s += "1";
+      for (let i = 1; i < Math.abs(this.power); i++) {
+        s = "0" + s;
+      }
+      s = "0." + s;
+    }
+
+    return new Integer(Number(s), s);
+  }
+  toTree(): Node {
+    return new PowerNode(new NumberNode(this.operand), new NumberNode(this.power));
+  }
+}

package/src/numbers/nombre.js

@@ -4,6 +4,7 @@ exports.NumberType = void 0;
 var NumberType;
 (function (NumberType) {
     NumberType[NumberType["Integer"] = 0] = "Integer";
-    NumberType[NumberType["Rational"] = 1] = "Rational";
-    NumberType[NumberType["Real"] = 2] = "Real";
+    NumberType[NumberType["Decimal"] = 1] = "Decimal";
+    NumberType[NumberType["Rational"] = 2] = "Rational";
+    NumberType[NumberType["Real"] = 3] = "Real";
 })(NumberType = exports.NumberType || (exports.NumberType = {}));

package/src/numbers/nombre.ts

@@ -3,11 +3,13 @@ import { NumberNode } from "../tree/nodes/numbers/numberNode";
 
 export enum NumberType {
   Integer,
+  Decimal,
   Rational,
   Real,
 }
 export interface Nombre {
   value: number;
   tex: string;
+  type: NumberType;
   toTree: () => Node;
 }

package/src/numbers/rationals/rational.js

@@ -1,37 +1,123 @@
 "use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 exports.__esModule = true;
-exports.Rational = void 0;
+exports.Rational = exports.RationalConstructor = void 0;
+var coprimesOf_1 = require("../../mathutils/arithmetic/coprimesOf");
 var gcd_1 = require("../../mathutils/arithmetic/gcd");
+var lcd_1 = require("../../mathutils/arithmetic/lcd");
+var randint_1 = require("../../mathutils/random/randint");
 var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-var divideNode_1 = require("../../tree/nodes/operators/divideNode");
+var fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+var random_1 = require("../../utils/random");
+var shuffle_1 = require("../../utils/shuffle");
 var integer_1 = require("../integer/integer");
+var nombre_1 = require("../nombre");
+var RationalConstructor = /** @class */ (function () {
+    function RationalConstructor() {
+    }
+    /**
+     * @param maxGcd max number by which the fraction is simplifiable
+     */
+    RationalConstructor.randomSimplifiable = function (maxGcd) {
+        if (maxGcd === void 0) { maxGcd = 10; }
+        var gcd = (0, randint_1.randint)(2, maxGcd);
+        var max = (0, randint_1.randint)(3, 11);
+        var min = (0, random_1.random)((0, coprimesOf_1.coprimesOf)(max));
+        var _a = (0, shuffle_1.shuffle)([gcd * min, gcd * max]), num = _a[0], denum = _a[1];
+        if (denum === gcd) {
+            //si 10/2 on transforme en 2/10
+            return new Rational(denum, num);
+        }
+        return new Rational(num, denum);
+    };
+    RationalConstructor.randomIrreductible = function (max) {
+        if (max === void 0) { max = 11; }
+        var a = (0, randint_1.randint)(2, max);
+        var b = (0, random_1.random)(__spreadArray(__spreadArray([], (0, coprimesOf_1.coprimesOf)(a), true), [1], false));
+        if (b === 1)
+            return new Rational(b, a);
+        var _a = (0, shuffle_1.shuffle)([a, b]), num = _a[0], denum = _a[1];
+        return new Rational(num, denum);
+    };
+    return RationalConstructor;
+}());
+exports.RationalConstructor = RationalConstructor;
 var Rational = /** @class */ (function () {
     function Rational(numerator, denumerator) {
+        if (denumerator === 0)
+            throw Error("division by zero");
         this.num = numerator;
         this.denum = denumerator;
         this.value = numerator / denumerator;
         this.isSimplified = Math.abs((0, gcd_1.gcd)(numerator, denumerator)) === 1;
         this.tex = "\\frac{".concat(this.num, "}{").concat(this.denum, "}");
+        this.type = nombre_1.NumberType.Rational;
     }
     Rational.prototype.toTex = function () {
         return "\\frac{".concat(this.num, "}{").concat(this.denum, "}");
     };
-    Rational.prototype.add = function (expression) {
-        return this;
+    Rational.prototype.add = function (nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                var num = this.num + this.denum * nb.value;
+                return new Rational(num, this.denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                var rational = nb;
+                var ppcm = (0, lcd_1.lcd)(rational.denum, this.denum);
+                var num = this.num * (ppcm / this.denum) + rational.num * (ppcm / rational.denum);
+                return new Rational(num, ppcm).simplify();
+            }
+        }
+        throw Error("not implemented yet");
+    };
+    Rational.prototype.multiply = function (nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                var num = this.num * nb.value;
+                var denum = this.denum;
+                return new Rational(num, denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                var rational = nb;
+                var num = this.num * rational.num;
+                var denum = this.denum * rational.denum;
+                return new Rational(num, denum).simplify();
+            }
+        }
+        throw Error("not implemented yet");
     };
-    Rational.prototype.multiply = function (expression) {
-        return this;
+    Rational.prototype.divide = function (nb) {
+        switch (nb.type) {
+            case nombre_1.NumberType.Integer: {
+                var denum = this.denum * nb.value;
+                return new Rational(this.num, denum).simplify();
+            }
+            case nombre_1.NumberType.Rational: {
+                var rational = nb;
+                var num = this.num * rational.denum;
+                var denum = this.denum * rational.num;
+                return new Rational(num, denum).simplify();
+            }
+        }
+        throw Error("not implemented yet");
     };
     Rational.prototype.opposite = function () {
         return new Rational(-this.num, this.denum);
     };
     Rational.prototype.toTree = function () {
-        return new divideNode_1.DivideNode(new numberNode_1.NumberNode(this.num), new numberNode_1.NumberNode(this.denum));
+        return new fractionNode_1.FractionNode(new numberNode_1.NumberNode(this.num), new numberNode_1.NumberNode(this.denum));
     };
     Rational.prototype.simplify = function () {
-        var sign = (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0)
-            ? 1
-            : -1;
+        var sign = (this.num > 0 && this.denum > 0) || (this.num < 0 && this.denum < 0) ? 1 : -1;
         var div = Math.abs((0, gcd_1.gcd)(this.num, this.denum));
         if (Math.abs(this.denum) === div)
             return new integer_1.Integer(this.num / this.denum);