umt 1.8.2 → 2.0.0

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

@@ -0,0 +1,62 @@
+"use strict";
+
+var _bitwise = require("@/Math/bitwise");
+describe("bitwise", function () {
+  it("左に8ビット回転する", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 8);
+    expect(result.toString(16)).toBe("34567812");
+  });
+  it("左に16ビット回転する", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 16);
+    expect(result.toString(16)).toBe("56781234");
+  });
+  it("左に24ビット回転する", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 24);
+    expect(result.toString(16)).toBe("78123456");
+  });
+  it("左に32ビット回転する (元の値と同じ)", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 32);
+    expect(result.toString(16)).toBe("12345678");
+  });
+  it("左に0ビット回転する (元の値と同じ)", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 0);
+    expect(result.toString(16)).toBe("12345678");
+  });
+  it("負のビット数で回転する (右回転と同じ)", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, -8);
+    expect(result.toString(16)).toBe("78123456");
+  });
+  it("ビット数が32を超える場合 (32で割った余りのビット数で回転)", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 40); // 40 % 32 = 8
+    expect(result.toString(16)).toBe("34567812");
+  });
+  it("右に8ビット回転する", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 8, "right");
+    expect(result.toString(16)).toBe("78123456");
+  });
+  it("右に16ビット回転する", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 16, "right");
+    expect(result.toString(16)).toBe("56781234");
+  });
+  it("右に24ビット回転する", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 24, "right");
+    expect(result.toString(16)).toBe("34567812");
+  });
+  it("右に32ビット回転する (元の値と同じ)", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 32, "right");
+    expect(result.toString(16)).toBe("12345678");
+  });
+  it("右に0ビット回転する (元の値と同じ)", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 0, "right");
+    expect(result.toString(16)).toBe("12345678");
+  });
+  it("ビット数が32を超える場合 (32で割った余りのビット数で回転)", function () {
+    var result = (0, _bitwise.bitwise)(0x12345678, 40, "right"); // 40 % 32 = 8
+    expect(result.toString(16)).toBe("78123456");
+  });
+  it("不正な方向を指定する", function () {
+    expect(function () {
+      return (0, _bitwise.bitwise)(0x12345678, 8, "invalid");
+    }).toThrowError("Invalid direction");
+  });
+});

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

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

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

@@ -0,0 +1,76 @@
+"use strict";
+
+var _calculator = require("@/Math/calculator");
+describe("calculator", function () {
+  // 足し算
+  test("should handle addition", function () {
+    expect((0, _calculator.calculator)("1+")).toBe("1+");
+    expect((0, _calculator.calculator)("1+1")).toBe("2");
+    expect((0, _calculator.calculator)("1+1+1")).toBe("3");
+    expect((0, _calculator.calculator)("1+1+1+1")).toBe("4");
+    expect((0, _calculator.calculator)("1+1+1+1+1")).toBe("5");
+  });
+
+  // 引き算
+  test("should handle subtraction", function () {
+    expect((0, _calculator.calculator)("1-")).toBe("1-");
+    expect((0, _calculator.calculator)("1-1")).toBe("0");
+    expect((0, _calculator.calculator)("1-1-1")).toBe("-1");
+    expect((0, _calculator.calculator)("1-1-1-1")).toBe("-2");
+    expect((0, _calculator.calculator)("1-1-1-1-1")).toBe("-3");
+  });
+
+  // 掛け算
+  test("should handle multiplication", function () {
+    expect((0, _calculator.calculator)("2*")).toBe("2*");
+    expect((0, _calculator.calculator)("2*2")).toBe("4");
+    expect((0, _calculator.calculator)("2*2*2")).toBe("8");
+    expect((0, _calculator.calculator)("2*2*2*2")).toBe("16");
+    expect((0, _calculator.calculator)("2*2*2*2*2")).toBe("32");
+  });
+
+  // 割り算
+  test("should handle division", function () {
+    expect((0, _calculator.calculator)("2/")).toBe("2/");
+    expect((0, _calculator.calculator)("2/2")).toBe("1");
+    expect((0, _calculator.calculator)("2/2/2")).toBe("0.5");
+    expect((0, _calculator.calculator)("2/2/2/2")).toBe("0.25");
+    expect((0, _calculator.calculator)("2/2/2/2/2")).toBe("0.125");
+  });
+
+  // べき乗
+  test("should handle exponentiation", function () {
+    expect((0, _calculator.calculator)("2^")).toBe("2^");
+    expect((0, _calculator.calculator)("2^2")).toBe("4");
+    expect((0, _calculator.calculator)("2^2^2")).toBe("16");
+    expect((0, _calculator.calculator)("2^2^2^2")).toBe("65536");
+    expect((0, _calculator.calculator)("2^2^2^2^2")).toBe("Infinity");
+    expect((0, _calculator.calculator)("3^4")).toBe("81");
+    expect((0, _calculator.calculator)("3^4^2")).toBe("43046721");
+  });
+
+  // 括弧
+  test("should handle parentheses", function () {
+    expect((0, _calculator.calculator)("(1+1)")).toBe("2");
+    expect((0, _calculator.calculator)("(1")).toBe("(1");
+    expect((0, _calculator.calculator)("(1+")).toBe("(1+");
+    expect((0, _calculator.calculator)("1)")).toBe("1)");
+    expect((0, _calculator.calculator)("(1)")).toBe("(1)");
+    expect((0, _calculator.calculator)("(1+1)+(1+1)")).toBe("4");
+  });
+
+  // 方程式
+  test("should handle equations", function () {
+    expect((0, _calculator.calculator)("2x=(1+1)+(1+1)+(1+1)")).toBe("3");
+  });
+
+  // 変数
+  test("should handle variables", function () {
+    expect((0, _calculator.calculator)("$10*2", {
+      $: 100
+    })).toBe("2000");
+    expect((0, _calculator.calculator)("2*$10", {
+      $: 100
+    })).toBe("2000");
+  });
+});

