umt 1.9.0 → 2.1.0

package/module/es5/Math/min.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 最小値を返す
+ * @param {number[]} number_
+ * @returns number
+ * @example min(1, 2, 3); // 1
+ */
+export declare const min: (...number_: number[]) => number;

package/module/es5/Math/min.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.min = void 0;
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * 最小値を返す
+ * @param {number[]} number_
+ * @returns number
+ * @example min(1, 2, 3); // 1
+ */
+var min = exports.min = function min() {
+  for (var _len = arguments.length, number_ = new Array(_len), _key = 0; _key < _len; _key++) {
+    number_[_key] = arguments[_key];
+  }
+  return Reflect.apply(Math.min, null, _toConsumableArray(new Set(number_)));
+};

package/module/es5/Math/multiples.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 倍数
+ * @param  {number} x
+ * @param  {number} n
+ * @returns number[]
+ * @example multiples(2, 5); // [2, 4, 6, 8, 10]
+ */
+export declare const multiples: (x: number, n: number) => number[];

package/module/es5/Math/multiples.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.multiples = void 0;
+/**
+ * 倍数
+ * @param  {number} x
+ * @param  {number} n
+ * @returns number[]
+ * @example multiples(2, 5); // [2, 4, 6, 8, 10]
+ */
+var multiples = exports.multiples = function multiples(x, n) {
+  var result = [];
+  for (var index = 1; index <= n; index++) {
+    result.push(x * index);
+  }
+  return result;
+};

package/module/es5/Math/multiplication.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 誤差のない掛け算を任意長の引数で行う
+ * @param  {...number[]} numbers
+ * @returns number
+ * @example multiplication(0.1, 0.2, 0.3); // 0.006
+ */
+export declare const multiplication: (...numbers: number[]) => number;

package/module/es5/Math/multiplication.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.multiplication = void 0;
+var _getDecimalLength = require("./getDecimalLength");
+/**
+ * 誤差のない掛け算を任意長の引数で行う
+ * @param  {...number[]} numbers
+ * @returns number
+ * @example multiplication(0.1, 0.2, 0.3); // 0.006
+ */
+var multiplication = exports.multiplication = function multiplication() {
+  for (var _len = arguments.length, numbers = new Array(_len), _key = 0; _key < _len; _key++) {
+    numbers[_key] = arguments[_key];
+  }
+  return numbers.reduce(function (accumulator, number) {
+    var n = Math.pow(10, (0, _getDecimalLength.getDecimalLength)(accumulator) + (0, _getDecimalLength.getDecimalLength)(number));
+    var accumulatorWithoutDot = +"".concat(accumulator).replace(".", "");
+    var numberWithoutDot = +"".concat(number).replace(".", "");
+    return accumulatorWithoutDot * numberWithoutDot / n;
+  }, 1);
+};

package/module/es5/Math/nCr.d.ts

@@ -0,0 +1,8 @@
+/**
+ * n個からr個を選ぶ組み合わせ（nCr）を計算します。
+ * @param n - 選ぶ元となる全体の数
+ * @param r - 選ぶ個数
+ * @returns 組み合わせの結果、または引数が無効な場合はNaN
+ * @example nCr(5, 2); // 10
+ */
+export declare const nCr: (n: number, r: number) => number;

package/module/es5/Math/nCr.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nCr = void 0;
+var _nPr = require("./nPr");
+/**
+ * n個からr個を選ぶ組み合わせ（nCr）を計算します。
+ * @param n - 選ぶ元となる全体の数
+ * @param r - 選ぶ個数
+ * @returns 組み合わせの結果、または引数が無効な場合はNaN
+ * @example nCr(5, 2); // 10
+ */
+var nCr = exports.nCr = function nCr(n, r) {
+  if (n === 0 || r === 0 || n < r) {
+    return Number.NaN;
+  }
+  var numerator = (0, _nPr.nPr)(n, r);
+  var denominator = 1;
+  for (var index = 2; index <= r; index++) {
+    denominator *= index;
+  }
+  var result = numerator / denominator;
+  return result;
+};

