umt 1.8.2 → 2.0.0

package/module/es5/IP/longToIp.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.longToIp = void 0;
+/**
+ * 32ビットの数値をIPアドレスに変換します
+ * @param {number} long - 変換する32ビットの数値
+ * @returns {string} IPアドレス
+ */
+var longToIp = exports.longToIp = function longToIp(_long) {
+  var binary = _long.toString(2).padStart(32, "0");
+  return Array.from({
+    length: 4
+  }, function (_, index) {
+    return Number.parseInt(binary.slice(index * 8, (index + 1) * 8), 2);
+  }).join(".");
+};

package/module/es5/IP/subnetMaskToCidr.d.ts

@@ -0,0 +1,6 @@
+/**
+ * サブネットマスクからCIDRを取得します
+ * @param {string} subnetMask - サブネットマスク
+ * @returns {number} CIDR
+ */
+export declare const subnetMaskToCidr: (subnetMask: string) => number;

package/module/es5/IP/subnetMaskToCidr.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subnetMaskToCidr = void 0;
+var _ipToBinaryString = require("./ipToBinaryString");
+var _isValueNaN = require("@/Validate/isValueNaN");
+/**
+ * サブネットマスクからCIDRを取得します
+ * @param {string} subnetMask - サブネットマスク
+ * @returns {number} CIDR
+ */
+var subnetMaskToCidr = exports.subnetMaskToCidr = function subnetMaskToCidr(subnetMask) {
+  // サブネットマスクが有効なIPアドレス形式かどうかをチェック
+  var octets = subnetMask.split(".").map(Number);
+  if (octets.length !== 4 || octets.some(function (octet) {
+    return (0, _isValueNaN.isValueNaN)(octet, true) || octet < 0 || octet > 255;
+  })) {
+    return 0;
+  }
+  return (0, _ipToBinaryString.ipToBinaryString)(subnetMask).match(/1/g).length;
+};

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

@@ -0,0 +1,7 @@
+/**
+ * 誤差のない足し算
+ * @param  {number[]} numbers
+ * @returns number
+ * @example addition(0.1, 0.2); // 0.3
+ */
+export declare const addition: (...numbers: number[]) => number;

package/module/es5/Math/addition.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addition = void 0;
+var _getDecimalLength = require("./getDecimalLength");
+var _max = require("./max");
+var _multiplication = require("./multiplication");
+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[]} numbers
+ * @returns number
+ * @example addition(0.1, 0.2); // 0.3
+ */
+var addition = exports.addition = function addition() {
+  for (var _len = arguments.length, numbers = new Array(_len), _key = 0; _key < _len; _key++) {
+    numbers[_key] = arguments[_key];
+  }
+  var z = Math.pow(10, _max.max.apply(void 0, _toConsumableArray(numbers.map(function (element) {
+    return (0, _getDecimalLength.getDecimalLength)(element);
+  }))));
+  return numbers.reduce(function (sum, current) {
+    return sum + (0, _multiplication.multiplication)(current, z);
+  }, 0) / z;
+};

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

@@ -0,0 +1,7 @@
+/**
+ * 平均値
+ * @param  {number[]} numbers
+ * @returns number
+ * @example average([1, 2, 3]); // 2
+ */
+export declare const average: (numbers: number[]) => number;

package/module/es5/Math/average.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.average = void 0;
+var _addition = require("./addition");
+var _division = require("./division");
+/**
+ * 平均値
+ * @param  {number[]} numbers
+ * @returns number
+ * @example average([1, 2, 3]); // 2
+ */
+var average = exports.average = function average(numbers) {
+  if (numbers.length === 0) {
+    return 0;
+  }
+  var sum = numbers.reduce(function (a, b) {
+    return (0, _addition.addition)(a, b);
+  }, 0);
+  var avg = (0, _division.division)(sum, numbers.length);
+  return avg;
+};

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

