umt 1.9.0 → 2.1.0

package/module/es5/tests/unit/Math/gcd.test.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _gcd = require("@/Math/gcd");
+describe("gcd function", function () {
+  // 正の整数が２つの場合
+  test("two positive integers", function () {
+    expect((0, _gcd.gcd)(56, 48)).toBe(8);
+  });
+
+  // 正の整数が３つ以上の場合
+  test("more than two positive integers", function () {
+    expect((0, _gcd.gcd)(56, 48, 32)).toBe(8);
+    expect((0, _gcd.gcd)(56, 48, 32, 24)).toBe(8);
+  });
+
+  // 0が含まれる場合
+  test("contains zero", function () {
+    expect((0, _gcd.gcd)(56, 0)).toBe(0);
+    expect((0, _gcd.gcd)(0, 56)).toBe(0);
+  });
+
+  // 1が含まれる場合
+  test("contains one", function () {
+    expect((0, _gcd.gcd)(56, 1)).toBe(1);
+    expect((0, _gcd.gcd)(1, 56)).toBe(1);
+  });
+
+  // 負の数が含まれる場合
+  test("contains negative numbers", function () {
+    expect((0, _gcd.gcd)(-56, 48)).toBe(8);
+    expect((0, _gcd.gcd)(56, -48)).toBe(8);
+    expect((0, _gcd.gcd)(-56, -48)).toBe(8);
+    expect((0, _gcd.gcd)(-56, 48, -32)).toBe(8);
+  });
+});

package/module/es5/tests/unit/Math/getDecimalLength.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/getDecimalLength.test.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var _getDecimalLength = require("@/Math/getDecimalLength");
+test("{getDecimalLength}", function () {
+  expect((0, _getDecimalLength.getDecimalLength)(1)).toBe(0);
+  expect((0, _getDecimalLength.getDecimalLength)(1.1)).toBe(1);
+  expect((0, _getDecimalLength.getDecimalLength)(1.11)).toBe(2);
+});

package/module/es5/tests/unit/Math/lcm.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/lcm.test.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _lcm = require("@/Math/lcm");
+describe("lcm関数のテスト", function () {
+  // 正数同士のテスト
+  test("正数の入力", function () {
+    expect((0, _lcm.lcm)(4, 5)).toBe(20);
+    expect((0, _lcm.lcm)(6, 8)).toBe(24);
+    expect((0, _lcm.lcm)(10, 15)).toBe(30);
+    expect((0, _lcm.lcm)(7, 11)).toBe(77);
+  });
+
+  // 0を含むテスト
+  test("0を含む", function () {
+    expect((0, _lcm.lcm)(0, 5)).toBe(0);
+    expect((0, _lcm.lcm)(4, 0)).toBe(0);
+    expect((0, _lcm.lcm)(0, 0)).toBe(0);
+    expect((0, _lcm.lcm)(0, 10)).toBe(0);
+    expect((0, _lcm.lcm)(7, 0)).toBe(0);
+  });
+
+  // 1を含むテスト
+  test("1を含む", function () {
+    expect((0, _lcm.lcm)(1, 5)).toBe(5);
+    expect((0, _lcm.lcm)(4, 1)).toBe(4);
+    expect((0, _lcm.lcm)(1, 1)).toBe(1);
+    expect((0, _lcm.lcm)(1, 10)).toBe(10);
+    expect((0, _lcm.lcm)(7, 1)).toBe(7);
+  });
+
+  // 大きな数値のテスト
+  test("大きな数値", function () {
+    expect((0, _lcm.lcm)(1000, 2000)).toBe(2000);
+    expect((0, _lcm.lcm)(12345, 67890)).toBe(55873470);
+  });
+});