package/module/es5/tests/unit/Math/calculator/calculatorInitialization.test.d.ts

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

package/module/es5/tests/unit/Math/calculator/calculatorInitialization.test.js

@@ -0,0 +1,10 @@
+"use strict";
+
+var _calculatorInitialization = require("@/Math/calculator/calculatorInitialization");
+test("calculatorInitialization", function () {
+  var calculator = (0, _calculatorInitialization.calculatorInitialization)({
+    $: 100
+  });
+  expect(calculator("$1")).toBe("100");
+  expect(calculator("100 + $1")).toBe("200");
+});

package/module/es5/tests/unit/Math/calculator/convertCurrency.test.d.ts

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

package/module/es5/tests/unit/Math/calculator/convertCurrency.test.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _convertCurrency = require("@/Math/calculator/convertCurrency");
+/**
+ * convertCurrency関数のテスト
+ */
+describe("convertCurrency", function () {
+  // ケース 1
+  test("conversionRatesが未定義", function () {
+    expect((0, _convertCurrency.convertCurrency)("¥1000")).toBe("¥1000");
+  });
+
+  // ケース 2
+  test("通貨記号がマッチしない", function () {
+    expect((0, _convertCurrency.convertCurrency)("¥1000", {
+      $: 1.1
+    })).toBe("¥1000");
+  });
+
+  // ケース 3
+  test("通貨記号がマッチし、換算レートが数値", function () {
+    expect((0, _convertCurrency.convertCurrency)("¥1000", {
+      "¥": 1.1
+    })).toBe("1100");
+  });
+
+  // ケース 4
+  test("通貨記号がマッチし、換算レートが数値でない", function () {
+    expect((0, _convertCurrency.convertCurrency)("¥1000", {
+      "¥": "invalid"
+    })).toBe("¥1000");
+  });
+
+  // ケース 5
+  test("換算結果がNaN", function () {
+    expect((0, _convertCurrency.convertCurrency)("¥NaN", {
+      "¥": 1.1
+    })).toBe("¥NaN");
+  });
+});

package/module/es5/tests/unit/Math/calculator/literalExpression.test.d.ts

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

