umt 2.3.0 → 2.4.0

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

@@ -1,25 +0,0 @@
-"use strict";
-
-var _linearCongruentialGenerator = require("@/Math/linearCongruentialGenerator");
-describe("linearCongruentialGenerator", function () {
-  it("should generate random numbers", function () {
-    var result = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(8, 13, 3, 5);
-    expect(result).toBeGreaterThanOrEqual(0);
-    expect(result).toBe(3);
-  });
-  it("should generate the same sequence for the same seed", function () {
-    var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
-    var result2 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
-    expect(result1).toBe(result2);
-  });
-  it("should generate different sequences for different seeds", function () {
-    var result1 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(12345);
-    var result2 = (0, _linearCongruentialGenerator.linearCongruentialGenerator)(54321);
-    expect(result1).not.toBe(result2);
-  });
-  it("should generate numbers with custom parameters", 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

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

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

@@ -1,37 +0,0 @@
-"use strict";
-
-var _mathConverter = require("@/Math/mathConverter");
-describe("mathConverter function", function () {
-  // Test multiplication conversion
-  test("should convert multiplication", 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 exponentiation conversion
-  test("should convert exponentiation", 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 cases where no conversion is needed
-  test("should not convert when unnecessary", function () {
-    expect((0, _mathConverter.mathConverter)("1250")).toBe("1250");
-  });
-
-  // Test cases with multiple operands
-  test("should handle multiple operands", function () {
-    expect((0, _mathConverter.mathConverter)("1250+1250")).toBe("1250+1250");
-  });
-
-  // Test invalid inputs
-  test("should handle invalid input", function () {
-    expect((0, _mathConverter.mathConverter)("abc")).toBe("abc");
-  });
-
-  // Test when primary value is missing
-  test("should handle missing primary value", function () {
-    expect((0, _mathConverter.mathConverter)("0*0")).toBe("0*0");
-  });
-});

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

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

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

@@ -1,59 +0,0 @@
-"use strict";
-
-var _mathSeparator = require("@/Math/mathSeparator");
-describe("mathSeparator", function () {
-  // Test number type inputs
-  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]);
-  });
-
-  // Test string number inputs
-  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]);
-  });
-
-  // Test zero cases
-  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]);
-  });
-
-  // Test invalid inputs
-  it("should return [0, 0] for non-number input", function () {
-    expect((0, _mathSeparator.mathSeparator)("abc")).toEqual([0, 0]);
-  });
-
-  // Test decimal numbers
-  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]);
-  });
-
-  // Test edge cases
-  it("should handle negative numbers", function () {
-    expect((0, _mathSeparator.mathSeparator)(-1250)).toEqual([10000, -11250]);
-    expect((0, _mathSeparator.mathSeparator)("-1250.5")).toEqual([10000, -11249.5]);
-  });
-  it("should handle very large numbers", function () {
-    expect((0, _mathSeparator.mathSeparator)(1000000)).toEqual([1000000, 0]);
-    expect((0, _mathSeparator.mathSeparator)("1000000.123")).toEqual([1000000, 0.123]);
-  });
-  it("should handle special numeric strings", function () {
-    // Note: "1e5" is treated as a regular string "1e5"
-    expect((0, _mathSeparator.mathSeparator)("1e5")).toEqual([100, 99900]);
-    // Note: isNumber treats "0xFF" as a valid number, so it's processed accordingly
-    expect((0, _mathSeparator.mathSeparator)("0xFF")).toEqual([1000, -745]);
-    // Note: "Infinity" is not a valid number in this context
-    expect((0, _mathSeparator.mathSeparator)("Infinity")).toEqual([0, 0]);
-  });
-});

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

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

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