package/module/es5/tests/unit/Math/linearCongruentialGenerator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/linearCongruentialGenerator.test.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _linearCongruentialGenerator = require("@/Math/linearCongruentialGenerator");
+describe("linearCongruentialGenerator", function () {
+  it("乱数を生成する", function () {
+    var result = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(8, 13, 3, 5);
+    expect(result).toBeGreaterThanOrEqual(0);
+    expect(result).toBe(3);
+  });
+  it("同じシード値で同じ乱数列を生成する", function () {
+    var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
+    var result2 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
+    expect(result1).toBe(result2);
+  });
+  it("異なるシード値で異なる乱数列を生成する", function () {
+    var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
+    var result2 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(54321);
+    expect(result1).not.toBe(result2);
+  });
+  it("カスタムパラメータで乱数を生成する", function () {
+    var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345, Math.pow(2, 31), 1103515245, 12345);
+    expect(result1).toBeGreaterThanOrEqual(0);
+    expect(result1).toBe(1406932606);
+  });
+});

package/module/es5/tests/unit/Math/mathConverter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/mathConverter.test.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _mathConverter = require("@/Math/mathConverter");
+describe("mathConverter関数のテスト", function () {
+  // 乗算のテスト
+  test("乗算の変換", function () {
+    expect((0, _mathConverter.mathConverter)("1250*1250")).toBe("1500*1000+400*100+200*100+50*50");
+    expect((0, _mathConverter.mathConverter)("1350*1350")).toBe("1700*1000+600*100+400*100+200*100+50*50");
+    expect((0, _mathConverter.mathConverter)("1550*1550")).toBe("2100*1000+1000*100+800*100+600*100+400*100+200*100+50*50");
+  });
+
+  // 累乗のテスト
+  test("累乗の変換", function () {
+    expect((0, _mathConverter.mathConverter)("1250^2")).toBe("1500*1000+400*100+200*100+50*50");
+    expect((0, _mathConverter.mathConverter)("1350^2")).toBe("1700*1000+600*100+400*100+200*100+50*50");
+  });
+
+  // 何も変換しない場合のテスト
+  test("変換が不要な場合", function () {
+    expect((0, _mathConverter.mathConverter)("1250")).toBe("1250");
+  });
+
+  // 複数のオペランドがある場合のテスト
+  test("複数のオペランドがある場合の変換", function () {
+    expect((0, _mathConverter.mathConverter)("1250+1250")).toBe("1250+1250");
+  });
+
+  // 無効な入力のテスト
+  test("無効な入力の場合", function () {
+    expect((0, _mathConverter.mathConverter)("abc")).toBe("abc");
+  });
+
+  // primaryがない場合のテスト
+  test("primaryがない場合", function () {
+    expect((0, _mathConverter.mathConverter)("0*0")).toBe("0*0");
+  });
+});

package/module/es5/tests/unit/Math/mathSeparator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/mathSeparator.test.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _mathSeparator = require("@/Math/mathSeparator");
+describe("mathSeparator", function () {
+  // 数字の型（number）のテスト
+  it("should handle single digit numbers", function () {
+    expect((0, _mathSeparator.mathSeparator)(5)).toEqual([5, 0]);
+  });
+  it("should handle multi-digit numbers", function () {
+    expect((0, _mathSeparator.mathSeparator)(1250)).toEqual([1000, 250]);
+  });
+
+  // 文字列型の数字のテスト
+  it("should handle single digit string numbers", function () {
+    expect((0, _mathSeparator.mathSeparator)("5")).toEqual([5, 0]);
+  });
+  it("should handle multi-digit string numbers", function () {
+    expect((0, _mathSeparator.mathSeparator)("1250")).toEqual([1000, 250]);
+  });
+
+  // 0および'0'のケース
+  it("should handle 0", function () {
+    expect((0, _mathSeparator.mathSeparator)(0)).toEqual([0, 0]);
+  });
+  it('should handle "0"', function () {
+    expect((0, _mathSeparator.mathSeparator)("0")).toEqual([0, 0]);
+  });
+
+  // 不正な値のケース
+  it("should return [0, 0] for non-number input", function () {
+    expect((0, _mathSeparator.mathSeparator)("abc")).toEqual([0, 0]);
+  });
+
+  // 小数のケース
+  it("should handle decimal numbers", function () {
+    expect((0, _mathSeparator.mathSeparator)(12.5)).toEqual([10, 2.5]);
+  });
+  it("should handle decimal string numbers", function () {
+    expect((0, _mathSeparator.mathSeparator)("12.5")).toEqual([10, 2.5]);
+  });
+});

