umt 1.9.0 → 2.1.0

package/module/es5/Math/index.js

@@ -0,0 +1,434 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _addition = require("./addition");
+Object.keys(_addition).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _addition[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _addition[key];
+    }
+  });
+});
+var _average = require("./average");
+Object.keys(_average).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _average[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _average[key];
+    }
+  });
+});
+var _bitwise = require("./bitwise");
+Object.keys(_bitwise).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bitwise[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _bitwise[key];
+    }
+  });
+});
+var _calculator = require("./calculator");
+Object.keys(_calculator).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _calculator[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _calculator[key];
+    }
+  });
+});
+var _degToRad = require("./degToRad");
+Object.keys(_degToRad).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _degToRad[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _degToRad[key];
+    }
+  });
+});
+var _deviationValue = require("./deviationValue");
+Object.keys(_deviationValue).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _deviationValue[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _deviationValue[key];
+    }
+  });
+});
+var _division = require("./division");
+Object.keys(_division).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _division[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _division[key];
+    }
+  });
+});
+var _factorial = require("./factorial");
+Object.keys(_factorial).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _factorial[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _factorial[key];
+    }
+  });
+});
+var _factorize = require("./factorize");
+Object.keys(_factorize).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _factorize[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _factorize[key];
+    }
+  });
+});
+var _flexibleNumberConversion = require("./flexibleNumberConversion");
+Object.keys(_flexibleNumberConversion).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _flexibleNumberConversion[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _flexibleNumberConversion[key];
+    }
+  });
+});
+var _gcd = require("./gcd");
+Object.keys(_gcd).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _gcd[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _gcd[key];
+    }
+  });
+});
+var _getDecimalLength = require("./getDecimalLength");
+Object.keys(_getDecimalLength).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getDecimalLength[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _getDecimalLength[key];
+    }
+  });
+});
+var _lcm = require("./lcm");
+Object.keys(_lcm).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _lcm[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _lcm[key];
+    }
+  });
+});
+var _linearCongruentialGenerator = require("./linearCongruentialGenerator");
+Object.keys(_linearCongruentialGenerator).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _linearCongruentialGenerator[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _linearCongruentialGenerator[key];
+    }
+  });
+});
+var _mathConverter = require("./mathConverter");
+Object.keys(_mathConverter).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mathConverter[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _mathConverter[key];
+    }
+  });
+});
+var _mathSeparator = require("./mathSeparator");
+Object.keys(_mathSeparator).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mathSeparator[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _mathSeparator[key];
+    }
+  });
+});
+var _max = require("./max");
+Object.keys(_max).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _max[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _max[key];
+    }
+  });
+});
+var _median = require("./median");
+Object.keys(_median).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _median[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _median[key];
+    }
+  });
+});
+var _min = require("./min");
+Object.keys(_min).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _min[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _min[key];
+    }
+  });
+});
+var _multiples = require("./multiples");
+Object.keys(_multiples).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _multiples[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _multiples[key];
+    }
+  });
+});
+var _multiplication = require("./multiplication");
+Object.keys(_multiplication).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _multiplication[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _multiplication[key];
+    }
+  });
+});
+var _nCr = require("./nCr");
+Object.keys(_nCr).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _nCr[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _nCr[key];
+    }
+  });
+});
+var _nHr = require("./nHr");
+Object.keys(_nHr).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _nHr[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _nHr[key];
+    }
+  });
+});
+var _nPr = require("./nPr");
+Object.keys(_nPr).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _nPr[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _nPr[key];
+    }
+  });
+});
+var _primeFactorization = require("./primeFactorization");
+Object.keys(_primeFactorization).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _primeFactorization[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _primeFactorization[key];
+    }
+  });
+});
+var _quotient = require("./quotient");
+Object.keys(_quotient).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _quotient[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _quotient[key];
+    }
+  });
+});
+var _radToDeg = require("./radToDeg");
+Object.keys(_radToDeg).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _radToDeg[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _radToDeg[key];
+    }
+  });
+});
+var _random = require("./random");
+Object.keys(_random).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _random[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _random[key];
+    }
+  });
+});
+var _reduce = require("./reduce");
+Object.keys(_reduce).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _reduce[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _reduce[key];
+    }
+  });
+});
+var _repeatedTrial = require("./repeatedTrial");
+Object.keys(_repeatedTrial).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _repeatedTrial[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _repeatedTrial[key];
+    }
+  });
+});
+var _roundOf = require("./roundOf");
+Object.keys(_roundOf).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _roundOf[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _roundOf[key];
+    }
+  });
+});
+var _solveEquation = require("./solveEquation");
+Object.keys(_solveEquation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _solveEquation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _solveEquation[key];
+    }
+  });
+});
+var _standardDeviation = require("./standardDeviation");
+Object.keys(_standardDeviation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _standardDeviation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _standardDeviation[key];
+    }
+  });
+});
+var _subtract = require("./subtract");
+Object.keys(_subtract).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _subtract[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _subtract[key];
+    }
+  });
+});
+var _toBaseN = require("./toBaseN");
+Object.keys(_toBaseN).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _toBaseN[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _toBaseN[key];
+    }
+  });
+});
+var _toCelsius = require("./toCelsius");
+Object.keys(_toCelsius).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _toCelsius[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _toCelsius[key];
+    }
+  });
+});
+var _toKelvin = require("./toKelvin");
+Object.keys(_toKelvin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _toKelvin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _toKelvin[key];
+    }
+  });
+});
+var _valueSwap = require("./valueSwap");
+Object.keys(_valueSwap).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _valueSwap[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _valueSwap[key];
+    }
+  });
+});
+var _xoshiro = require("./xoshiro256");
+Object.keys(_xoshiro).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _xoshiro[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _xoshiro[key];
+    }
+  });
+});

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