@@ -1,22 +0,0 @@
-"use strict";
-
-var _max = require("@/Math/max");
-describe("max function", function () {
-  it("should return the maximum value", function () {
-    expect((0, _max.max)(1, 2, 3)).toBe(3);
-    expect((0, _max.max)(3, 2, 1)).toBe(3);
-    expect((0, _max.max)(-1, -2, -3)).toBe(-1);
-  });
-  it("should remove duplicates before finding maximum", function () {
-    expect((0, _max.max)(1, 1, 1)).toBe(1);
-    expect((0, _max.max)(1, 2, 2, 3, 3)).toBe(3);
-  });
-  it("should handle single value", function () {
-    expect((0, _max.max)(5)).toBe(5);
-    expect((0, _max.max)(-5)).toBe(-5);
-  });
-  it("should handle decimal numbers", function () {
-    expect((0, _max.max)(1.5, 2.5, 1.1)).toBe(2.5);
-    expect((0, _max.max)(-1.5, -2.5, -1.1)).toBe(-1.1);
-  });
-});

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

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

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

@@ -1,17 +0,0 @@
-"use strict";
-
-var _median = require("@/Math/median");
-describe("median", function () {
-  it("should calculate median of array with even number of elements", function () {
-    expect((0, _median.median)([1, 2, 3, 4])).toBe(2.5);
-  });
-  it("should calculate median of array with odd number of elements", function () {
-    expect((0, _median.median)([1, 3, 3, 6, 7, 8, 9])).toBe(6);
-  });
-  it("should return NaN for empty array", function () {
-    expect((0, _median.median)([])).toBeNaN();
-  });
-  it("should calculate median of unsorted array", function () {
-    expect((0, _median.median)([9, 1, 5, 3, 6])).toBe(5);
-  });
-});

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

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

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

@@ -1,22 +0,0 @@
-"use strict";
-
-var _min = require("@/Math/min");
-describe("min function", function () {
-  it("should return the minimum value", function () {
-    expect((0, _min.min)(1, 2, 3)).toBe(1);
-    expect((0, _min.min)(3, 2, 1)).toBe(1);
-    expect((0, _min.min)(-1, -2, -3)).toBe(-3);
-  });
-  it("should remove duplicates before finding minimum", function () {
-    expect((0, _min.min)(1, 1, 1)).toBe(1);
-    expect((0, _min.min)(1, 2, 2, 3, 3)).toBe(1);
-  });
-  it("should handle single value", function () {
-    expect((0, _min.min)(5)).toBe(5);
-    expect((0, _min.min)(-5)).toBe(-5);
-  });
-  it("should handle decimal numbers", function () {
-    expect((0, _min.min)(1.5, 2.5, 1.1)).toBe(1.1);
-    expect((0, _min.min)(-1.5, -2.5, -1.1)).toBe(-2.5);
-  });
-});

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

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

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

@@ -1,30 +0,0 @@
-"use strict";
-
-var _multiples = require("@/Math/multiples");
-describe("multiples function", function () {
-  it("should generate multiples of 1", function () {
-    expect((0, _multiples.multiples)(1, 1)).toEqual([1]);
-    expect((0, _multiples.multiples)(1, 3)).toEqual([1, 2, 3]);
-    expect((0, _multiples.multiples)(1, 5)).toEqual([1, 2, 3, 4, 5]);
-  });
-  it("should generate multiples of 2", function () {
-    expect((0, _multiples.multiples)(2, 1)).toEqual([2]);
-    expect((0, _multiples.multiples)(2, 3)).toEqual([2, 4, 6]);
-    expect((0, _multiples.multiples)(2, 5)).toEqual([2, 4, 6, 8, 10]);
-  });
-  it("should generate multiples of negative numbers", function () {
-    expect((0, _multiples.multiples)(-2, 3)).toEqual([-2, -4, -6]);
-    expect((0, _multiples.multiples)(-3, 4)).toEqual([-3, -6, -9, -12]);
-  });
-  it("should handle zero as base number", function () {
-    expect((0, _multiples.multiples)(0, 3)).toEqual([0, 0, 0]);
-  });
-  it("should return empty array for zero count", function () {
-    expect((0, _multiples.multiples)(2, 0)).toEqual([]);
-    expect((0, _multiples.multiples)(-2, 0)).toEqual([]);
-  });
-  it("should handle decimal numbers", function () {
-    expect((0, _multiples.multiples)(0.5, 3)).toEqual([0.5, 1, 1.5]);
-    expect((0, _multiples.multiples)(1.5, 3)).toEqual([1.5, 3, 4.5]);
-  });
-});

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

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

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

