goscript 0.0.37 → 0.0.38

package/gs/math/erfinv.gs.test.ts

@@ -30,7 +30,9 @@ describe('Erfinv', () => {
   })
 
   it('should be the inverse of Erf', () => {
-    const testValues = [0, 0.1, 0.3, 0.5, 0.7, 0.9, -0.1, -0.3, -0.5, -0.7, -0.9]
+    const testValues = [
+      0, 0.1, 0.3, 0.5, 0.7, 0.9, -0.1, -0.3, -0.5, -0.7, -0.9,
+    ]
     for (const x of testValues) {
       const y = Erfinv(x)
       // Relax precision tolerance for JavaScript floating-point differences
@@ -101,4 +103,4 @@ describe('Erfcinv', () => {
     expect(Erfcinv(0.0001)).toBeGreaterThan(2.5)
     expect(Erfcinv(1.9999)).toBeLessThan(-2.5)
   })
-}) 
+})

package/gs/math/exp.gs.test.ts

@@ -79,4 +79,4 @@ describe('expmulti', () => {
     expect(expmulti(0, 0, 1)).toBe(2)
     expect(expmulti(1, 0, 1)).toBeCloseTo(Math.E * 2, 14)
   })
-}) 
+})

package/gs/math/expm1.gs.test.ts

@@ -11,7 +11,7 @@ describe('Expm1', () => {
 
   it('should return correct values for normal inputs', () => {
     expect(Expm1(1)).toBeCloseTo(Math.E - 1, 15)
-    expect(Expm1(-1)).toBeCloseTo(1/Math.E - 1, 15)
+    expect(Expm1(-1)).toBeCloseTo(1 / Math.E - 1, 15)
     expect(Expm1(2)).toBeCloseTo(Math.E * Math.E - 1, 14)
     expect(Expm1(0.5)).toBeCloseTo(Math.sqrt(Math.E) - 1, 15)
   })
@@ -31,9 +31,11 @@ describe('Expm1', () => {
     const x = 1e-15
     const expm1Result = Expm1(x)
     const expMinus1Result = Math.exp(x) - 1
-    
+
     // For very small x, expm1 should be more accurate
-    expect(Math.abs(expm1Result - x)).toBeLessThan(Math.abs(expMinus1Result - x))
+    expect(Math.abs(expm1Result - x)).toBeLessThan(
+      Math.abs(expMinus1Result - x),
+    )
   })
 })
 
@@ -45,4 +47,4 @@ describe('expm1', () => {
     expect(expm1(0.5)).toBe(Expm1(0.5))
     expect(Number.isNaN(expm1(Number.NaN))).toBe(true)
   })
-}) 
+})

package/gs/math/floor.gs.test.ts

@@ -1,5 +1,14 @@
 import { describe, it, expect } from 'vitest'
-import { Floor, floor, Ceil, ceil, Trunc, trunc, Round, RoundToEven } from './floor.gs.js'
+import {
+  Floor,
+  floor,
+  Ceil,
+  ceil,
+  Trunc,
+  trunc,
+  Round,
+  RoundToEven,
+} from './floor.gs.js'
 
 describe('Floor', () => {
   it('should return correct floor values', () => {
@@ -28,7 +37,9 @@ describe('floor', () => {
   it('should work the same as Floor', () => {
     expect(floor(4.8)).toBe(Floor(4.8))
     expect(floor(-4.2)).toBe(Floor(-4.2))
-    expect(floor(Number.POSITIVE_INFINITY)).toBe(Floor(Number.POSITIVE_INFINITY))
+    expect(floor(Number.POSITIVE_INFINITY)).toBe(
+      Floor(Number.POSITIVE_INFINITY),
+    )
   })
 })
 
@@ -90,7 +101,9 @@ describe('trunc', () => {
   it('should work the same as Trunc', () => {
     expect(trunc(4.8)).toBe(Trunc(4.8))
     expect(trunc(-4.2)).toBe(Trunc(-4.2))
-    expect(trunc(Number.POSITIVE_INFINITY)).toBe(Trunc(Number.POSITIVE_INFINITY))
+    expect(trunc(Number.POSITIVE_INFINITY)).toBe(
+      Trunc(Number.POSITIVE_INFINITY),
+    )
   })
 })
 
@@ -143,4 +156,4 @@ describe('RoundToEven', () => {
     expect(RoundToEven(0)).toBe(0)
     expect(RoundToEven(-0)).toBe(-0)
   })
-}) 
+})