package/module/es5/Math/nHr.d.ts

@@ -0,0 +1,8 @@
+/**
+ * n個からr個を重複を許して選ぶ組み合わせ（nHr）を計算します。
+ * @param n - 選ぶ元となる全体の数
+ * @param r - 選ぶ個数
+ * @returns 重複組み合わせの結果、または引数が無効な場合はNaN
+ * @example nHr(5, 2); // 15
+ */
+export declare const nHr: (n: number, r: number) => number;

package/module/es5/Math/nHr.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nHr = void 0;
+var _nCr = require("./nCr");
+/**
+ * n個からr個を重複を許して選ぶ組み合わせ（nHr）を計算します。
+ * @param n - 選ぶ元となる全体の数
+ * @param r - 選ぶ個数
+ * @returns 重複組み合わせの結果、または引数が無効な場合はNaN
+ * @example nHr(5, 2); // 15
+ */
+var nHr = exports.nHr = function nHr(n, r) {
+  if (n === 0 || r === 0 || n < 0 || r < 0) {
+    return Number.NaN;
+  }
+  var result = (0, _nCr.nCr)(n + r - 1, r);
+  return result;
+};

package/module/es5/Math/nPr.d.ts

@@ -0,0 +1,8 @@
+/**
+ * n個からr個を選ぶ順列（nPr）を計算します。
+ * @param n - 選ぶ元となる全体の数
+ * @param r - 選ぶ個数
+ * @returns 順列の結果、または引数が無効な場合はNaN
+ * @example nPr(5, 2); // 20
+ */
+export declare const nPr: (n: number, r: number) => number;

package/module/es5/Math/nPr.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nPr = void 0;
+/**
+ * n個からr個を選ぶ順列（nPr）を計算します。
+ * @param n - 選ぶ元となる全体の数
+ * @param r - 選ぶ個数
+ * @returns 順列の結果、または引数が無効な場合はNaN
+ * @example nPr(5, 2); // 20
+ */
+var nPr = exports.nPr = function nPr(n, r) {
+  if (n === 0 || r === 0 || n < r) {
+    return Number.NaN;
+  }
+  var result = 1;
+  for (var index = 0; index < r; index++) {
+    result *= n - index;
+  }
+  return result;
+};

package/module/es5/Math/primeFactorization.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 素因数分解
+ * @param  {number} x
+ * @returns {number: number; count: number}[]
+ * @example primeFactorization(12); // [{number: 2, count: 2}, {number: 3, count: 1}]
+ */
+export declare const primeFactorization: (x: number) => {
+    number: number;
+    count: number;
+}[];

package/module/es5/Math/primeFactorization.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.primeFactorization = void 0;
+/**
+ * 素因数分解
+ * @param  {number} x
+ * @returns {number: number; count: number}[]
+ * @example primeFactorization(12); // [{number: 2, count: 2}, {number: 3, count: 1}]
+ */
+var primeFactorization = exports.primeFactorization = function primeFactorization(x) {
+  var n = 0;
+  var cooyX = x;
+  var out = [];
+  for (var index = 2; index <= cooyX; index++) {
+    if (cooyX % index === 0) {
+      n = 0;
+      while (cooyX % index === 0) {
+        n++;
+        cooyX /= index;
+      }
+      out.push({
+        number: index,
+        count: n
+      });
+    }
+  }
+  return out;
+};

package/module/es5/Math/quotient.d.ts

@@ -0,0 +1,8 @@
+/**
+ * あまりの割り算
+ * @param  {number} x
+ * @param  {number} y
+ * @returns number[]
+ * @example quotient(5, 2); // [2, 1]
+ */
+export declare const quotient: (x: number, y: number) => number[];

package/module/es5/Math/quotient.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.quotient = void 0;
+/**
+ * あまりの割り算
+ * @param  {number} x
+ * @param  {number} y
+ * @returns number[]
+ * @example quotient(5, 2); // [2, 1]
+ */
+var quotient = exports.quotient = function quotient(x, y) {
+  return [(x - x % y) / y, x % y + 0];
+};