@@ -0,0 +1,13 @@
+/**
+ * ビット回転を行う関数
+ * @param x 回転させる32ビット整数
+ * @param k 回転するビット数
+ * @param direction 回転方向 ('left' または 'right')
+ * @returns 指定された方向にkビット回転された結果
+ * @example
+ * const resultLeft = bitwise(0x12345678, 8);
+ * console.log(resultLeft.toString(16)); // '34567812'
+ * const resultRight = bitwise(0x12345678, 8, 'right');
+ * console.log(resultRight.toString(16)); // '78123456'
+ */
+export declare const bitwise: (x: number, k: number, direction?: "left" | "right") => number;

package/module/es5/Math/bitwise.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bitwise = void 0;
+/**
+ * ビット回転を行う関数
+ * @param x 回転させる32ビット整数
+ * @param k 回転するビット数
+ * @param direction 回転方向 ('left' または 'right')
+ * @returns 指定された方向にkビット回転された結果
+ * @example
+ * const resultLeft = bitwise(0x12345678, 8);
+ * console.log(resultLeft.toString(16)); // '34567812'
+ * const resultRight = bitwise(0x12345678, 8, 'right');
+ * console.log(resultRight.toString(16)); // '78123456'
+ */
+var bitwise = exports.bitwise = function bitwise(x, k) {
+  var direction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "left";
+  var rotation = (k % 32 + 32) % 32;
+  switch (direction) {
+    case "left":
+      {
+        return x << rotation | x >>> 32 - rotation;
+      }
+    case "right":
+      {
+        return x >>> rotation | x << 32 - rotation;
+      }
+    default:
+      {
+        throw new Error("Invalid direction ".concat(direction));
+      }
+  }
+};

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

@@ -0,0 +1,10 @@
+/**
+ * 電卓
+ * ()や符号に対応
+ * 一文字までの方程式に対応
+ * @param  {string} expression 計算式または方程式
+ * @param  {object} exchange 為替
+ * @returns 計算結果
+ * @example calculator("1+2"); // 3
+ */
+export declare const calculator: <T extends Record<string, string | number>>(expression: string, exchange?: T) => string;

package/module/es5/Math/calculator/calculator.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculator = void 0;
+var _core = require("./core");
+var _literalExpression = require("./literalExpression");
+/**
+ * 電卓
+ * ()や符号に対応
+ * 一文字までの方程式に対応
+ * @param  {string} expression 計算式または方程式
+ * @param  {object} exchange 為替
+ * @returns 計算結果
+ * @example calculator("1+2"); // 3
+ */
+var calculator = exports.calculator = function calculator(expression, exchange) {
+  var cleanExpression = expression.replaceAll(/\s+/g, "");
+  return cleanExpression.includes("=") ? (0, _literalExpression.literalExpression)(cleanExpression) : (0, _core.calculatorCore)(cleanExpression, exchange);
+};

package/module/es5/Math/calculator/calculatorInitialization.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 電卓関数を初期化する
+ * @param {object} exchange - 為替レート
+ * @return {Function} - calculator
+ * @example calculatorInitialization({ $: 100 })("$1"); // "100"
+ */
+export declare const calculatorInitialization: <T extends {
+    [key: string]: string | number;
+}>(exchange: T) => ((x: string) => string);

package/module/es5/Math/calculator/calculatorInitialization.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculatorInitialization = void 0;
+var _calculator = require("./calculator");
+/**
+ * 電卓関数を初期化する
+ * @param {object} exchange - 為替レート
+ * @return {Function} - calculator
+ * @example calculatorInitialization({ $: 100 })("$1"); // "100"
+ */
+var calculatorInitialization = exports.calculatorInitialization = function calculatorInitialization(exchange) {
+  /**
+   * @param {string} x - 金額
+   * @return {string} - 計算結果
+   */
+  return function (x) {
+    return (0, _calculator.calculator)(x, exchange);
+  };
+};

package/module/es5/Math/calculator/convertCurrency.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 文字列内の通貨記号を利用して通貨を換算する。
+ *
+ * @param inputString - 換算する通貨額を含む文字列
+ * @param conversionRates - 通貨記号と換算レートのオブジェクト
+ * @returns 換算後の通貨額を文字列で返す。換算できない場合は元の文字列を返す。
+ * @example convertCurrency("¥100", { "¥": 0.01 }); // "1"
+ */
+export declare const convertCurrency: <T extends {
+    [key: string]: number | string;
+}>(inputString: string, conversionRates?: T) => string;

