math-exercises 1.1.1 → 1.2.1

package/src/mathutils/arithmetic/coprimesOf.js

@@ -0,0 +1,13 @@
+"use strict";
+exports.__esModule = true;
+exports.coprimesOf = void 0;
+var gcd_1 = require("./gcd");
+var coprimesOf = function (nb) {
+    var coprimes = [];
+    for (var i = 2; i <= nb; i++) {
+        if ((0, gcd_1.gcd)(nb, i) === 1)
+            coprimes.push(i);
+    }
+    return coprimes;
+};
+exports.coprimesOf = coprimesOf;

package/src/mathutils/arithmetic/coprimesOf.ts

@@ -0,0 +1,9 @@
+import { gcd } from "./gcd";
+
+export const coprimesOf = (nb: number) => {
+  let coprimes = [];
+  for (let i = 2; i <= nb; i++) {
+    if (gcd(nb, i) === 1) coprimes.push(i);
+  }
+  return coprimes;
+};

package/src/mathutils/arithmetic/dividersOf.ts

@@ -0,0 +1,7 @@
+export const dividersOf = (nb: number) => {
+  let divisors = [];
+  for (let i = 1; i <= nb; i++) {
+    if (nb % i === 0) divisors.push(i);
+  }
+  return divisors;
+};

package/src/mathutils/arithmetic/lcd.js

@@ -0,0 +1,12 @@
+"use strict";
+exports.__esModule = true;
+exports.lcd = void 0;
+function lcd(a, b) {
+    var max = Math.max(a, b);
+    for (var i = max; i < a * b; i++) {
+        if (i % a === 0 && i % b === 0)
+            return i;
+    }
+    return a * b;
+}
+exports.lcd = lcd;

package/src/mathutils/arithmetic/lcd.ts

@@ -0,0 +1,7 @@
+export function lcd(a: number, b: number) {
+  const max = Math.max(a, b);
+  for (let i = max; i < a * b; i++) {
+    if (i % a === 0 && i % b === 0) return i;
+  }
+  return a * b;
+}

package/src/mathutils/arithmetic/nonCoprimesOf.ts

@@ -0,0 +1,9 @@
+import { gcd } from "./gcd";
+
+export const nonCoprimesOf = (nb: number) => {
+  let nonCoprimes = [];
+  for (let i = 1; i <= nb; i++) {
+    if (gcd(nb, i) !== 1) nonCoprimes.push(i);
+  }
+  return nonCoprimes;
+};

package/src/mathutils/arithmetic/nonDividersOf.ts

@@ -0,0 +1,12 @@
+import { dividersOf } from "./dividersOf";
+
+export const nonDivisorOf = (nb: number) => {
+  let nonDividers = [];
+  let dividers = dividersOf(nb);
+
+  for (let i = 2; i < nb; i++) {
+    if (nb % i !== 0) nonDividers.push(i);
+  }
+
+  return nonDividers;
+};

package/src/mathutils/decimals/decimalPartLengthOf.ts

@@ -0,0 +1,10 @@
+export const decimalPartLengthOf = (x: number) => {
+  function hasFraction(x: number) {
+    return Math.abs(Math.round(x) - x) > 1e-10;
+  }
+
+  let count = 0;
+  // multiply by increasing powers of 10 until the fractional part is ~ 0
+  while (hasFraction(x * 10 ** count) && isFinite(10 ** count)) count++;
+  return count;
+};

package/src/mathutils/random/randint.js

@@ -1,9 +1,18 @@
 "use strict";
 exports.__esModule = true;
 exports.randint = void 0;