package/module/es5/Math/radToDeg.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ラジアンを角度に変換
+ * @param  {number} x
+ * @returns number
+ * @example radToDeg(Math.PI); // 180
+ */
+export declare const radToDeg: (x: number) => number;

package/module/es5/Math/radToDeg.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.radToDeg = void 0;
+var _division = require("./division");
+/**
+ * ラジアンを角度に変換
+ * @param  {number} x
+ * @returns number
+ * @example radToDeg(Math.PI); // 180
+ */
+var radToDeg = exports.radToDeg = function radToDeg(x) {
+  return (0, _division.division)(x, (0, _division.division)(Math.PI, 180));
+};

package/module/es5/Math/random.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 整数の乱数
+ * @param  {number} max 最大値
+ * @param  {number} min 最小値
+ * @return {number}
+ * @example random(10); // 0~10
+ */
+export declare const random: (max: number, min?: number) => number;

package/module/es5/Math/random.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.random = void 0;
+/**
+ * 整数の乱数
+ * @param  {number} max 最大値
+ * @param  {number} min 最小値
+ * @return {number}
+ * @example random(10); // 0~10
+ */
+var random = exports.random = function random(max) {
+  var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};

package/module/es5/Math/reduce.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 約分
+ * @param  {number} x
+ * @param  {number} y
+ * @returns {x: number, y: number, gcd: number}
+ * @example reduce(2, 4); // {x: 1, y: 2, gcd: 2}
+ */
+export declare const reduce: (x: number, y: number) => {
+    x: number;
+    y: number;
+    gcd?: undefined;
+} | {
+    x: number;
+    y: number;
+    gcd: number;
+};

package/module/es5/Math/reduce.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reduce = void 0;
+var _gcd = require("./gcd");
+/**
+ * 約分
+ * @param  {number} x
+ * @param  {number} y
+ * @returns {x: number, y: number, gcd: number}
+ * @example reduce(2, 4); // {x: 1, y: 2, gcd: 2}
+ */
+var reduce = exports.reduce = function reduce(x, y) {
+  if (x === 0 || y === 0) {
+    return {
+      x: Number.NaN,
+      y: Number.NaN
+    };
+  }
+  var n = (0, _gcd.gcd)(x, y);
+  return {
+    x: x / n,
+    y: y / n,
+    gcd: (0, _gcd.gcd)(x, y)
+  };
+};

package/module/es5/Math/repeatedTrial.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 反復的な思考
+ * @param  {number} n
+ * @param  {number} r
+ * @param  {{x:number;y:number}} p
+ * @return {number[]}
+ * @example repeatedTrial(5, 2, {x: 1/3, y: 2/3}); // [10, 27]
+ */
+export declare const repeatedTrial: (n: number, r: number, p: {
+    x: number;
+    y: number;
+}) => number[];

package/module/es5/Math/repeatedTrial.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.repeatedTrial = void 0;
+var _gcd = require("./gcd");
+var _nCr = require("./nCr");
+/**
+ * 反復的な思考
+ * @param  {number} n
+ * @param  {number} r
+ * @param  {{x:number;y:number}} p
+ * @return {number[]}
+ * @example repeatedTrial(5, 2, {x: 1/3, y: 2/3}); // [10, 27]
+ */
+var repeatedTrial = exports.repeatedTrial = function repeatedTrial(n, r, p) {
+  var x = (0, _nCr.nCr)(n, r);
+  var answer1 = x * Math.pow(p.x, r) * Math.pow(p.y - p.x, n - r);
+  var answer2 = Math.pow(p.y, r) * Math.pow(p.y, n - r);
+  var greatest_common_divisor = (0, _gcd.gcd)(answer1, answer2);
+  return [answer1 / greatest_common_divisor, answer2 / greatest_common_divisor];
+};

package/module/es5/Math/roundOf.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 四捨五入
+ * @param {number} number_ - 四捨五入する数値
+ * @param {number} precision - 四捨五入する桁数
+ * @returns number
+ * @example roundOf(1.234, 2); // 1.23
+ */
+export declare const roundOf: (number_: number, precision?: number) => number;