package/module/es5/Math/calculator/convertCurrency.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertCurrency = void 0;
+var _multiplication = require("@/Math/multiplication");
+var _isNumber = require("@/Validate/isNumber");
+/**
+ * 文字列内の通貨記号を利用して通貨を換算する。
+ *
+ * @param inputString - 換算する通貨額を含む文字列
+ * @param conversionRates - 通貨記号と換算レートのオブジェクト
+ * @returns 換算後の通貨額を文字列で返す。換算できない場合は元の文字列を返す。
+ * @example convertCurrency("¥100", { "¥": 0.01 }); // "1"
+ */
+var convertCurrency = exports.convertCurrency = function convertCurrency(inputString, conversionRates) {
+  if (!conversionRates) {
+    return inputString;
+  }
+  for (var currencySymbol in conversionRates) {
+    if (inputString.startsWith(currencySymbol)) {
+      var amountString = inputString.slice(currencySymbol.length);
+      var rate = conversionRates[currencySymbol];
+      if ((0, _isNumber.isNumber)(rate)) {
+        var amount = Number(amountString);
+        var convertedAmount = (0, _multiplication.multiplication)(amount, Number(rate));
+        return Number.isNaN(convertedAmount) ? inputString : String(convertedAmount);
+      }
+    }
+  }
+  return inputString;
+};

package/module/es5/Math/calculator/core.d.ts

@@ -0,0 +1,3 @@
+export declare const calculatorCore: <T extends {
+    [key: string]: string | number;
+}>(expression: string, currencyExchange?: T) => string;