package/module/es5/tests/unit/Math/max.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/max.test.js

@@ -0,0 +1,7 @@
+"use strict";
+
+var _max = require("@/Math/max");
+test("{max}", function () {
+  expect((0, _max.max)(1, 1)).toBe(1);
+  expect((0, _max.max)(1, 2)).toBe(2);
+});

package/module/es5/tests/unit/Math/median.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/median.test.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _median = require("@/Math/median");
+describe("median", function () {
+  it("偶数個の要素を持つ配列の中央値を計算する", function () {
+    expect((0, _median.median)([1, 2, 3, 4])).toBe(2.5);
+  });
+  it("奇数個の要素を持つ配列の中央値を計算する", function () {
+    expect((0, _median.median)([1, 3, 3, 6, 7, 8, 9])).toBe(6);
+  });
+  it("空の配列が与えられた場合はNaNを返す", function () {
+    expect((0, _median.median)([])).toBeNaN();
+  });
+  it("ソートされていない配列の中央値を計算する", function () {
+    expect((0, _median.median)([9, 1, 5, 3, 6])).toBe(5);
+  });
+});

package/module/es5/tests/unit/Math/min.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/min.test.js

@@ -0,0 +1,7 @@
+"use strict";
+
+var _min = require("@/Math/min");
+test("{min}", function () {
+  expect((0, _min.min)(1, 1)).toBe(1);
+  expect((0, _min.min)(1, 2)).toBe(1);
+});

package/module/es5/tests/unit/Math/multiples.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/multiples.test.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _multiples = require("@/Math/multiples");
+test("{multiples}", function () {
+  expect((0, _multiples.multiples)(1, 1)).toEqual([1]);
+  expect((0, _multiples.multiples)(1, 2)).toEqual([1, 2]);
+  expect((0, _multiples.multiples)(1, 3)).toEqual([1, 2, 3]);
+  expect((0, _multiples.multiples)(1, 4)).toEqual([1, 2, 3, 4]);
+  expect((0, _multiples.multiples)(1, 5)).toEqual([1, 2, 3, 4, 5]);
+  expect((0, _multiples.multiples)(1, 6)).toEqual([1, 2, 3, 4, 5, 6]);
+  expect((0, _multiples.multiples)(2, 1)).toEqual([2]);
+  expect((0, _multiples.multiples)(2, 2)).toEqual([2, 4]);
+  expect((0, _multiples.multiples)(2, 3)).toEqual([2, 4, 6]);
+});