package/gs/math/fma.gs.test.ts

@@ -1,83 +1,83 @@
-import { describe, it, expect } from 'vitest';
-import { FMA } from './fma.gs.js';
-import { Inf, NaN as GoNaN, IsNaN } from './bits.gs.js';
+import { describe, it, expect } from 'vitest'
+import { FMA } from './fma.gs.js'
+import { Inf, NaN as GoNaN, IsNaN } from './bits.gs.js'
 
 describe('FMA', () => {
   it('should compute fused multiply-add correctly for basic cases', () => {
-    expect(FMA(2, 3, 4)).toBe(10); // 2*3 + 4 = 10
-    expect(FMA(1.5, 2, 0.5)).toBe(3.5); // 1.5*2 + 0.5 = 3.5
-    expect(FMA(0.1, 0.2, 0.3)).toBeCloseTo(0.32, 10); // 0.1*0.2 + 0.3 = 0.32
-    expect(FMA(-2, 3, 1)).toBe(-5); // -2*3 + 1 = -5
-  });
+    expect(FMA(2, 3, 4)).toBe(10) // 2*3 + 4 = 10
+    expect(FMA(1.5, 2, 0.5)).toBe(3.5) // 1.5*2 + 0.5 = 3.5
+    expect(FMA(0.1, 0.2, 0.3)).toBeCloseTo(0.32, 10) // 0.1*0.2 + 0.3 = 0.32
+    expect(FMA(-2, 3, 1)).toBe(-5) // -2*3 + 1 = -5
+  })
 
   it('should handle zero values', () => {
-    expect(FMA(0, 5, 3)).toBe(3); // 0*5 + 3 = 3
-    expect(FMA(5, 0, 3)).toBe(3); // 5*0 + 3 = 3
-    expect(FMA(5, 3, 0)).toBe(15); // 5*3 + 0 = 15
-    expect(FMA(0, 0, 0)).toBe(0); // 0*0 + 0 = 0
-    expect(FMA(0, 0, 5)).toBe(5); // 0*0 + 5 = 5
-  });
+    expect(FMA(0, 5, 3)).toBe(3) // 0*5 + 3 = 3
+    expect(FMA(5, 0, 3)).toBe(3) // 5*0 + 3 = 3
+    expect(FMA(5, 3, 0)).toBe(15) // 5*3 + 0 = 15
+    expect(FMA(0, 0, 0)).toBe(0) // 0*0 + 0 = 0
+    expect(FMA(0, 0, 5)).toBe(5) // 0*0 + 5 = 5
+  })
 
   it('should handle negative values', () => {
-    expect(FMA(-2, -3, 4)).toBe(10); // -2*-3 + 4 = 10
-    expect(FMA(-2, 3, -4)).toBe(-10); // -2*3 + -4 = -10
-    expect(FMA(2, -3, -4)).toBe(-10); // 2*-3 + -4 = -10
-    expect(FMA(-2, -3, -4)).toBe(2); // -2*-3 + -4 = 2
-  });
+    expect(FMA(-2, -3, 4)).toBe(10) // -2*-3 + 4 = 10
+    expect(FMA(-2, 3, -4)).toBe(-10) // -2*3 + -4 = -10
+    expect(FMA(2, -3, -4)).toBe(-10) // 2*-3 + -4 = -10
+    expect(FMA(-2, -3, -4)).toBe(2) // -2*-3 + -4 = 2
+  })
 
   it('should handle infinity cases', () => {
-    expect(FMA(Inf(1), 2, 3)).toBe(Inf(1)); // +Inf * 2 + 3 = +Inf
-    expect(FMA(2, Inf(1), 3)).toBe(Inf(1)); // 2 * +Inf + 3 = +Inf
-    expect(FMA(2, 3, Inf(1))).toBe(Inf(1)); // 2 * 3 + +Inf = +Inf
-    expect(FMA(Inf(-1), 2, 3)).toBe(Inf(-1)); // -Inf * 2 + 3 = -Inf
-    expect(FMA(Inf(1), Inf(1), 3)).toBe(Inf(1)); // +Inf * +Inf + 3 = +Inf
-    expect(FMA(Inf(-1), Inf(-1), 3)).toBe(Inf(1)); // -Inf * -Inf + 3 = +Inf
-  });
+    expect(FMA(Inf(1), 2, 3)).toBe(Inf(1)) // +Inf * 2 + 3 = +Inf
+    expect(FMA(2, Inf(1), 3)).toBe(Inf(1)) // 2 * +Inf + 3 = +Inf
+    expect(FMA(2, 3, Inf(1))).toBe(Inf(1)) // 2 * 3 + +Inf = +Inf
+    expect(FMA(Inf(-1), 2, 3)).toBe(Inf(-1)) // -Inf * 2 + 3 = -Inf
+    expect(FMA(Inf(1), Inf(1), 3)).toBe(Inf(1)) // +Inf * +Inf + 3 = +Inf
+    expect(FMA(Inf(-1), Inf(-1), 3)).toBe(Inf(1)) // -Inf * -Inf + 3 = +Inf
+  })
 
   it('should handle NaN cases', () => {
-    expect(IsNaN(FMA(GoNaN(), 2, 3))).toBe(true);
-    expect(IsNaN(FMA(2, GoNaN(), 3))).toBe(true);
-    expect(IsNaN(FMA(2, 3, GoNaN()))).toBe(true);
-    expect(IsNaN(FMA(GoNaN(), GoNaN(), GoNaN()))).toBe(true);
-  });
+    expect(IsNaN(FMA(GoNaN(), 2, 3))).toBe(true)
+    expect(IsNaN(FMA(2, GoNaN(), 3))).toBe(true)
+    expect(IsNaN(FMA(2, 3, GoNaN()))).toBe(true)
+    expect(IsNaN(FMA(GoNaN(), GoNaN(), GoNaN()))).toBe(true)
+  })
 
   it('should handle special infinity and zero combinations', () => {
     // Inf * 0 should produce NaN
-    expect(IsNaN(FMA(Inf(1), 0, 5))).toBe(true);
-    expect(IsNaN(FMA(0, Inf(1), 5))).toBe(true);
-    
+    expect(IsNaN(FMA(Inf(1), 0, 5))).toBe(true)
+    expect(IsNaN(FMA(0, Inf(1), 5))).toBe(true)
+
     // But if the addition part is also infinity, behavior depends on implementation
-    expect(IsNaN(FMA(Inf(1), 0, Inf(1)))).toBe(true);
-  });
+    expect(IsNaN(FMA(Inf(1), 0, Inf(1)))).toBe(true)
+  })
 
   it('should handle cancellation cases', () => {
     // Cases where x*y and z cancel out
-    expect(FMA(2, 3, -6)).toBe(0); // 2*3 + (-6) = 0
-    expect(FMA(-5, 4, 20)).toBe(0); // -5*4 + 20 = 0
-    expect(FMA(0.5, 0.2, -0.1)).toBeCloseTo(0, 10); // 0.5*0.2 + (-0.1) = 0
-  });
+    expect(FMA(2, 3, -6)).toBe(0) // 2*3 + (-6) = 0
+    expect(FMA(-5, 4, 20)).toBe(0) // -5*4 + 20 = 0
+    expect(FMA(0.5, 0.2, -0.1)).toBeCloseTo(0, 10) // 0.5*0.2 + (-0.1) = 0
+  })
 
   it('should handle very large and small numbers', () => {
-    const large = 1e100;
-    const small = 1e-100;
-    
+    const large = 1e100
+    const small = 1e-100
+
     // Relax tolerance for very large/small number calculations
     const result1 = FMA(large, small, 1)
-    expect(result1).toBeCloseTo(2, 0); // large*small is approximately 1, so result is approximately 2
-    expect(FMA(small, small, large)).toBeCloseTo(large, 5); // small*small is negligible
-    expect(FMA(large, large, -large * large)).toBeCloseTo(0, 5); // cancellation
-  });
+    expect(result1).toBeCloseTo(2, 0) // large*small is approximately 1, so result is approximately 2
+    expect(FMA(small, small, large)).toBeCloseTo(large, 5) // small*small is negligible
+    expect(FMA(large, large, -large * large)).toBeCloseTo(0, 5) // cancellation
+  })
 
   it('should be equivalent to x * y + z for simple cases', () => {
     const testCases = [
       [1, 2, 3],
       [0.5, 0.25, 0.125],
       [-1, 2, -3],
-      [10, 0.1, 5]
-    ];
+      [10, 0.1, 5],
+    ]
 
     testCases.forEach(([x, y, z]) => {
-      expect(FMA(x, y, z)).toBeCloseTo(x * y + z, 10);
-    });
-  });
-}); 
+      expect(FMA(x, y, z)).toBeCloseTo(x * y + z, 10)
+    })
+  })
+})