package/module/es5/Math/calculator/core.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculatorCore = void 0;
+var _convertCurrency = require("./convertCurrency");
+var _addition = require("@/Math/addition");
+var _division = require("@/Math/division");
+var _multiplication = require("@/Math/multiplication");
+var _subtract = require("@/Math/subtract");
+var _isNumber = require("@/Validate/isNumber");
+var calculatorCore = exports.calculatorCore = function calculatorCore(expression, currencyExchange) {
+  var sanitizedExpression = expression;
+
+  // 符号の処理
+  sanitizedExpression = sanitizeSigns(sanitizedExpression);
+
+  // 主要な計算ループ
+  while (true) {
+    // 通貨計算
+    if (currencyExchange) {
+      sanitizedExpression = applyCurrencyExchange(sanitizedExpression, currencyExchange);
+    }
+
+    // 括弧の処理
+    if (containsParentheses(sanitizedExpression)) {
+      var temporary = resolveParentheses(sanitizedExpression);
+      if (temporary === Number.NaN.toString()) {
+        return sanitizedExpression;
+      }
+      sanitizedExpression = temporary;
+    }
+
+    // 乗算、べき乗の処理
+    else if (containsMulExp(sanitizedExpression)) {
+      var _temporary = resolveMulExp(sanitizedExpression);
+      if (_temporary === Number.NaN.toString()) {
+        return sanitizedExpression;
+      }
+      sanitizedExpression = _temporary;
+    }
+
+    // 除算の処理
+    else if (containsDiv(sanitizedExpression)) {
+      var _temporary2 = resolveDiv(sanitizedExpression);
+      if (_temporary2 === Number.NaN.toString()) {
+        return sanitizedExpression;
+      }
+      sanitizedExpression = _temporary2;
+    }
+
+    // 加算と減算の処理
+    else if (containsAddSub(sanitizedExpression) && !(0, _isNumber.isNumber)(sanitizedExpression)) {
+      var _temporary3 = resolveAddSub(sanitizedExpression);
+      if (_temporary3 === Number.NaN.toString()) {
+        return sanitizedExpression;
+      }
+      sanitizedExpression = _temporary3;
+    }
+
+    // もう計算するものがなければ結果を返す
+    else {
+      return sanitizedExpression;
+    }
+  }
+};
+var sanitizeSigns = function sanitizeSigns(expr) {
+  return expr.replaceAll("--", "+").replaceAll("++", "+").replaceAll("+-", "+0-").replaceAll("-+", "+0-");
+};
+var applyCurrencyExchange = function applyCurrencyExchange(expr, rates) {
+  var returnExpr = expr;
+  // 通貨の交換ロジック
+  for (var index in rates) {
+    if (returnExpr.includes(index)) {
+      var $ = returnExpr.match(new RegExp("\\".concat(index, "([0-9]+)")));
+      if ($) {
+        returnExpr = returnExpr.replace($[0], (0, _convertCurrency.convertCurrency)($[0], rates));
+      }
+    }
+  }
+  return returnExpr;
+};
+var containsParentheses = function containsParentheses(expr) {
+  return expr.includes("(") || expr.includes(")");
+};
+var resolveParentheses = function resolveParentheses(expr) {
+  // 括弧内の計算ロジック
+  var match = expr.match(/\(\d+\.?(\d+)?([*+/-])\d+\.?(\d+)?\)/);
+  if (match) {
+    return expr.replace(match[0], calculatorCore(match[0].replaceAll(/\(|\)/g, "")));
+  }
+  return Number.NaN.toString();
+};
+var containsMulExp = function containsMulExp(expr) {
+  return expr.includes("^") || expr.includes("*");
+};
+var containsDiv = function containsDiv(expr) {
+  return expr.includes("/");
+};
+var resolveMulExp = function resolveMulExp(expr) {
+  // 乗算、べき乗の計算ロジック
+  var match = expr.match(/(.*?)(\d+\.?(\d+)?([*^])\d+\.?(\d+)?$)/);
+  if (match) {
+    var operands = match[2].split(/([*/^])/);
+    var result = operands[1] === "^" ? Math.pow(Number(operands[0]), Number(operands[2])) : (0, _multiplication.multiplication)(Number(operands[0]), Number(operands[2]));
+    return "".concat(match[1]).concat(result);
+  }
+  return Number.NaN.toString();
+};
+var resolveDiv = function resolveDiv(expr) {
+  // 除算の計算ロジック
+  var match = expr.match(/\d+\.?(\d+)?(\/)\d+\.?(\d+)?/);
+  if (match) {
+    var operands = match[0].split(/(\/)/);
+    var result = (0, _division.division)(Number(operands[0]), Number(operands[2]));
+    return expr.replace(match[0], String(result));
+  }
+  return Number.NaN.toString();
+};
+var containsAddSub = function containsAddSub(expr) {
+  return expr.includes("+") || expr.includes("-");
+};
+var resolveAddSub = function resolveAddSub(expr) {
+  // 加算、減算の計算ロジック
+  var match = expr.match(/(-?\d+)\.?(\d+)?(\+|-)(-?\d+)\.?(\d+)?/);
+  if (match) {
+    var result = match[3] === "+" ? (0, _addition.addition)(Number(match[1]), Number(match[4])) : (0, _subtract.subtract)(Number(match[1]), Number(match[4]));
+    return expr.replace(match[0], String(result));
+  }
+  return Number.NaN.toString();
+};

package/module/es5/Math/calculator/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./calculator";
+export * from "./calculatorInitialization";
+export * from "./convertCurrency";
+export * from "./core";
+export * from "./literalExpression";

package/module/es5/Math/calculator/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 _calculatorInitialization = require("./calculatorInitialization");
+Object.keys(_calculatorInitialization).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _calculatorInitialization[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _calculatorInitialization[key];
+    }
+  });
+});
+var _convertCurrency = require("./convertCurrency");
+Object.keys(_convertCurrency).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _convertCurrency[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _convertCurrency[key];
+    }
+  });
+});
+var _core = require("./core");
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _core[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _core[key];
+    }
+  });
+});
+var _literalExpression = require("./literalExpression");
+Object.keys(_literalExpression).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _literalExpression[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _literalExpression[key];
+    }
+  });
+});

package/module/es5/Math/calculator/literalExpression.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 文字式の方程式を計算する
+ * @param x 方程式の文字列
+ * @returns 計算結果
+ * @example literalExpression("x+1=2"); // "1"
+ */
+export declare const literalExpression: (x: string) => string;