package/module/es5/tests/unit/Math/multiplication.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/multiplication.test.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _multiplication = require("@/Math/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; }
+describe("multiplication", function () {
+  test.each([[[1, 1], 1], [[1, 2], 2], [[1.1, 2.2], 2.42], [[1, 2, 3], 6], [[2, 2, 2], 8], [[0.5, 2, 2], 2]])("multiplication(%s) equals %s", function (args, expected) {
+    expect(_multiplication.multiplication.apply(void 0, _toConsumableArray(args))).toBeCloseTo(expected);
+  });
+});

package/module/es5/tests/unit/Math/nCr.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/nCr.test.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _nCr = require("@/Math/nCr");
+describe("nCr function", function () {
+  // 正常系
+  test("calculate nCr for n=5, r=2", function () {
+    expect((0, _nCr.nCr)(5, 2)).toBe(10);
+  });
+  test("calculate nCr for n=10, r=4", function () {
+    expect((0, _nCr.nCr)(10, 4)).toBe(210);
+  });
+
+  // 異常系
+  test("return NaN when n or r is 0", function () {
+    expect((0, _nCr.nCr)(0, 5)).toBeNaN();
+    expect((0, _nCr.nCr)(5, 0)).toBeNaN();
+  });
+  test("return NaN when n < r", function () {
+    expect((0, _nCr.nCr)(2, 5)).toBeNaN();
+  });
+});

package/module/es5/tests/unit/Math/nHr.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/nHr.test.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _nHr = require("@/Math/nHr");
+describe("nHr function", function () {
+  // 正常系
+  test("calculate nHr for n=5, r=2", function () {
+    expect((0, _nHr.nHr)(5, 2)).toBe(15);
+  });
+  test("calculate nHr for n=3, r=3", function () {
+    expect((0, _nHr.nHr)(3, 3)).toBe(10);
+  });
+
+  // 異常系
+  test("return NaN when n or r is 0", function () {
+    expect((0, _nHr.nHr)(0, 5)).toBeNaN();
+    expect((0, _nHr.nHr)(5, 0)).toBeNaN();
+  });
+  test("return NaN when n or r is negative", function () {
+    expect((0, _nHr.nHr)(-1, 5)).toBeNaN();
+    expect((0, _nHr.nHr)(5, -1)).toBeNaN();
+  });
+});

package/module/es5/tests/unit/Math/nPr.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/nPr.test.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _nPr = require("@/Math/nPr");
+describe("nPr function", function () {
+  // 正常系
+  test("calculate nPr for n=5, r=2", function () {
+    expect((0, _nPr.nPr)(5, 2)).toBe(20);
+  });
+  test("calculate nPr for n=10, r=4", function () {
+    expect((0, _nPr.nPr)(10, 4)).toBe(5040);
+  });
+
+  // 異常系
+  test("return NaN when n or r is 0", function () {
+    expect((0, _nPr.nPr)(0, 5)).toBeNaN();
+    expect((0, _nPr.nPr)(5, 0)).toBeNaN();
+  });
+  test("return NaN when n < r", function () {
+    expect((0, _nPr.nPr)(2, 5)).toBeNaN();
+  });
+});

package/module/es5/tests/unit/Math/primeFactorization.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/primeFactorization.test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _primeFactorization = require("@/Math/primeFactorization");
+test("{primeFactorization}", function () {
+  var result = (0, _primeFactorization.primeFactorization)(100);
+  result.forEach(function (item) {
+    if (item.number === 2) {
+      expect(item.count).toBe(2);
+    } else if (item.number === 5) {
+      expect(item.count).toBe(2);
+    }
+  });
+});

package/module/es5/tests/unit/Math/quotient.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/quotient.test.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _quotient = require("@/Math/quotient");
+test("{quotient}", function () {
+  expect((0, _quotient.quotient)(1, 1)).toEqual([1, 0]);
+  expect((0, _quotient.quotient)(1, 2)).toEqual([0, 1]);
+  expect((0, _quotient.quotient)(2, 1)).toEqual([2, 0]);
+  expect((0, _quotient.quotient)(2, 2)).toEqual([1, 0]);
+  expect((0, _quotient.quotient)(2, 3)).toEqual([0, 2]);
+  expect((0, _quotient.quotient)(3, 1)).toEqual([3, 0]);
+  expect((0, _quotient.quotient)(3, 2)).toEqual([1, 1]);
+  expect((0, _quotient.quotient)(3, 3)).toEqual([1, 0]);
+  expect((0, _quotient.quotient)(3, 4)).toEqual([0, 3]);
+});

package/module/es5/tests/unit/Math/radToDeg.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/radToDeg.test.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _radToDeg = require("@/Math/radToDeg");
+describe("radToDeg", function () {
+  // 正常ケース
+  test("radToDeg: Normal Cases", function () {
+    expect((0, _radToDeg.radToDeg)(0)).toBe(0);
+    expect((0, _radToDeg.radToDeg)(Math.PI / 2)).toBe(90);
+    expect((0, _radToDeg.radToDeg)(Math.PI)).toBe(180);
+    expect((0, _radToDeg.radToDeg)(3 * Math.PI / 2)).toBe(270);
+    expect((0, _radToDeg.radToDeg)(2 * Math.PI)).toBe(360);
+  });
+
+  // 負の角度
+  test("radToDeg: Negative Angles", function () {
+    expect((0, _radToDeg.radToDeg)(-Math.PI / 2)).toBe(-90);
+    expect((0, _radToDeg.radToDeg)(-Math.PI)).toBe(-180);
+    expect((0, _radToDeg.radToDeg)(-3 * Math.PI / 2)).toBe(-270);
+    expect((0, _radToDeg.radToDeg)(-2 * Math.PI)).toBe(-360);
+  });
+
+  // 浮動小数点数の角度
+  test("radToDeg: Floating Point Angles", function () {
+    expect((0, _radToDeg.radToDeg)(Math.PI / 4)).toBeCloseTo(45);
+    expect((0, _radToDeg.radToDeg)(Math.PI * 60.7 / 180)).toBeCloseTo(60.7);
+    expect((0, _radToDeg.radToDeg)(Math.PI * 120.2 / 180)).toBeCloseTo(120.2);
+  });
+
+  // 2π以上の角度
+  test("radToDeg: Angles Greater Than 2π", function () {
+    expect((0, _radToDeg.radToDeg)(5 * Math.PI / 2)).toBeCloseTo(450);
+    expect((0, _radToDeg.radToDeg)(4 * Math.PI)).toBeCloseTo(720);
+    expect((0, _radToDeg.radToDeg)(6 * Math.PI)).toBeCloseTo(1080);
+  });
+
+  // NaNとInfinity
+  test("radToDeg: NaN and Infinity", function () {
+    expect((0, _radToDeg.radToDeg)(NaN)).toBe(NaN);
+    expect((0, _radToDeg.radToDeg)(Infinity)).toBe(Infinity);
+    expect((0, _radToDeg.radToDeg)(-Infinity)).toBe(-Infinity);
+  });
+
+  // 無効な入力
+  test("radToDeg: Invalid Inputs", function () {
+    expect((0, _radToDeg.radToDeg)("1.57")).toBeCloseTo(89.95);
+    expect((0, _radToDeg.radToDeg)([1.57])).toBeCloseTo(89.95);
+    expect((0, _radToDeg.radToDeg)({})).toBe(NaN);
+  });
+});

package/module/es5/tests/unit/Math/random.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/random.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _random = require("@/Math/random");
+describe("random関数のテスト", function () {
+  it("指定された範囲内の乱数を生成する", function () {
+    var min = 1;
+    var max = 10;
+    var result = (0, _random.random)(max, min);
+    expect(result).toBeGreaterThanOrEqual(min);
+    expect(result).toBeLessThanOrEqual(max);
+  });
+  it("最小値を指定しない場合は0を含む乱数を生成する", function () {
+    var max = 5;
+    var result = (0, _random.random)(max);
+    expect(result).toBeGreaterThanOrEqual(0);
+    expect(result).toBeLessThanOrEqual(max);
+  });
+  it("最大値と最小値が同じ場合はその値を返す", function () {
+    var value = 7;
+    var result = (0, _random.random)(value, value);
+    expect(result).toBe(value);
+  });
+});

package/module/es5/tests/unit/Math/reduce.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/reduce.test.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _reduce = require("@/Math/reduce");
+test("{reduce}", function () {
+  expect((0, _reduce.reduce)(16, 2)).toMatchObject({
+    x: 8,
+    y: 1,
+    gcd: 2
+  });
+  expect((0, _reduce.reduce)(0, 2)).toMatchObject({
+    x: NaN,
+    y: NaN
+  });
+});

package/module/es5/tests/unit/Math/repeatedTrial.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/repeatedTrial.test.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _repeatedTrial = require("@/Math/repeatedTrial");
+test("{repeatedTrial}", function () {
+  expect((0, _repeatedTrial.repeatedTrial)(4, 2, {
+    x: 1,
+    y: 3
+  })).toEqual([8, 27]);
+});

package/module/es5/tests/unit/Math/roundOf.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/roundOf.test.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _roundOf = require("@/Math/roundOf");
+test("{roundOf", function () {
+  expect((0, _roundOf.roundOf)(1.111111111111)).toBe(1);
+  expect((0, _roundOf.roundOf)(1.111111111111, 1)).toBe(1.1);
+  expect((0, _roundOf.roundOf)(1.111111111111, 2)).toBe(1.11);
+  expect((0, _roundOf.roundOf)(1.111111111111, 3)).toBe(1.111);
+  expect((0, _roundOf.roundOf)(1.111111111111, 4)).toBe(1.1111);
+  expect((0, _roundOf.roundOf)(1.111111111111, 5)).toBe(1.11111);
+  expect((0, _roundOf.roundOf)(1.111111111111, 6)).toBe(1.111111);
+  expect((0, _roundOf.roundOf)(1.111111111111, 7)).toBe(1.1111111);
+  expect((0, _roundOf.roundOf)(1.111111111111, 8)).toBe(1.11111111);
+  expect((0, _roundOf.roundOf)(1.555555555555, 2)).toBe(1.56);
+});

package/module/es5/tests/unit/Math/solveEquation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/solveEquation.test.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _solveEquation = require("@/Math/solveEquation");
+test("{solveEquation", function () {
+  expect((0, _solveEquation.solveEquation)(
+  /*
+  x + y = 4
+  x + 2y = 10
+  */
+  [[1, 1], [1, 2]], [4, 10])).toEqual([-2, 6]);
+  expect((0, _solveEquation.solveEquation)(
+  /*
+  x + 6y = 33
+  x + y = 8
+  */
+  [[1, 6], [1, 1]], [33, 8])).toEqual([3, 5]);
+  expect((0, _solveEquation.solveEquation)(
+  /*
+  5x-4y+6z=8
+  7x-6y+10z=14
+  4x+9y+7z=74
+  */
+  [[5, -4, 6], [7, -6, 10], [4, 9, 7]], [8, 14, 74])).toEqual([2, 5, 3]);
+});

package/module/es5/tests/unit/Math/standardDeviation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/standardDeviation.test.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var _standardDeviation = require("@/Math/standardDeviation");
+test("{standardDeviation}", function () {
+  expect((0, _standardDeviation.standardDeviation)([1, 2, 3, 4, 5])).toBe(1.4142135623730951);
+});

package/module/es5/tests/unit/Math/subtract.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/subtract.test.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _subtract = require("@/Math/subtract");
+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; }
+describe("subtract関数のテスト", function () {
+  test.each([{
+    a: [1, 1],
+    expected: 0
+  }, {
+    a: [1.1, 1],
+    expected: 0.1
+  }, {
+    a: [1, 1.1],
+    expected: -0.1
+  }, {
+    a: [1, 1, 1],
+    expected: -1
+  }, {
+    a: [5, 2, 1],
+    expected: 2
+  }, {
+    a: [10, 1, 1, 1],
+    expected: 7
+  }])("$a の引き算の結果が $expected", function (_ref) {
+    var a = _ref.a,
+      expected = _ref.expected;
+    expect(_subtract.subtract.apply(void 0, _toConsumableArray(a))).toBe(expected);
+  });
+});