package/gs/math/frexp.gs.test.ts

@@ -1,146 +1,141 @@
-import { describe, it, expect } from 'vitest';
-import { Frexp, frexp } from './frexp.gs.js';
-import { Inf, NaN as GoNaN, IsNaN } from './bits.gs.js';
+import { describe, it, expect } from 'vitest'
+import { Frexp, frexp } from './frexp.gs.js'
+import { Inf, NaN as GoNaN, IsNaN } from './bits.gs.js'
 
 describe('Frexp', () => {
   it('should break numbers into normalized fraction and exponent', () => {
     // Test basic cases where we can verify the math
-    let [frac, exp] = Frexp(8);
-    expect(frac).toBeCloseTo(0.5, 10);
-    expect(exp).toBe(4); // 8 = 0.5 * 2^4
-    
-    [frac, exp] = Frexp(1);
-    expect(frac).toBeCloseTo(0.5, 10);
-    expect(exp).toBe(1); // 1 = 0.5 * 2^1
-    
-    [frac, exp] = Frexp(2);
-    expect(frac).toBeCloseTo(0.5, 10);
-    expect(exp).toBe(2); // 2 = 0.5 * 2^2
-    
-    [frac, exp] = Frexp(4);
-    expect(frac).toBeCloseTo(0.5, 10);
-    expect(exp).toBe(3); // 4 = 0.5 * 2^3
-  });
+    let [frac, exp] = Frexp(8)
+    expect(frac).toBeCloseTo(0.5, 10)
+    expect(exp).toBe(4) // 8 = 0.5 * 2^4
+    ;[frac, exp] = Frexp(1)
+    expect(frac).toBeCloseTo(0.5, 10)
+    expect(exp).toBe(1) // 1 = 0.5 * 2^1
+    ;[frac, exp] = Frexp(2)
+    expect(frac).toBeCloseTo(0.5, 10)
+    expect(exp).toBe(2) // 2 = 0.5 * 2^2
+    ;[frac, exp] = Frexp(4)
+    expect(frac).toBeCloseTo(0.5, 10)
+    expect(exp).toBe(3) // 4 = 0.5 * 2^3
+  })
 
   it('should handle fractional numbers', () => {
-    let [frac, exp] = Frexp(0.5);
-    expect(frac).toBeCloseTo(0.5, 10);
-    expect(exp).toBe(0); // 0.5 = 0.5 * 2^0
-    
-    [frac, exp] = Frexp(0.25);
-    expect(frac).toBeCloseTo(0.5, 10);
-    expect(exp).toBe(-1); // 0.25 = 0.5 * 2^-1
-    
-    [frac, exp] = Frexp(0.125);
-    expect(frac).toBeCloseTo(0.5, 10);
-    expect(exp).toBe(-2); // 0.125 = 0.5 * 2^-2
-  });
+    let [frac, exp] = Frexp(0.5)
+    expect(frac).toBeCloseTo(0.5, 10)
+    expect(exp).toBe(0) // 0.5 = 0.5 * 2^0
+    ;[frac, exp] = Frexp(0.25)
+    expect(frac).toBeCloseTo(0.5, 10)
+    expect(exp).toBe(-1) // 0.25 = 0.5 * 2^-1
+    ;[frac, exp] = Frexp(0.125)
+    expect(frac).toBeCloseTo(0.5, 10)
+    expect(exp).toBe(-2) // 0.125 = 0.5 * 2^-2
+  })
 
   it('should handle negative numbers', () => {
-    let [frac, exp] = Frexp(-8);
-    expect(frac).toBeCloseTo(-0.5, 10);
-    expect(exp).toBe(4); // -8 = -0.5 * 2^4
-    
-    [frac, exp] = Frexp(-1);
-    expect(frac).toBeCloseTo(-0.5, 10);
-    expect(exp).toBe(1); // -1 = -0.5 * 2^1
-    
-    [frac, exp] = Frexp(-0.5);
-    expect(frac).toBeCloseTo(-0.5, 10);
-    expect(exp).toBe(0); // -0.5 = -0.5 * 2^0
-  });
+    let [frac, exp] = Frexp(-8)
+    expect(frac).toBeCloseTo(-0.5, 10)
+    expect(exp).toBe(4) // -8 = -0.5 * 2^4
+    ;[frac, exp] = Frexp(-1)
+    expect(frac).toBeCloseTo(-0.5, 10)
+    expect(exp).toBe(1) // -1 = -0.5 * 2^1
+    ;[frac, exp] = Frexp(-0.5)
+    expect(frac).toBeCloseTo(-0.5, 10)
+    expect(exp).toBe(0) // -0.5 = -0.5 * 2^0
+  })
 
   it('should handle zero values', () => {
-    let [frac, exp] = Frexp(0);
-    expect(frac).toBe(0);
-    expect(exp).toBe(0);
-    
-    [frac, exp] = Frexp(-0);
-    expect(frac).toBe(-0);
-    expect(exp).toBe(0);
-    expect(Object.is(frac, -0)).toBe(true); // Preserve sign of zero
-  });
+    let [frac, exp] = Frexp(0)
+    expect(frac).toBe(0)
+    expect(exp).toBe(0)
+    ;[frac, exp] = Frexp(-0)
+    expect(frac).toBe(-0)
+    expect(exp).toBe(0)
+    expect(Object.is(frac, -0)).toBe(true) // Preserve sign of zero
+  })
 
   it('should handle infinity cases', () => {
-    let [frac, exp] = Frexp(Inf(1));
-    expect(frac).toBe(Inf(1));
-    expect(exp).toBe(0);
-    
-    [frac, exp] = Frexp(Inf(-1));
-    expect(frac).toBe(Inf(-1));
-    expect(exp).toBe(0);
-  });
+    let [frac, exp] = Frexp(Inf(1))
+    expect(frac).toBe(Inf(1))
+    expect(exp).toBe(0)
+    ;[frac, exp] = Frexp(Inf(-1))
+    expect(frac).toBe(Inf(-1))
+    expect(exp).toBe(0)
+  })
 
   it('should handle NaN cases', () => {
-    let [frac, _exp] = Frexp(GoNaN());
-    expect(IsNaN(frac)).toBe(true);
-    expect(_exp).toBe(0);
-  });
+    let [frac, _exp] = Frexp(GoNaN())
+    expect(IsNaN(frac)).toBe(true)
+    expect(_exp).toBe(0)
+  })
 
   it('should satisfy the fundamental property f = frac * 2^exp', () => {
-    const testValues = [1, 2, 3, 4, 5, 8, 16, 0.5, 0.25, 0.125, 1.5, 3.14159, 100, 1000];
-    
-    testValues.forEach(value => {
-      const [frac, exp] = Frexp(value);
-      const reconstructed = frac * Math.pow(2, exp);
-      expect(reconstructed).toBeCloseTo(value, 10);
-    });
-    
+    const testValues = [
+      1, 2, 3, 4, 5, 8, 16, 0.5, 0.25, 0.125, 1.5, 3.14159, 100, 1000,
+    ]
+
+    testValues.forEach((value) => {
+      const [frac, exp] = Frexp(value)
+      const reconstructed = frac * Math.pow(2, exp)
+      expect(reconstructed).toBeCloseTo(value, 10)
+    })
+
     // Test negative values
-    testValues.forEach(value => {
-      const [frac, exp] = Frexp(-value);
-      const reconstructed = frac * Math.pow(2, exp);
-      expect(reconstructed).toBeCloseTo(-value, 10);
-    });
-  });
+    testValues.forEach((value) => {
+      const [frac, exp] = Frexp(-value)
+      const reconstructed = frac * Math.pow(2, exp)
+      expect(reconstructed).toBeCloseTo(-value, 10)
+    })
+  })
 
   it('should ensure fraction is in range [0.5, 1) for positive numbers', () => {
-    const testValues = [1, 2, 3, 4, 5, 8, 16, 0.5, 0.25, 0.125, 1.5, 3.14159, 100, 1000];
-    
-    testValues.forEach(value => {
-      const [frac, _exp] = Frexp(value);
+    const testValues = [
+      1, 2, 3, 4, 5, 8, 16, 0.5, 0.25, 0.125, 1.5, 3.14159, 100, 1000,
+    ]
+
+    testValues.forEach((value) => {
+      const [frac, _exp] = Frexp(value)
       if (value !== 0) {
-        expect(Math.abs(frac)).toBeGreaterThanOrEqual(0.5);
-        expect(Math.abs(frac)).toBeLessThan(1);
+        expect(Math.abs(frac)).toBeGreaterThanOrEqual(0.5)
+        expect(Math.abs(frac)).toBeLessThan(1)
       }
-    });
-  });
+    })
+  })
 
   it('should handle very large numbers', () => {
-    const large = 1e100;
-    const [frac, exp] = Frexp(large);
-    expect(Math.abs(frac)).toBeGreaterThanOrEqual(0.5);
-    expect(Math.abs(frac)).toBeLessThan(1);
-    expect(frac * Math.pow(2, exp)).toBeCloseTo(large, 5);
-  });
+    const large = 1e100
+    const [frac, exp] = Frexp(large)
+    expect(Math.abs(frac)).toBeGreaterThanOrEqual(0.5)
+    expect(Math.abs(frac)).toBeLessThan(1)
+    expect(frac * Math.pow(2, exp)).toBeCloseTo(large, 5)
+  })
 
   it('should handle very small numbers', () => {
-    const small = 1e-100;
-    const [frac, exp] = Frexp(small);
-    expect(Math.abs(frac)).toBeGreaterThanOrEqual(0.5);
-    expect(Math.abs(frac)).toBeLessThan(1);
-    expect(frac * Math.pow(2, exp)).toBeCloseTo(small, 110);
-  });
-});
+    const small = 1e-100
+    const [frac, exp] = Frexp(small)
+    expect(Math.abs(frac)).toBeGreaterThanOrEqual(0.5)
+    expect(Math.abs(frac)).toBeLessThan(1)
+    expect(frac * Math.pow(2, exp)).toBeCloseTo(small, 110)
+  })
+})
 
 describe('frexp (lowercase)', () => {
   it('should work identically to Frexp', () => {
-    const testValues = [0, 1, 2, 4, 8, 0.5, 0.25, -1, -2, 3.14159];
-    
-    testValues.forEach(value => {
-      const [frac1, exp1] = Frexp(value);
-      const [frac2, exp2] = frexp(value);
-      expect(frac1).toBe(frac2);
-      expect(exp1).toBe(exp2);
-    });
-    
+    const testValues = [0, 1, 2, 4, 8, 0.5, 0.25, -1, -2, 3.14159]
+
+    testValues.forEach((value) => {
+      const [frac1, exp1] = Frexp(value)
+      const [frac2, exp2] = frexp(value)
+      expect(frac1).toBe(frac2)
+      expect(exp1).toBe(exp2)
+    })
+
     // Test special cases
-    expect(frexp(Inf(1))).toEqual(Frexp(Inf(1)));
-    expect(frexp(Inf(-1))).toEqual(Frexp(Inf(-1)));
-    
-    const [fracNaN1, expNaN1] = frexp(GoNaN());
-    const [fracNaN2, expNaN2] = Frexp(GoNaN());
-    expect(IsNaN(fracNaN1)).toBe(IsNaN(fracNaN2));
-    expect(expNaN1).toBe(expNaN2);
-  });
-}); 
+    expect(frexp(Inf(1))).toEqual(Frexp(Inf(1)))
+    expect(frexp(Inf(-1))).toEqual(Frexp(Inf(-1)))
+
+    const [fracNaN1, expNaN1] = frexp(GoNaN())
+    const [fracNaN2, expNaN2] = Frexp(GoNaN())
+    expect(IsNaN(fracNaN1)).toBe(IsNaN(fracNaN2))
+    expect(expNaN1).toBe(expNaN2)
+  })
+})