@@ -1,48 +0,0 @@
-"use strict";
-
-var _multiplication = require("@/Math/multiplication");
-describe("multiplication function", function () {
-  describe("basic integer multiplication", function () {
-    it("should multiply two positive integers", function () {
-      expect((0, _multiplication.multiplication)(2, 3)).toBe(6);
-      expect((0, _multiplication.multiplication)(10, 20)).toBe(200);
-    });
-    it("should multiply multiple positive integers", function () {
-      expect((0, _multiplication.multiplication)(2, 3, 4)).toBe(24);
-      expect((0, _multiplication.multiplication)(1, 2, 3, 4, 5)).toBe(120);
-    });
-  });
-  describe("decimal number multiplication", function () {
-    it("should handle decimal multiplication without floating point errors", function () {
-      expect((0, _multiplication.multiplication)(0.1, 0.2)).toBeCloseTo(0.02);
-      expect((0, _multiplication.multiplication)(0.1, 0.2, 0.3)).toBeCloseTo(0.006);
-      expect((0, _multiplication.multiplication)(1.23, 4.56)).toBeCloseTo(5.6088);
-    });
-    it("should handle mixed integer and decimal multiplication", function () {
-      expect((0, _multiplication.multiplication)(0.5, 2)).toBe(1);
-      expect((0, _multiplication.multiplication)(0.1, 10)).toBe(1);
-      expect((0, _multiplication.multiplication)(1.5, 2, 3)).toBe(9);
-    });
-  });
-  describe("edge cases", function () {
-    it("should handle negative numbers", function () {
-      expect((0, _multiplication.multiplication)(-2, 3)).toBe(-6);
-      expect((0, _multiplication.multiplication)(2, -3)).toBe(-6);
-      expect((0, _multiplication.multiplication)(-2, -3)).toBe(6);
-    });
-    it("should handle zero", function () {
-      expect((0, _multiplication.multiplication)(0, 5)).toBe(0);
-      expect((0, _multiplication.multiplication)(5, 0)).toBe(0);
-      expect((0, _multiplication.multiplication)(0, 0)).toBe(0);
-    });
-    it("should handle multiplication by one", function () {
-      expect((0, _multiplication.multiplication)(1, 5)).toBe(5);
-      expect((0, _multiplication.multiplication)(5, 1)).toBe(5);
-      expect((0, _multiplication.multiplication)(1, 1)).toBe(1);
-    });
-    it("should handle very small numbers", function () {
-      expect((0, _multiplication.multiplication)(0.0001, 0.0001)).toBeCloseTo(0.00000001);
-      expect((0, _multiplication.multiplication)(0.00001, 0.00001)).toBeCloseTo(0.0000000001);
-    });
-  });
-});

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

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

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

@@ -1,34 +0,0 @@
-"use strict";
-
-var _nCr = require("@/Math/nCr");
-describe("nCr function", function () {
-  describe("valid combinations", function () {
-    it("should calculate basic combinations correctly", function () {
-      expect((0, _nCr.nCr)(5, 2)).toBe(10); // 5C2 = 10
-      expect((0, _nCr.nCr)(10, 4)).toBe(210); // 10C4 = 210
-    });
-    it("should handle choosing all items", function () {
-      expect((0, _nCr.nCr)(3, 3)).toBe(1); // 3C3 = 1
-      expect((0, _nCr.nCr)(5, 5)).toBe(1); // 5C5 = 1
-    });
-    it("should handle choosing one item", function () {
-      expect((0, _nCr.nCr)(5, 1)).toBe(5); // 5C1 = 5
-      expect((0, _nCr.nCr)(10, 1)).toBe(10); // 10C1 = 10
-    });
-    it("should calculate larger combinations", function () {
-      expect((0, _nCr.nCr)(20, 10)).toBe(184756); // 20C10 = 184,756
-      expect((0, _nCr.nCr)(15, 7)).toBe(6435); // 15C7 = 6,435
-    });
-  });
-  describe("edge cases", function () {
-    it("should return NaN when n or r is 0", function () {
-      expect((0, _nCr.nCr)(0, 5)).toBeNaN();
-      expect((0, _nCr.nCr)(5, 0)).toBeNaN();
-      expect((0, _nCr.nCr)(0, 0)).toBeNaN();
-    });
-    it("should return NaN when n is less than r", function () {
-      expect((0, _nCr.nCr)(2, 5)).toBeNaN();
-      expect((0, _nCr.nCr)(3, 4)).toBeNaN();
-    });
-  });
-});

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

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

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