package/module/es5/tests/unit/Math/calculator/literalExpression.test.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _literalExpression = require("@/Math/calculator/literalExpression");
+describe("literalExpression", function () {
+  // 基本的な方程式
+  test("should handle basic equations", function () {
+    expect((0, _literalExpression.literalExpression)("x=1")).toBe("1");
+    expect((0, _literalExpression.literalExpression)("x=0")).toBe("0");
+    expect((0, _literalExpression.literalExpression)("x=-1")).toBe("-1");
+  });
+
+  // 基本的な方程式(右辺)
+  test("should handle basic equations (right side)", function () {
+    expect((0, _literalExpression.literalExpression)("1=x")).toBe("1");
+    expect((0, _literalExpression.literalExpression)("0=x")).toBe("0");
+    expect((0, _literalExpression.literalExpression)("-1=x")).toBe("-1");
+  });
+
+  // 数値と変数が混在
+  test("should handle equations with mixed numerical and variable parts", function () {
+    expect((0, _literalExpression.literalExpression)("2x=4")).toBe("2");
+    expect((0, _literalExpression.literalExpression)("1x=1")).toBe("1");
+    expect((0, _literalExpression.literalExpression)("3x=-6")).toBe("-2");
+    expect((0, _literalExpression.literalExpression)("2x+2=4")).toBe("1");
+    expect((0, _literalExpression.literalExpression)("3x-2=-6")).toBe("-4/3");
+  });
+
+  // 数値と変数が混在(右辺)
+  test("should handle equations with mixed numerical and variable parts (right side)", function () {
+    expect((0, _literalExpression.literalExpression)("4=2x")).toBe("2");
+    expect((0, _literalExpression.literalExpression)("1=1x")).toBe("1");
+    expect((0, _literalExpression.literalExpression)("-6=3x")).toBe("-2");
+    expect((0, _literalExpression.literalExpression)("4=2x+2")).toBe("1");
+    expect((0, _literalExpression.literalExpression)("-6=3x-2")).toBe("-4/3");
+  });
+
+  // 最大公約数が1より大きい場合
+  test("should simplify when gcd is greater than 1", function () {
+    expect((0, _literalExpression.literalExpression)("2x=8")).toBe("4");
+  });
+
+  // 最大公約数が1より大きい場合(右辺)
+  test("should simplify when gcd is greater than 1 (right side)", function () {
+    expect((0, _literalExpression.literalExpression)("8=2x")).toBe("4");
+  });
+
+  // 無効な方程式
+  test("should handle invalid equations", function () {
+    expect((0, _literalExpression.literalExpression)("x=x")).toBe("");
+  });
+});

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

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

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

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

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+
+var _deviationValue = require("@/Math/deviationValue");
+// 偏差値の計算に関するテスト
+describe("deviationValue", function () {
+  // 正常な入力値でのテスト
+  test("正常な入力値", function () {
+    expect((0, _deviationValue.deviationValue)(100, 50, 10)).toBe(100);
+  });
+
+  // 平均値と同じ値でのテスト
+  test("平均値と同じ値", function () {
+    expect((0, _deviationValue.deviationValue)(50, 50, 10)).toBe(50);
+  });
+
+  // 標準偏差が0のケース（例外処理が必要な場合）
+  test("標準偏差が0", function () {
+    expect((0, _deviationValue.deviationValue)(100, 50, 0)).toBe(Infinity);
+  });
+
+  // 負の値を含むケース
+  test("負の値を含む", function () {
+    expect((0, _deviationValue.deviationValue)(-20, 0, 20)).toBe(40);
+  });
+
+  // 浮動小数点数を含むケース
+  test("浮動小数点数を含む", function () {
+    expect((0, _deviationValue.deviationValue)(55.5, 50, 10)).toBeCloseTo(55.5);
+  });
+});

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

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

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