package/gs/math/gamma.gs.test.ts

@@ -63,4 +63,4 @@ describe('Gamma', () => {
     const expected = Math.PI / Math.sin(Math.PI * x)
     expect(gamma_x * gamma_1_minus_x).toBeCloseTo(expected, 10)
   })
-}) 
+})

package/gs/math/hypot.gs.test.ts

@@ -1,73 +1,73 @@
-import { describe, it, expect } from 'vitest';
-import { Hypot, hypot } from './hypot.gs.js';
-import { Inf, NaN as GoNaN, IsNaN, IsInf } from './bits.gs.js';
+import { describe, it, expect } from 'vitest'
+import { Hypot, hypot } from './hypot.gs.js'
+import { Inf, NaN as GoNaN, IsNaN, IsInf } from './bits.gs.js'
 
 describe('Hypot', () => {
   it('should calculate hypotenuse correctly for basic cases', () => {
-    expect(Hypot(3, 4)).toBeCloseTo(5, 10);
-    expect(Hypot(5, 12)).toBeCloseTo(13, 10);
-    expect(Hypot(8, 15)).toBeCloseTo(17, 10);
-    expect(Hypot(1, 1)).toBeCloseTo(Math.sqrt(2), 10);
-  });
+    expect(Hypot(3, 4)).toBeCloseTo(5, 10)
+    expect(Hypot(5, 12)).toBeCloseTo(13, 10)
+    expect(Hypot(8, 15)).toBeCloseTo(17, 10)
+    expect(Hypot(1, 1)).toBeCloseTo(Math.sqrt(2), 10)
+  })
 
   it('should handle zero values', () => {
-    expect(Hypot(0, 0)).toBe(0);
-    expect(Hypot(0, 5)).toBe(5);
-    expect(Hypot(5, 0)).toBe(5);
-    expect(Hypot(0, -5)).toBe(5);
-    expect(Hypot(-5, 0)).toBe(5);
-  });
+    expect(Hypot(0, 0)).toBe(0)
+    expect(Hypot(0, 5)).toBe(5)
+    expect(Hypot(5, 0)).toBe(5)
+    expect(Hypot(0, -5)).toBe(5)
+    expect(Hypot(-5, 0)).toBe(5)
+  })
 
   it('should handle negative values', () => {
-    expect(Hypot(-3, 4)).toBeCloseTo(5, 10);
-    expect(Hypot(3, -4)).toBeCloseTo(5, 10);
-    expect(Hypot(-3, -4)).toBeCloseTo(5, 10);
-    expect(Hypot(-5, -12)).toBeCloseTo(13, 10);
-  });
+    expect(Hypot(-3, 4)).toBeCloseTo(5, 10)
+    expect(Hypot(3, -4)).toBeCloseTo(5, 10)
+    expect(Hypot(-3, -4)).toBeCloseTo(5, 10)
+    expect(Hypot(-5, -12)).toBeCloseTo(13, 10)
+  })
 
   it('should handle infinity cases', () => {
-    expect(Hypot(Inf(1), 5)).toBe(Inf(1));
-    expect(Hypot(5, Inf(1))).toBe(Inf(1));
-    expect(Hypot(Inf(-1), 5)).toBe(Inf(1));
-    expect(Hypot(5, Inf(-1))).toBe(Inf(1));
-    expect(Hypot(Inf(1), Inf(1))).toBe(Inf(1));
-    expect(Hypot(Inf(-1), Inf(-1))).toBe(Inf(1));
-  });
+    expect(Hypot(Inf(1), 5)).toBe(Inf(1))
+    expect(Hypot(5, Inf(1))).toBe(Inf(1))
+    expect(Hypot(Inf(-1), 5)).toBe(Inf(1))
+    expect(Hypot(5, Inf(-1))).toBe(Inf(1))
+    expect(Hypot(Inf(1), Inf(1))).toBe(Inf(1))
+    expect(Hypot(Inf(-1), Inf(-1))).toBe(Inf(1))
+  })
 
   it('should handle NaN cases', () => {
-    expect(IsNaN(Hypot(GoNaN(), 5))).toBe(true);
-    expect(IsNaN(Hypot(5, GoNaN()))).toBe(true);
-    expect(IsNaN(Hypot(GoNaN(), GoNaN()))).toBe(true);
-  });
+    expect(IsNaN(Hypot(GoNaN(), 5))).toBe(true)
+    expect(IsNaN(Hypot(5, GoNaN()))).toBe(true)
+    expect(IsNaN(Hypot(GoNaN(), GoNaN()))).toBe(true)
+  })
 
   it('should handle very large values without overflow', () => {
-    const large = 1e150;
-    const result = Hypot(large, large);
-    expect(result).toBeCloseTo(large * Math.sqrt(2), 5);
-    expect(IsInf(result, 0)).toBe(false);
-  });
+    const large = 1e150
+    const result = Hypot(large, large)
+    expect(result).toBeCloseTo(large * Math.sqrt(2), 5)
+    expect(IsInf(result, 0)).toBe(false)
+  })
 
   it('should handle very small values without underflow', () => {
-    const small = 1e-150;
-    const result = Hypot(small, small);
-    expect(result).toBeCloseTo(small * Math.sqrt(2), 160);
-    expect(result).toBeGreaterThan(0);
-  });
+    const small = 1e-150
+    const result = Hypot(small, small)
+    expect(result).toBeCloseTo(small * Math.sqrt(2), 160)
+    expect(result).toBeGreaterThan(0)
+  })
 
   it('should be commutative', () => {
-    expect(Hypot(3, 4)).toBe(Hypot(4, 3));
-    expect(Hypot(-3, 4)).toBe(Hypot(4, -3));
-    expect(Hypot(1.5, 2.5)).toBe(Hypot(2.5, 1.5));
-  });
-});
+    expect(Hypot(3, 4)).toBe(Hypot(4, 3))
+    expect(Hypot(-3, 4)).toBe(Hypot(4, -3))
+    expect(Hypot(1.5, 2.5)).toBe(Hypot(2.5, 1.5))
+  })
+})
 
 describe('hypot (lowercase)', () => {
   it('should work identically to Hypot', () => {
-    expect(hypot(3, 4)).toBe(Hypot(3, 4));
-    expect(hypot(5, 12)).toBe(Hypot(5, 12));
-    expect(hypot(0, 0)).toBe(Hypot(0, 0));
-    expect(hypot(-3, 4)).toBe(Hypot(-3, 4));
-    expect(hypot(Inf(1), 5)).toBe(Hypot(Inf(1), 5));
-    expect(IsNaN(hypot(GoNaN(), 5))).toBe(IsNaN(Hypot(GoNaN(), 5)));
-  });
-}); 
+    expect(hypot(3, 4)).toBe(Hypot(3, 4))
+    expect(hypot(5, 12)).toBe(Hypot(5, 12))
+    expect(hypot(0, 0)).toBe(Hypot(0, 0))
+    expect(hypot(-3, 4)).toBe(Hypot(-3, 4))
+    expect(hypot(Inf(1), 5)).toBe(Hypot(Inf(1), 5))
+    expect(IsNaN(hypot(GoNaN(), 5))).toBe(IsNaN(Hypot(GoNaN(), 5)))
+  })
+})