@@ -0,0 +1,8 @@
+/**
+ * 最小公倍数
+ * @param  {number} x
+ * @param  {number} y
+ * @returns number
+ * @example lcm(2, 3); // 6
+ */
+export declare const lcm: (x: number, y: number) => number;

package/module/es5/Math/lcm.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lcm = void 0;
+var _division = require("./division");
+var _gcd = require("./gcd");
+var _multiplication = require("./multiplication");
+var _valueSwap3 = require("./valueSwap");
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+/**
+ * 最小公倍数
+ * @param  {number} x
+ * @param  {number} y
+ * @returns number
+ * @example lcm(2, 3); // 6
+ */
+var lcm = exports.lcm = function lcm(x, y) {
+  if (x === 0 || y === 0) {
+    return 0;
+  }
+  var _valueSwap = (0, _valueSwap3.valueSwap)(x, y),
+    _valueSwap2 = _slicedToArray(_valueSwap, 2),
+    newX = _valueSwap2[0],
+    newY = _valueSwap2[1];
+  return (0, _multiplication.multiplication)((0, _division.division)(newX, (0, _gcd.gcd)(newX, newY)), newY);
+};

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

@@ -0,0 +1,11 @@
+/**
+ * 線形合同法による乱数生成器
+ * @param seed 初期シード値
+ * @param max 最大値 (デフォルト: 4294967296)
+ * @param multiplier 乗数 (デフォルト: 1664525)
+ * @param increment 加算定数 (デフォルト: 1013904223)
+ * @returns 乱数生成器関数
+ * @example
+ * const lcg = linearCongruentialGenerator(12345);
+ */
+export declare const linearCongruentialGenerator: (seed: number, max?: number, multiplier?: number, increment?: number) => number;

package/module/es5/Math/linearCongruentialGenerator.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.linearCongruentialGenerator = void 0;
+/**
+ * 線形合同法による乱数生成器
+ * @param seed 初期シード値
+ * @param max 最大値 (デフォルト: 4294967296)
+ * @param multiplier 乗数 (デフォルト: 1664525)
+ * @param increment 加算定数 (デフォルト: 1013904223)
+ * @returns 乱数生成器関数
+ * @example
+ * const lcg = linearCongruentialGenerator(12345);
+ */
+var linearCongruentialGenerator = exports.linearCongruentialGenerator = function linearCongruentialGenerator(seed) {
+  var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 4294967296;
+  var multiplier = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1664525;
+  var increment = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1013904223;
+  return (multiplier * seed + increment) % max;
+};

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

@@ -0,0 +1,7 @@
+/**
+ * nの2乗を展開します
+ * @param {string} equation - 変換する数学的な式
+ * @returns {string} 変換後の式
+ * @example mathConverter("1250*1250"); // "1500*1000+400*100+200*100+50*50"
+ */
+export declare const mathConverter: (equation: string) => string;