@@ -1,35 +0,0 @@
-"use strict";
-
-var _nHr = require("@/Math/nHr");
-describe("nHr function", function () {
-  describe("valid combinations with repetition", function () {
-    it("should calculate basic combinations with repetition correctly", function () {
-      expect((0, _nHr.nHr)(5, 2)).toBe(15); // 5H2 = 15
-      expect((0, _nHr.nHr)(3, 3)).toBe(10); // 3H3 = 10
-    });
-    it("should handle choosing one item", function () {
-      expect((0, _nHr.nHr)(3, 1)).toBe(3); // 3H1 = 3
-      expect((0, _nHr.nHr)(5, 1)).toBe(5); // 5H1 = 5
-    });
-    it("should handle choosing same as total items", function () {
-      expect((0, _nHr.nHr)(2, 2)).toBe(3); // 2H2 = 3
-      expect((0, _nHr.nHr)(4, 4)).toBe(35); // 4H4 = 35
-    });
-    it("should handle larger combinations", function () {
-      expect((0, _nHr.nHr)(10, 3)).toBe(220); // 10H3 = 220
-      expect((0, _nHr.nHr)(6, 4)).toBe(126); // 6H4 = 126
-    });
-  });
-  describe("edge cases", function () {
-    it("should return NaN when n or r is 0", function () {
-      expect((0, _nHr.nHr)(0, 5)).toBeNaN();
-      expect((0, _nHr.nHr)(5, 0)).toBeNaN();
-      expect((0, _nHr.nHr)(0, 0)).toBeNaN();
-    });
-    it("should return NaN when n or r is negative", function () {
-      expect((0, _nHr.nHr)(-1, 5)).toBeNaN();
-      expect((0, _nHr.nHr)(5, -1)).toBeNaN();
-      expect((0, _nHr.nHr)(-1, -1)).toBeNaN();
-    });
-  });
-});

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

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

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

@@ -1,38 +0,0 @@
-"use strict";
-
-var _nPr = require("@/Math/nPr");
-describe("nPr function", function () {
-  describe("valid permutations", function () {
-    it("should calculate basic permutations correctly", function () {
-      expect((0, _nPr.nPr)(5, 2)).toBe(20); // 5P2 = 20
-      expect((0, _nPr.nPr)(10, 4)).toBe(5040); // 10P4 = 5040
-    });
-    it("should handle choosing one item", function () {
-      expect((0, _nPr.nPr)(3, 1)).toBe(3); // 3P1 = 3
-      expect((0, _nPr.nPr)(5, 1)).toBe(5); // 5P1 = 5
-    });
-    it("should handle choosing all items", function () {
-      expect((0, _nPr.nPr)(3, 3)).toBe(6); // 3P3 = 6 (factorial of 3)
-      expect((0, _nPr.nPr)(4, 4)).toBe(24); // 4P4 = 24 (factorial of 4)
-    });
-    it("should handle larger permutations", function () {
-      expect((0, _nPr.nPr)(8, 3)).toBe(336); // 8P3 = 336
-      expect((0, _nPr.nPr)(6, 4)).toBe(360); // 6P4 = 360
-    });
-  });
-  describe("edge cases", function () {
-    it("should return NaN when n or r is 0", function () {
-      expect((0, _nPr.nPr)(0, 5)).toBeNaN();
-      expect((0, _nPr.nPr)(5, 0)).toBeNaN();
-      expect((0, _nPr.nPr)(0, 0)).toBeNaN();
-    });
-    it("should return NaN when n is less than r", function () {
-      expect((0, _nPr.nPr)(2, 5)).toBeNaN();
-      expect((0, _nPr.nPr)(3, 4)).toBeNaN();
-    });
-    it("should calculate correctly when n equals r", function () {
-      expect((0, _nPr.nPr)(2, 2)).toBe(2); // 2P2 = 2
-      expect((0, _nPr.nPr)(5, 5)).toBe(120); // 5P5 = 120
-    });
-  });
-});

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

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

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