package/module/es5/Math/calculator/literalExpression.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.literalExpression = void 0;
+var _core = require("./core");
+var _division = require("@/Math/division");
+var _gcd = require("@/Math/gcd");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+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; }
+/**
+ * 文字式の方程式を計算する
+ * @param x 方程式の文字列
+ * @returns 計算結果
+ * @example literalExpression("x+1=2"); // "1"
+ */
+var literalExpression = exports.literalExpression = function literalExpression(x) {
+  // 方程式の数値と変数部分を格納
+  var numericalPart = "";
+  var variablePart = [];
+
+  // 等号で分割し、数値と変数部分を識別
+  var _iterator = _createForOfIteratorHelper(x.split("=")),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var part = _step.value;
+      if (/[A-Za-z]+/.test(part)) {
+        variablePart = part.split(/(\d+[A-Za-z]+)|([^A-Za-z]+)/).filter(function (n) {
+          return n && n !== undefined;
+        });
+      } else {
+        numericalPart = part;
+      }
+    }
+
+    // 変数部分の計算
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (variablePart[1]) {
+    variablePart[1] = (0, _core.calculatorCore)(variablePart[1]).replaceAll("+", "plus").replaceAll("-", "minus").replaceAll("plus", "-").replaceAll("minus", "+");
+  }
+
+  // 数値部分の計算
+  numericalPart = variablePart[1] ? (0, _core.calculatorCore)("".concat(numericalPart).concat(variablePart[1])) : (0, _core.calculatorCore)(numericalPart);
+
+  // 変数部分を再分割
+  variablePart = variablePart[0].split(/(\d+)|([A-Za-z]+)/).filter(function (n) {
+    return n && n !== undefined;
+  });
+
+  // 数値がない場合は計算結果を返す
+  if (Number.isNaN(Number(variablePart[0]))) {
+    return numericalPart;
+  }
+
+  // 最大公約数で簡約
+  var commonGcd = (0, _gcd.gcd)(Number(variablePart[0]), Number(numericalPart));
+  if (commonGcd !== 1) {
+    numericalPart = "".concat((0, _division.division)(Number(numericalPart), commonGcd), "/").concat((0, _division.division)(Number(variablePart[0]), commonGcd));
+    if (/(-?)\d+\/1/.test(numericalPart)) {
+      return numericalPart.replace(/\/1/, "");
+    }
+  }
+  if (variablePart[0] !== "1") {
+    numericalPart = "".concat(numericalPart, "/").concat(variablePart[0]);
+  }
+  return numericalPart;
+};

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

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

package/module/es5/Math/degToRad.js

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

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

@@ -0,0 +1,9 @@
+/**
+ * 偏差値を計算する
+ * @param  {number} value - 現在のセンサー値
+ * @param  {number} averageValue - センサー値の平均値
+ * @param  {number} standardDeviationValue - センサー値の標準偏差
+ * @returns {number} 偏差値
+ * @example deviationValue(10, 5, 2); // 75
+ */
+export declare const deviationValue: (value: number, averageValue: number, standardDeviationValue: number) => number;

package/module/es5/Math/deviationValue.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deviationValue = void 0;
+/**
+ * 偏差値を計算する
+ * @param  {number} value - 現在のセンサー値
+ * @param  {number} averageValue - センサー値の平均値
+ * @param  {number} standardDeviationValue - センサー値の標準偏差
+ * @returns {number} 偏差値
+ * @example deviationValue(10, 5, 2); // 75
+ */
+var deviationValue = exports.deviationValue = function deviationValue(value, averageValue, standardDeviationValue) {
+  return (value - averageValue) / standardDeviationValue * 10 + 50;
+};

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

@@ -0,0 +1,10 @@
+/**
+ * 誤差のない割り算
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {boolean} [isFloor=true]
+ * @returns number
+ * @example division(0.1, 0.2); // 0.5
+ * @example division(10, 3, false); // [3, 1]
+ */
+export declare const division: <T extends boolean = true>(x: number, y: number, isFloor?: T) => T extends true ? number : number[];