package/module/es5/Math/mathConverter.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mathConverter = void 0;
+var _mathSeparator3 = require("./mathSeparator");
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+/**
+ * nの2乗を展開します
+ * @param {string} equation - 変換する数学的な式
+ * @returns {string} 変換後の式
+ * @example mathConverter("1250*1250"); // "1500*1000+400*100+200*100+50*50"
+ */
+var _mathConverter = exports.mathConverter = function mathConverter(equation) {
+  var convertedEquation = equation;
+  while (true) {
+    var multiplicationOrExponentiation = convertedEquation.match(/\d+\.?(\d+)?(\*|\^)\d+\.?(\d+)?/);
+    if (!multiplicationOrExponentiation) {
+      return convertedEquation;
+    }
+    var _multiplicationOrExpo = multiplicationOrExponentiation[0].split(/(\*|\^)/),
+      _multiplicationOrExpo2 = _slicedToArray(_multiplicationOrExpo, 3),
+      operand1 = _multiplicationOrExpo2[0],
+      operator = _multiplicationOrExpo2[1],
+      operand2 = _multiplicationOrExpo2[2];
+    if (operand1 === operand2 || operand2 && operator === "^") {
+      var _mathSeparator = (0, _mathSeparator3.mathSeparator)(operand1),
+        _mathSeparator2 = _slicedToArray(_mathSeparator, 2),
+        primary = _mathSeparator2[0],
+        remainder = _mathSeparator2[1];
+      if (!primary) {
+        return convertedEquation;
+      }
+      convertedEquation = "".concat(Number(operand1) + remainder, "*").concat(primary, "+");
+      convertedEquation += remainder <= 100 ? "".concat(remainder, "*").concat(remainder) : _mathConverter("".concat(remainder, "*").concat(remainder));
+    } else {
+      return convertedEquation;
+    }
+  }
+};

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

@@ -0,0 +1,7 @@
+/**
+ * 最大値の位で区切ります。
+ * @param  {string|number} input
+ * @returns [number, number]
+ * @example mathSeparator(1250); // [1000, 250]
+ */
+export declare const mathSeparator: (input: string | number) => [number, number];

package/module/es5/Math/mathSeparator.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mathSeparator = void 0;
+var _isNumber = require("@/Validate/isNumber");
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+/**
+ * 最大値の位で区切ります。
+ * @param  {string|number} input
+ * @returns [number, number]
+ * @example mathSeparator(1250); // [1000, 250]
+ */
+var mathSeparator = exports.mathSeparator = function mathSeparator(input) {
+  if (!(0, _isNumber.isNumber)(input)) {
+    return [0, 0];
+  }
+  var _String$split = String(input).split("."),
+    _String$split2 = _slicedToArray(_String$split, 2),
+    integerPart = _String$split2[0],
+    fractionalPart = _String$split2[1];
+  var decimalPart = fractionalPart ? Number("0.".concat(fractionalPart)) : 0;
+  var numberOfDigits = integerPart.length - 1;
+  var numericalValue = Number(integerPart);
+  if (numberOfDigits === 0) {
+    return [numericalValue, decimalPart];
+  }
+  var primary = Math.pow(10, numberOfDigits);
+  var remainder = numericalValue - primary + decimalPart;
+  return [primary, remainder];
+};

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

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

package/module/es5/Math/max.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.max = 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 max(1, 2, 3); // 3
+ */
+var max = exports.max = function max() {
+  for (var _len = arguments.length, number_ = new Array(_len), _key = 0; _key < _len; _key++) {
+    number_[_key] = arguments[_key];
+  }
+  return Reflect.apply(Math.max, null, _toConsumableArray(new Set(number_)));
+};

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

@@ -0,0 +1,7 @@
+/**
+ * 数値配列の中央値を計算する
+ * @param {number[]} array 数値型の配列
+ * @returns 中央値
+ * @example median([1, 3, 3, 6, 7, 8, 9]); // 6
+ */
+export declare const median: (array: number[]) => number;

package/module/es5/Math/median.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.median = void 0;
+var _quickSort = require("@/Array/quickSort");
+/**
+ * 数値配列の中央値を計算する
+ * @param {number[]} array 数値型の配列
+ * @returns 中央値
+ * @example median([1, 3, 3, 6, 7, 8, 9]); // 6
+ */
+var median = exports.median = function median(array) {
+  var sortedArray = (0, _quickSort.quickSort)(array);
+  var mid = Math.floor(sortedArray.length / 2);
+  return sortedArray.length % 2 === 0 ? (sortedArray[mid - 1] + sortedArray[mid]) / 2 : sortedArray[mid];
+};