@@ -1,84 +0,0 @@
-"use strict";
-
-var _primeFactorization = require("@/Math/primeFactorization");
-describe("primeFactorization function", function () {
-  describe("basic prime factorization", function () {
-    it("should factorize numbers with single prime factor", function () {
-      expect((0, _primeFactorization.primeFactorization)(8)).toEqual([{
-        number: 2,
-        count: 3
-      }]);
-      expect((0, _primeFactorization.primeFactorization)(27)).toEqual([{
-        number: 3,
-        count: 3
-      }]);
-    });
-    it("should factorize numbers with multiple prime factors", function () {
-      expect((0, _primeFactorization.primeFactorization)(12)).toEqual([{
-        number: 2,
-        count: 2
-      }, {
-        number: 3,
-        count: 1
-      }]);
-      expect((0, _primeFactorization.primeFactorization)(100)).toEqual([{
-        number: 2,
-        count: 2
-      }, {
-        number: 5,
-        count: 2
-      }]);
-    });
-    it("should handle prime numbers", function () {
-      expect((0, _primeFactorization.primeFactorization)(2)).toEqual([{
-        number: 2,
-        count: 1
-      }]);
-      expect((0, _primeFactorization.primeFactorization)(17)).toEqual([{
-        number: 17,
-        count: 1
-      }]);
-      expect((0, _primeFactorization.primeFactorization)(31)).toEqual([{
-        number: 31,
-        count: 1
-      }]);
-    });
-  });
-  describe("edge cases", function () {
-    it("should handle perfect squares", function () {
-      expect((0, _primeFactorization.primeFactorization)(25)).toEqual([{
-        number: 5,
-        count: 2
-      }]);
-      expect((0, _primeFactorization.primeFactorization)(49)).toEqual([{
-        number: 7,
-        count: 2
-      }]);
-    });
-    it("should handle numbers with large prime factors", function () {
-      expect((0, _primeFactorization.primeFactorization)(997)).toEqual([{
-        number: 997,
-        count: 1
-      }]);
-      expect((0, _primeFactorization.primeFactorization)(998)).toEqual([{
-        number: 2,
-        count: 1
-      }, {
-        number: 499,
-        count: 1
-      }]);
-    });
-    it("should handle consecutive prime factors", function () {
-      expect((0, _primeFactorization.primeFactorization)(30)).toEqual([{
-        number: 2,
-        count: 1
-      }, {
-        number: 3,
-        count: 1
-      }, {
-        number: 5,
-        count: 1
-      }]);
-    });
-  });
-});

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

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

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

@@ -1,36 +0,0 @@
-"use strict";
-
-var _quotient = require("@/Math/quotient");
-describe("quotient function", function () {
-  describe("basic division", function () {
-    it("should handle exact division (no remainder)", function () {
-      expect((0, _quotient.quotient)(4, 2)).toEqual([2, 0]);
-      expect((0, _quotient.quotient)(10, 5)).toEqual([2, 0]);
-      expect((0, _quotient.quotient)(100, 10)).toEqual([10, 0]);
-    });
-    it("should handle division with remainder", function () {
-      expect((0, _quotient.quotient)(5, 2)).toEqual([2, 1]);
-      expect((0, _quotient.quotient)(7, 3)).toEqual([2, 1]);
-      expect((0, _quotient.quotient)(10, 3)).toEqual([3, 1]);
-    });
-  });
-  describe("edge cases", function () {
-    it("should handle division by 1", function () {
-      expect((0, _quotient.quotient)(5, 1)).toEqual([5, 0]);
-      expect((0, _quotient.quotient)(0, 1)).toEqual([0, 0]);
-    });
-    it("should handle when dividend is smaller than divisor", function () {
-      expect((0, _quotient.quotient)(2, 5)).toEqual([0, 2]);
-      expect((0, _quotient.quotient)(1, 10)).toEqual([0, 1]);
-    });
-    it("should handle negative numbers", function () {
-      expect((0, _quotient.quotient)(-5, 2)).toEqual([-2, -1]);
-      expect((0, _quotient.quotient)(5, -2)).toEqual([-2, 1]);
-      expect((0, _quotient.quotient)(-5, -2)).toEqual([2, -1]);
-    });
-    it("should handle large numbers", function () {
-      expect((0, _quotient.quotient)(1000, 3)).toEqual([333, 1]);
-      expect((0, _quotient.quotient)(9999, 10)).toEqual([999, 9]);
-    });
-  });
-});

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

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

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