@@ -0,0 +1,34 @@
+"use strict";
+
+var _division = require("@/Math/division");
+describe("division function", function () {
+  // 整数に対するテスト
+  it("should return the correct division for integers", function () {
+    expect((0, _division.division)(10, 2)).toBe(5);
+    expect((0, _division.division)(30, 5)).toBe(6);
+  });
+
+  // isFloor=true の場合
+  it("should return floored division if isFloor is true", function () {
+    expect((0, _division.division)(7, 2, true)).toBe(3.5);
+    expect((0, _division.division)(3, 5, true)).toBe(0.6);
+  });
+
+  // isFloor=false の場合
+  it("should return division and remainder if isFloor is false", function () {
+    expect((0, _division.division)(10, 3, false)).toEqual([3, 1]);
+    expect((0, _division.division)(7, 2, false)).toEqual([3, 1]);
+    expect((0, _division.division)(3, 5, false)).toEqual([0, 3]);
+  });
+
+  // 小数に対するテスト
+  it("should handle decimals correctly", function () {
+    expect((0, _division.division)(10.5, 2.1)).toBe(5);
+  });
+
+  // 精度チェック
+  it("should handle precision correctly", function () {
+    expect((0, _division.division)(0.1, 0.2)).toBeCloseTo(0.5);
+    expect((0, _division.division)(-0.16, 0.2)).toBeCloseTo(-0.8);
+  });
+});

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+
+var _factorial = require("@/Math/factorial");
+describe("factorial", function () {
+  test("0の階乗は1を返す", function () {
+    expect((0, _factorial.factorial)(0)).toBe(1);
+  });
+  test("1の階乗は1を返す", function () {
+    expect((0, _factorial.factorial)(1)).toBe(1);
+  });
+  test("正の整数の階乗を正しく計算する", function () {
+    expect((0, _factorial.factorial)(2)).toBe(2);
+    expect((0, _factorial.factorial)(3)).toBe(6);
+    expect((0, _factorial.factorial)(4)).toBe(24);
+    expect((0, _factorial.factorial)(5)).toBe(120);
+    expect((0, _factorial.factorial)(6)).toBe(720);
+    expect((0, _factorial.factorial)(7)).toBe(5040);
+    expect((0, _factorial.factorial)(8)).toBe(40320);
+    expect((0, _factorial.factorial)(9)).toBe(362880);
+    expect((0, _factorial.factorial)(10)).toBe(3628800);
+  });
+  test("負の数を渡すと1を返す", function () {
+    expect((0, _factorial.factorial)(-1)).toBe(1);
+    expect((0, _factorial.factorial)(-5)).toBe(1);
+  });
+});

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+
+var _factorize = require("@/Math/factorize");
+test("{factorize}", function () {
+  expect((0, _factorize.factorize)(12)).toEqual([2, 2, 3]);
+  expect((0, _factorize.factorize)(14)).toEqual([2, 7]);
+  expect((0, _factorize.factorize)(15)).toEqual([3, 5]);
+  expect((0, _factorize.factorize)(16)).toEqual([2, 2, 2, 2]);
+  expect((0, _factorize.factorize)(17)).toEqual([17]);
+  expect((0, _factorize.factorize)(18)).toEqual([2, 3, 3]);
+  expect((0, _factorize.factorize)(19)).toEqual([19]);
+  expect((0, _factorize.factorize)(20)).toEqual([2, 2, 5]);
+});

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

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

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