package/module/es5/Math/roundOf.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.roundOf = void 0;
+/**
+ * 四捨五入
+ * @param {number} number_ - 四捨五入する数値
+ * @param {number} precision - 四捨五入する桁数
+ * @returns number
+ * @example roundOf(1.234, 2); // 1.23
+ */
+var roundOf = exports.roundOf = function roundOf(number_) {
+  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  return Math.round(number_ * Math.pow(10, precision)) / Math.pow(10, precision);
+};

package/module/es5/Math/solveEquation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 連立一次方程式を解く
+ * @param {number[][]} coefficients - 係数
+ * @param {number[]} constants - 定数
+ * @returns {number[]} 解
+ * @example
+ * // x + y = 4
+ * // x + 2y = 10
+ * solveEquation(
+ * {
+ * 	coefficients: [
+ * 		[1, 1],
+ * 		[1, 2],
+ * 	],
+ * 	constants: [4, 10],
+ * },
+ * ); // [-2, 6]
+ */
+export declare const solveEquation: (coefficients: number[][], constants: number[]) => number[];

package/module/es5/Math/solveEquation.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.solveEquation = void 0;
+var _addition = require("./addition");
+var _division = require("./division");
+var _multiplication = require("./multiplication");
+var _roundOf = require("./roundOf");
+var _subtract = require("./subtract");
+/**
+ * 連立一次方程式を解く
+ * @param {number[][]} coefficients - 係数
+ * @param {number[]} constants - 定数
+ * @returns {number[]} 解
+ * @example
+ * // x + y = 4
+ * // x + 2y = 10
+ * solveEquation(
+ * {
+ * 	coefficients: [
+ * 		[1, 1],
+ * 		[1, 2],
+ * 	],
+ * 	constants: [4, 10],
+ * },
+ * ); // [-2, 6]
+ */
+var solveEquation = exports.solveEquation = function solveEquation(coefficients, constants) {
+  var n = constants.length;
+  for (var index = 0; index < n; index++) {
+    // Find the max element in the column
+    var maxElement = Math.abs(coefficients[index][index]);
+    var maxRow = index;
+    for (var index_ = index + 1; index_ < n; index_++) {
+      if (Math.abs(coefficients[index_][index]) > maxElement) {
+        maxElement = Math.abs(coefficients[index_][index]);
+        maxRow = index_;
+      }
+    }
+
+    // Swap the row with the max element to the top of the matrix
+    for (var _index_ = index; _index_ < n; _index_++) {
+      var temporary_ = coefficients[maxRow][_index_];
+      coefficients[maxRow][_index_] = coefficients[index][_index_];
+      coefficients[index][_index_] = temporary_;
+    }
+    var temporary = constants[maxRow];
+    constants[maxRow] = constants[index];
+    constants[index] = temporary;
+
+    // Perform elimination on the rows below
+    for (var _index_2 = index + 1; _index_2 < n; _index_2++) {
+      // const factor = coefficients[j][i] / coefficients[i][i];
+      var factor = (0, _division.division)(coefficients[_index_2][index], coefficients[index][index]);
+      // constants[j] -= factor * constants[i];
+      constants[_index_2] = (0, _subtract.subtract)(constants[_index_2], (0, _multiplication.multiplication)(factor, constants[index]));
+      for (var k = index; k < n; k++) {
+        // coefficients[j][k] -= factor * coefficients[i][k];
+        coefficients[_index_2][k] = (0, _subtract.subtract)(coefficients[_index_2][k], (0, _multiplication.multiplication)(factor, coefficients[index][k]));
+      }
+    }
+  }
+  var solution = [];
+
+  // Back substitute to find the solution
+  for (var _index = n - 1; _index >= 0; _index--) {
+    var sum = 0;
+    for (var _index_3 = _index + 1; _index_3 < n; _index_3++) {
+      // sum += coefficients[i][j] * solution[n - j - 1];
+      sum = (0, _addition.addition)(sum, (0, _multiplication.multiplication)(coefficients[_index][_index_3], solution[(0, _subtract.subtract)((0, _subtract.subtract)(n, _index_3), 1)]));
+    }
+    // solution.push((constants[i] - sum) / coefficients[i][i]);
+    solution.push((0, _division.division)((0, _subtract.subtract)(constants[_index], sum), coefficients[_index][_index]));
+  }
+  return solution.reverse().map(function (x) {
+    return (0, _roundOf.roundOf)(x, 1);
+  });
+};