@@ -1,50 +0,0 @@
-"use strict";
-
-var _radToDeg = require("@/Math/radToDeg");
-describe("radToDeg", function () {
-  describe("basic conversions", function () {
-    it("should convert common angles correctly", 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);
-    });
-  });
-  describe("negative angles", function () {
-    it("should handle negative angles correctly", 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);
-    });
-  });
-  describe("floating point angles", function () {
-    it("should handle floating point angles correctly", 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);
-    });
-  });
-  describe("angles greater than 2π", function () {
-    it("should handle angles greater than 2π correctly", 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);
-    });
-  });
-  describe("special values", function () {
-    it("should handle NaN and Infinity correctly", function () {
-      expect((0, _radToDeg.radToDeg)(Number.NaN)).toBe(Number.NaN);
-      expect((0, _radToDeg.radToDeg)(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY);
-      expect((0, _radToDeg.radToDeg)(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY);
-    });
-  });
-  describe("invalid inputs", function () {
-    it("should handle invalid inputs appropriately", function () {
-      expect((0, _radToDeg.radToDeg)("1.57")).toBeCloseTo(89.95);
-      expect((0, _radToDeg.radToDeg)([1.57])).toBeCloseTo(89.95);
-      expect((0, _radToDeg.radToDeg)({})).toBe(Number.NaN);
-    });
-  });
-});

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

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

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

@@ -1,61 +0,0 @@
-"use strict";
-
-var _random = require("@/Math/random");
-describe("random function", function () {
-  describe("basic random generation", function () {
-    it("should generate random numbers within specified range", function () {
-      var min = 1;
-      var max = 10;
-      for (var i = 0; i < 100; i++) {
-        var result = (0, _random.random)(max, min);
-        expect(result).toBeGreaterThanOrEqual(min);
-        expect(result).toBeLessThanOrEqual(max);
-        expect(Number.isInteger(result)).toBe(true);
-      }
-    });
-    it("should use 0 as default minimum value", function () {
-      var max = 5;
-      for (var i = 0; i < 100; i++) {
-        var result = (0, _random.random)(max);
-        expect(result).toBeGreaterThanOrEqual(0);
-        expect(result).toBeLessThanOrEqual(max);
-        expect(Number.isInteger(result)).toBe(true);
-      }
-    });
-  });
-  describe("edge cases", function () {
-    it("should return same value when max equals min", function () {
-      var value = 7;
-      var result = (0, _random.random)(value, value);
-      expect(result).toBe(value);
-    });
-    it("should handle negative numbers", function () {
-      var min = -10;
-      var max = -5;
-      for (var i = 0; i < 100; i++) {
-        var result = (0, _random.random)(max, min);
-        expect(result).toBeGreaterThanOrEqual(min);
-        expect(result).toBeLessThanOrEqual(max);
-        expect(Number.isInteger(result)).toBe(true);
-      }
-    });
-    it("should handle mixed positive and negative range", function () {
-      var min = -5;
-      var max = 5;
-      for (var i = 0; i < 100; i++) {
-        var result = (0, _random.random)(max, min);
-        expect(result).toBeGreaterThanOrEqual(min);
-        expect(result).toBeLessThanOrEqual(max);
-        expect(Number.isInteger(result)).toBe(true);
-      }
-    });
-    it("should handle when min is greater than max", function () {
-      var min = 10;
-      var max = 5;
-      var result = (0, _random.random)(max, min);
-      expect(result).toBeGreaterThanOrEqual(max);
-      expect(result).toBeLessThanOrEqual(min);
-      expect(Number.isInteger(result)).toBe(true);
-    });
-  });
-});

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

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