@@ -0,0 +1,195 @@
+"use strict";
+
+var _flexibleNumberConversion = require("@/Math/flexibleNumberConversion");
+describe("flexibleNumberConversion", function () {
+  // 基本的な数値入力
+  describe("基本的な数値入力", function () {
+    test("正の整数をそのまま返す", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(123)).toBe(123);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(456)).toBe(456);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(789)).toBe(789);
+    });
+    test("負の整数をそのまま返す", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-123)).toBe(-123);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-456)).toBe(-456);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-789)).toBe(-789);
+    });
+    test("ゼロをそのまま返す", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(0)).toBe(0);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-0)).toBe(-0);
+    });
+  });
+
+  // 文字列としての数値入力
+  describe("文字列としての数値入力", function () {
+    test("正の整数の文字列を適切に変換する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("123")).toBe(123);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("456")).toBe(456);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("789")).toBe(789);
+    });
+    test("負の整数の文字列を適切に変換する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-123")).toBe(-123);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-456")).toBe(-456);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-789")).toBe(-789);
+    });
+    test("小数の文字列を適切に変換する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("3.14")).toBe(3.14);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-2.718")).toBe(-2.718);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0.001")).toBe(0.001);
+    });
+    test("指数表記の文字列を正しく解釈する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e3")).toBe(1000);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-2.5e-3")).toBe(-0.0025);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("6.022e23")).toBe(6.022e23);
+    });
+    test("特殊な基数表記の文字列を正しく解釈する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0x1A")).toBe(26);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0b1011")).toBe(11);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0o77")).toBe(63);
+    });
+    test("数値の前後にスペースがある文字列を適切に変換する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(" 123 ")).toBe(123);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("   -456")).toBe(-456);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("789   ")).toBe(789);
+    });
+    test("プラス符号のみの文字列を処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+")).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+123")).toBe(123);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+0")).toBe(0);
+    });
+    test("無効な指数表記を持つ文字列を処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e")).toBe(1);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("e10")).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("2e+")).toBe(2);
+    });
+    test("小数点のみの文字列を処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(".")).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-.")).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(".e1")).toBe(NaN);
+    });
+    test("数値で始まらない文字列を処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("px42")).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("meter3.14")).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc123")).toBe(NaN);
+    });
+  });
+
+  // 特殊な数値入力
+  describe("特殊な数値入力", function () {
+    test("Infinityを適切に処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("Infinity")).toBe(Infinity);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-Infinity")).toBe(-Infinity);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Infinity)).toBe(Infinity);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(-Infinity)).toBe(-Infinity);
+    });
+    test("NaNの入力を処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(NaN)).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("NaN")).toBe(NaN);
+    });
+    test("非常に大きな数値を適切に処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("9007199254740991")).toBe(9007199254740991);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e308")).toBe(1e308);
+    });
+    test("非常に小さな数値を適切に処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MIN_VALUE)).toBe(Number.MIN_VALUE);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("5e-324")).toBe(5e-324);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-1e-308")).toBe(-1e-308);
+    });
+  });
+
+  // 無効または特殊な入力
+  describe("無効または特殊な入力", function () {
+    test("空文字列、null、undefinedを0として扱う", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("")).toBe(0);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(null)).toBe(0);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(undefined)).toBe(0);
+    });
+    test("無効な文字列をNaNとして返す", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("not a number")).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc")).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("abc123")).toBe(NaN);
+    });
+    test("オブジェクトや配列をNaNとして返す", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)({})).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)({
+        key: "value"
+      })).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)([])).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)([1, 2, 3])).toBe(NaN);
+    });
+    test("関数をNaNとして返す", function () {
+      var func = function func() {};
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(func)).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(function () {})).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(function () {})).toBe(NaN);
+    });
+    test("特殊文字を含む文字列をNaNとして返す", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("@123")).toBe(NaN);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("!@#$%")).toBe(NaN);
+    });
+  });
+
+  // 複雑なケース
+  describe("複雑なケース", function () {
+    test("数値と文字が混在する文字列の先頭を数値として抽出する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("42px")).toBe(42);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-42px")).toBe(-42);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("3.14meters")).toBe(3.14);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-3.14meters")).toBe(-3.14);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e10meters")).toBe(1e10);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-1e10meters")).toBe(-1e10);
+    });
+    test("内部にスペースが含まれる文字列を適切に処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(" 123 456 ")).toBe(123);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(" -456px ")).toBe(-456);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("3.14 meters")).toBe(3.14);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1e2 meters")).toBe(100);
+    });
+    test("先頭にゼロが付く数値を適切に処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("0123")).toBe(123);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-0456")).toBe(-456);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("000789")).toBe(789);
+    });
+    test("先頭にプラス符号が付く数値を適切に処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+123")).toBe(123);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+0")).toBe(0);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+3.14")).toBe(3.14);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("+1e10")).toBe(1e10);
+    });
+  });
+
+  // パフォーマンスとストレステスト
+  describe("パフォーマンスとストレステスト", function () {
+    test("大量の連続した有効な入力を処理する", function () {
+      for (var i = 0; i < 1000; i++) {
+        expect((0, _flexibleNumberConversion.flexibleNumberConversion)(i.toString())).toBe(i);
+      }
+    });
+    test("大量の連続した無効な入力を処理する", function () {
+      for (var i = 0; i < 1000; i++) {
+        expect((0, _flexibleNumberConversion.flexibleNumberConversion)("invalid".concat(i))).toBe(NaN);
+      }
+    });
+  });
+
+  // 境界値テスト
+  describe("境界値テスト", function () {
+    test("Number.MAX_VALUEを処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MAX_VALUE)).toBe(Number.MAX_VALUE);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("1.7976931348623157e+308")).toBe(Number.MAX_VALUE);
+    });
+    test("Number.MIN_VALUEを処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MIN_VALUE)).toBe(Number.MIN_VALUE);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("5e-324")).toBe(Number.MIN_VALUE);
+    });
+    test("Number.MAX_SAFE_INTEGERを処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("9007199254740991")).toBe(Number.MAX_SAFE_INTEGER);
+    });
+    test("Number.MIN_SAFE_INTEGERを処理する", function () {
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)(Number.MIN_SAFE_INTEGER)).toBe(Number.MIN_SAFE_INTEGER);
+      expect((0, _flexibleNumberConversion.flexibleNumberConversion)("-9007199254740991")).toBe(Number.MIN_SAFE_INTEGER);
+    });
+  });
+});

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

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