package/module/es5/Math/standardDeviation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 標準偏差
+ * @param  {number[]} values
+ * @returns number
+ * @example standardDeviation([1, 2, 3]); // 0.816496580927726
+ */
+export declare const standardDeviation: (values: number[]) => number;

package/module/es5/Math/standardDeviation.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.standardDeviation = void 0;
+var _average = require("./average");
+/**
+ * 標準偏差
+ * @param  {number[]} values
+ * @returns number
+ * @example standardDeviation([1, 2, 3]); // 0.816496580927726
+ */
+var standardDeviation = exports.standardDeviation = function standardDeviation(values) {
+  var avg = (0, _average.average)(values);
+  var squareDiffs = values.map(function (value) {
+    var diff = value - avg;
+    var sqrDiff = diff * diff;
+    return sqrDiff;
+  });
+  var avgSquareDiff = (0, _average.average)(squareDiffs);
+  var standardDeviation_ = Math.sqrt(avgSquareDiff);
+  return standardDeviation_;
+};

package/module/es5/Math/subtract.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 誤差のない引き算を任意長の引数で行う
+ * @param  {number[]} numbers 引き算を行う数値の配列
+ * @returns number
+ * @example subtract([0.1, 0.2, 0.3]); // -0.4
+ */
+export declare const subtract: (...numbers: number[]) => number;

package/module/es5/Math/subtract.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subtract = void 0;
+var _getDecimalLength = require("./getDecimalLength");
+var _max = require("./max");
+var _multiplication = require("./multiplication");
+/**
+ * 誤差のない引き算を任意長の引数で行う
+ * @param  {number[]} numbers 引き算を行う数値の配列
+ * @returns number
+ * @example subtract([0.1, 0.2, 0.3]); // -0.4
+ */
+
+var subtract = exports.subtract = function subtract() {
+  for (var _len = arguments.length, numbers = new Array(_len), _key = 0; _key < _len; _key++) {
+    numbers[_key] = arguments[_key];
+  }
+  return numbers.reduce(function (accumulator, current, index) {
+    if (index === 0) {
+      return current;
+    }
+    // 10の何乗かを取得
+    var z = Math.pow(10, (0, _max.max)((0, _getDecimalLength.getDecimalLength)(accumulator), (0, _getDecimalLength.getDecimalLength)(current)));
+    // 小数点を揃えてから引き算
+    return ((0, _multiplication.multiplication)(accumulator, z) - (0, _multiplication.multiplication)(current, z)) / z;
+  }, 0);
+};

package/module/es5/Math/toBaseN.d.ts

@@ -0,0 +1,8 @@
+/**
+ * n進数に変換
+ * @param {number} x
+ * @param  {number} [radix=2] n進数
+ * @returns string
+ * @example toBaseN(10); // "1010"
+ */
+export declare const toBaseN: (x: number, radix?: number) => string;

package/module/es5/Math/toBaseN.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toBaseN = void 0;
+/**
+ * n進数に変換
+ * @param {number} x
+ * @param  {number} [radix=2] n進数
+ * @returns string
+ * @example toBaseN(10); // "1010"
+ */
+var toBaseN = exports.toBaseN = function toBaseN(x) {
+  var radix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  return x.toString(radix);
+};

package/module/es5/Math/toCelsius.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ケルビンを摂氏に変換する
+ * @param kelvin
+ * @returns number
+ * @example toCelsius(300); // 26.85
+ */
+export declare const toCelsius: (kelvin: number) => number;