package/module/es5/tests/unit/Math/toBaseN.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Math/toBaseN.test.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _toBaseN = require("@/Math/toBaseN");
+test("{toBaseN}", function () {
+  //2進数
+  expect((0, _toBaseN.toBaseN)(1)).toBe("1");
+  expect((0, _toBaseN.toBaseN)(2)).toBe("10");
+  expect((0, _toBaseN.toBaseN)(3)).toBe("11");
+  expect((0, _toBaseN.toBaseN)(4)).toBe("100");
+  expect((0, _toBaseN.toBaseN)(5)).toBe("101");
+  expect((0, _toBaseN.toBaseN)(6)).toBe("110");
+  expect((0, _toBaseN.toBaseN)(112)).toBe("1110000");
+  //4進数
+  expect((0, _toBaseN.toBaseN)(7, 4)).toBe("13");
+  expect((0, _toBaseN.toBaseN)(8, 4)).toBe("20");
+  expect((0, _toBaseN.toBaseN)(9, 4)).toBe("21");
+  expect((0, _toBaseN.toBaseN)(112, 4)).toBe("1300");
+  //8進数
+  expect((0, _toBaseN.toBaseN)(7, 8)).toBe("7");
+  expect((0, _toBaseN.toBaseN)(8, 8)).toBe("10");
+  expect((0, _toBaseN.toBaseN)(9, 8)).toBe("11");
+  expect((0, _toBaseN.toBaseN)(112, 8)).toBe("160");
+});

package/module/es5/tests/unit/Math/toCelsius.test.d.ts

@@ -0,0 +1 @@
+export {};