-var randint = function (a, b) {
+/**
+ * @returns random [[a, b[[
+ */
+var randint = function (a, b, excludes) {
     if (b === undefined)
         return Math.floor(Math.random() * a);
-    return a + Math.floor(Math.random() * (b - a));
+    if (!excludes)
+        return a + Math.floor(Math.random() * (b - a));
+    var res;
+    do {
+        res = a + Math.floor(Math.random() * (b - a));
+    } while (excludes.includes(res));
+    return res;
 };
 exports.randint = randint;

package/src/mathutils/random/randint.ts

@@ -1,4 +1,12 @@
-export const randint = (a: number, b?: number) => {
+/**
+ * @returns random [[a, b[[
+ */
+export const randint = (a: number, b?: number, excludes?: number[]): number => {
   if (b === undefined) return Math.floor(Math.random() * a);
-  return a + Math.floor(Math.random() * (b - a));
+  if (!excludes) return a + Math.floor(Math.random() * (b - a));
+  let res;
+  do {
+    res = a + Math.floor(Math.random() * (b - a));
+  } while (excludes.includes(res));
+  return res;
 };

package/src/numbers/decimals/decimal.js

@@ -0,0 +1,144 @@
+"use strict";
+exports.__esModule = true;
+exports.Decimal = exports.DecimalConstructor = void 0;
+var randint_1 = require("../../mathutils/random/randint");
+var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+var integer_1 = require("../integer/integer");
+var nombre_1 = require("../nombre");
+var DecimalConstructor = /** @class */ (function () {
+    function DecimalConstructor() {
+    }
+    DecimalConstructor.randomFracPart = function (precision) {
+        var decimals = "";
+        for (var i = 0; i < precision; i++) {
+            decimals += (0, randint_1.randint)(i === precision - 1 ? 1 : 0, 10);
+        }
+        return decimals;
+    };
+    DecimalConstructor.random = function (min, max, precision) {
+        var int = (0, randint_1.randint)(min, max) + "";
+        var decimals = DecimalConstructor.randomFracPart(precision);
+        return DecimalConstructor.fromParts(int, decimals);
+    };
+    DecimalConstructor.fromParts = function (intPart, decimalPart) {
+        return new Decimal(Number("" + intPart + "." + decimalPart));
+    };
+    return DecimalConstructor;
+}());
+exports.DecimalConstructor = DecimalConstructor;
+var Decimal = /** @class */ (function () {
+    function Decimal(value) {
+        this.type = nombre_1.NumberType.Decimal;
+        this.value = value;
+        this.tex = value + "";
+        var _a = (value + "").split("."), intPartString = _a[0], decimalPartString = _a[1];
+        this.intPart = Number(intPartString);
+        this.decimalPart = decimalPartString || "";
+        this.precision = this.decimalPart.length;
+    }
+    /**
+     *
+     * @param precision 0 = unité, 1 = dizieme, ... , -1 : dizaine
+     * @returns
+     */
+    Decimal.prototype.round = function (precision) {
+        var intPartString = this.intPart + "";
+        if (precision < 0) {
+            if (precision < -intPartString.length)
+                throw Error("can't round to higher precision");
+            return new integer_1.Integer(this.intPart).round(-precision);
+        }
+        if (precision > this.precision)
+            throw Error("can't round to higher precision");
+        if (precision === this.precision)
+            return this;
+        var newFracPart = "", newIntPart = "";
+        var shouldRoundUp = Number(this.decimalPart[precision]) > 4;
+        if (shouldRoundUp) {
+            var retenue = true;
+            var i = precision - 1;
+            while (retenue) {
+                if (i > -1) {
+                    var nb = (Number(this.decimalPart[i]) + 1) % 10;
+                    if (nb || newFracPart) {
+                        newFracPart = nb.toString() + newFracPart;
+                    }
+                    if (nb !== 0) {
+                        retenue = false;
+                        for (var j = i - 1; j > -1; j--) {
+                            newFracPart = this.decimalPart[j] + newFracPart;
+                        }
+                        newIntPart = intPartString;
+                    }
+                    else
+                        i--;
+                }
+                else {
+                    var nb = (Number(intPartString[i + intPartString.length]) + 1) % 10;
+                    newIntPart = nb + "" + newIntPart;
+                    if (nb !== 0) {
+                        retenue = false;
+                        for (var j = i + intPartString.length - 1; j > -1; j--) {
+                            newIntPart = intPartString[j] + newIntPart;
+                        }
+                    }
+                    else
+                        i--;
+                }
+            }
+        }
+        else {
+            var retenue = true;
+            var i = precision - 1;
+            while (retenue) {
+                if (i > -1) {
+                    var nb = Number(this.decimalPart[i]);
+                    if (nb || newFracPart) {
+                        newFracPart = nb.toString() + newFracPart;
+                    }
+                    if (nb !== 0) {
+                        retenue = false;
+                        for (var 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);
+    };
+    Decimal.prototype.multiplyByPowerOfTen = function (power) {
+        var newIntPart = "", newFracPart = "";
+        if (power > -1) {
+            newIntPart = this.intPart + "";
+            for (var i = 0; i < power; i++) {
+                newIntPart += i > this.decimalPart.length - 1 ? "0" : this.decimalPart[i];
+            }
+            newFracPart = this.decimalPart.slice(power);
+        }
+        else {
+            var intPartString = this.intPart + "";
+            newFracPart = this.decimalPart;
+            for (var 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);
+    };
+    Decimal.prototype.toTree = function () {
+        return new numberNode_1.NumberNode(this.value);
+    };
+    return Decimal;
+}());
+exports.Decimal = Decimal;

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 = {}));