goscript 0.0.34 → 0.0.36

package/gs/math/pow10.gs.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest'
+import { Pow10 } from './pow10.gs.js'
+
+describe('Pow10', () => {
+  it('should return correct powers of 10 for small integers', () => {
+    expect(Pow10(0)).toBe(1)
+    expect(Pow10(1)).toBe(10)
+    expect(Pow10(2)).toBe(100)
+    expect(Pow10(3)).toBe(1000)
+    expect(Pow10(4)).toBe(10000)
+    expect(Pow10(5)).toBe(100000)
+  })
+
+  it('should return correct powers of 10 for negative integers', () => {
+    expect(Pow10(-1)).toBe(0.1)
+    expect(Pow10(-2)).toBe(0.01)
+    expect(Pow10(-3)).toBe(0.001)
+    expect(Pow10(-4)).toBeCloseTo(0.0001, 15)
+    expect(Pow10(-5)).toBeCloseTo(0.00001, 15)
+  })
+
+  it('should return correct powers of 10 for fractional exponents', () => {
+    expect(Pow10(0.5)).toBeCloseTo(Math.sqrt(10), 15)
+    expect(Pow10(1.5)).toBeCloseTo(10 * Math.sqrt(10), 14)
+    expect(Pow10(-0.5)).toBeCloseTo(1 / Math.sqrt(10), 15)
+  })
+
+  it('should handle large positive exponents', () => {
+    expect(Pow10(100)).toBe(1e100)
+    expect(Pow10(200)).toBe(1e200)
+    expect(Pow10(300)).toBe(1e300)
+    expect(Pow10(308)).toBe(1e308)
+    expect(Pow10(309)).toBe(Number.POSITIVE_INFINITY)
+    expect(Pow10(400)).toBe(Number.POSITIVE_INFINITY)
+  })
+
+  it('should handle large negative exponents', () => {
+    expect(Pow10(-100)).toBe(1e-100)
+    expect(Pow10(-200)).toBe(1e-200)
+    expect(Pow10(-300)).toBe(1e-300)
+    expect(Pow10(-320)).toBe(1e-320)
+    expect(Pow10(-324)).toBe(0)
+    expect(Pow10(-400)).toBe(0)
+  })
+
+  it('should handle special values', () => {
+    expect(Pow10(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Pow10(Number.NEGATIVE_INFINITY)).toBe(0)
+    expect(Number.isNaN(Pow10(Number.NaN))).toBe(true)
+  })
+
+  it('should match Math.pow(10, n)', () => {
+    const testValues = [0, 1, 2, 3, -1, -2, -3, 0.5, 1.5, -0.5, 10, -10]
+    for (const n of testValues) {
+      expect(Pow10(n)).toBeCloseTo(Math.pow(10, n), 15)
+    }
+  })
+}) 

package/gs/math/pow10.gs.ts

@@ -0,0 +1,19 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Inf } from "./bits.gs.js";
+
+let pow10tab = $.arrayToSlice<number>([1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30, 1e31])
+
+let pow10postab32 = $.arrayToSlice<number>([1e00, 1e32, 1e64, 1e96, 1e128, 1e160, 1e192, 1e224, 1e256, 1e288])
+
+let pow10negtab32 = $.arrayToSlice<number>([1e-00, 1e-32, 1e-64, 1e-96, 1e-128, 1e-160, 1e-192, 1e-224, 1e-256, 1e-288, 1e-320])
+
+// Pow10 returns 10**n, the base-10 exponential of n.
+//
+// Special cases are:
+//
+//	Pow10(n) =    0 for n < -323
+//	Pow10(n) = +Inf for n > 308
+export function Pow10(n: number): number {
+	return Math.pow(10, n)
+}
+

package/gs/math/remainder.gs.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest'
+import { Remainder, remainder } from './remainder.gs.js'
+
+describe('Remainder', () => {
+  it('should return correct IEEE 754 remainder for normal values', () => {
+    expect(Remainder(5, 3)).toBeCloseTo(-1, 15)
+    expect(Remainder(7, 3)).toBeCloseTo(1, 15)
+    expect(Remainder(8, 3)).toBeCloseTo(-1, 15)
+    expect(Remainder(9, 3)).toBeCloseTo(0, 15)
+    expect(Remainder(10, 3)).toBeCloseTo(1, 15)
+  })
+
+  it('should handle negative values correctly', () => {
+    expect(Remainder(-5, 3)).toBeCloseTo(1, 15)
+    expect(Remainder(5, -3)).toBeCloseTo(-1, 15)
+    expect(Remainder(-5, -3)).toBeCloseTo(1, 15)
+  })
+
+  it('should handle fractional values', () => {
+    expect(Remainder(5.5, 2)).toBeCloseTo(-0.5, 15)
+    expect(Remainder(7.5, 2)).toBeCloseTo(-0.5, 15)
+    expect(Remainder(6.5, 2)).toBeCloseTo(0.5, 15)
+    expect(Remainder(8.5, 2)).toBeCloseTo(0.5, 15)
+  })
+
+  it('should return zero when x is a multiple of y', () => {
+    expect(Remainder(6, 3)).toBe(0)
+    expect(Remainder(12, 4)).toBe(0)
+    expect(Remainder(-8, 2)).toBe(0)
+    expect(Remainder(15, 5)).toBe(0)
+  })
+
+  it('should handle special cases with NaN', () => {
+    expect(Number.isNaN(Remainder(Number.NaN, 3))).toBe(true)
+    expect(Number.isNaN(Remainder(5, Number.NaN))).toBe(true)
+    expect(Number.isNaN(Remainder(Number.NaN, Number.NaN))).toBe(true)
+  })
+
+  it('should handle special cases with infinity', () => {
+    expect(Number.isNaN(Remainder(Number.POSITIVE_INFINITY, 3))).toBe(true)
+    expect(Number.isNaN(Remainder(Number.NEGATIVE_INFINITY, 3))).toBe(true)
+    expect(Remainder(5, Number.POSITIVE_INFINITY)).toBe(5)
+    expect(Remainder(5, Number.NEGATIVE_INFINITY)).toBe(5)
+    expect(Remainder(-7, Number.POSITIVE_INFINITY)).toBe(-7)
+  })
+
+  it('should handle division by zero', () => {
+    expect(Number.isNaN(Remainder(5, 0))).toBe(true)
+    expect(Number.isNaN(Remainder(-5, 0))).toBe(true)
+    expect(Number.isNaN(Remainder(0, 0))).toBe(true)
+  })
+
+  it('should handle zero dividend', () => {
+    expect(Remainder(0, 3)).toBe(0)
+    expect(Remainder(0, -3)).toBe(0)
+    const result = Remainder(-0, 3)
+    expect(result === 0 || Object.is(result, -0)).toBe(true)
+  })
+})
+
+describe('remainder', () => {
+  it('should work the same as Remainder', () => {
+    expect(remainder(5, 3)).toBe(Remainder(5, 3))
+    expect(remainder(7, 3)).toBe(Remainder(7, 3))
+    expect(remainder(-5, 3)).toBe(Remainder(-5, 3))
+    expect(remainder(5.5, 2)).toBe(Remainder(5.5, 2))
+    expect(Number.isNaN(remainder(Number.NaN, 3))).toBe(true)
+    expect(Number.isNaN(remainder(5, 0))).toBe(true)
+  })
+}) 

package/gs/math/remainder.gs.ts

@@ -0,0 +1,33 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { IsInf, IsNaN, NaN } from "./bits.gs.js";
+import { Mod } from "./mod.gs.js";
+
+
+// Remainder returns the IEEE 754 floating-point remainder of x/y.
+//
+// Special cases are:
+//
+//	Remainder(±Inf, y) = NaN
+//	Remainder(NaN, y) = NaN
+//	Remainder(x, 0) = NaN
+//	Remainder(x, ±Inf) = x
+//	Remainder(x, NaN) = NaN
+export function Remainder(x: number, y: number): number {
+	return remainder(x, y)
+}
+
+export function remainder(x: number, y: number): number {
+	// Handle special cases
+	if (Number.isNaN(x) || Number.isNaN(y) || !Number.isFinite(x) || y === 0) {
+		return Number.NaN
+	}
+	
+	if (!Number.isFinite(y)) {
+		return x
+	}
+	
+	// IEEE 754 remainder: x - n*y where n is the integer nearest to x/y
+	const n = Math.round(x / y)
+	return x - n * y
+}
+

package/gs/math/signbit.gs.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest'
+import { Signbit } from './signbit.gs.js'
+
+describe('Signbit', () => {
+  it('should return false for positive numbers', () => {
+    expect(Signbit(1)).toBe(false)
+    expect(Signbit(5.5)).toBe(false)
+    expect(Signbit(Number.MAX_VALUE)).toBe(false)
+    expect(Signbit(Number.MIN_VALUE)).toBe(false)
+  })
+
+  it('should return true for negative numbers', () => {
+    expect(Signbit(-1)).toBe(true)
+    expect(Signbit(-5.5)).toBe(true)
+    expect(Signbit(-Number.MAX_VALUE)).toBe(true)
+    expect(Signbit(-Number.MIN_VALUE)).toBe(true)
+  })
+
+  it('should handle zero correctly', () => {
+    expect(Signbit(0)).toBe(false)
+    expect(Signbit(-0)).toBe(true)
+  })
+
+  it('should handle infinity correctly', () => {
+    expect(Signbit(Number.POSITIVE_INFINITY)).toBe(false)
+    expect(Signbit(Number.NEGATIVE_INFINITY)).toBe(true)
+  })
+
+  it('should handle NaN correctly', () => {
+    expect(Signbit(Number.NaN)).toBe(false)
+    expect(Signbit(-Number.NaN)).toBe(false) // NaN doesn't have a sign
+  })
+}) 

package/gs/math/signbit.gs.ts

@@ -0,0 +1,8 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Float64bits } from "./unsafe.gs.js";
+
+// Signbit reports whether x is negative or negative zero.
+export function Signbit(x: number): boolean {
+	return x < 0 || Object.is(x, -0)
+}
+

package/gs/math/sin.gs.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest'
+import { Sin, sin, Cos, cos } from './sin.gs.js'
+
+describe('Sin', () => {
+  it('should return correct sine values', () => {
+    expect(Sin(0)).toBe(0)
+    expect(Sin(-0)).toBe(-0)
+    expect(Sin(Math.PI / 2)).toBeCloseTo(1, 15)
+    expect(Sin(-Math.PI / 2)).toBeCloseTo(-1, 15)
+    expect(Sin(Math.PI)).toBeCloseTo(0, 15)
+    expect(Sin(-Math.PI)).toBeCloseTo(0, 15)
+    expect(Sin(Math.PI / 6)).toBeCloseTo(0.5, 15)
+    expect(Sin(Math.PI / 4)).toBeCloseTo(Math.sqrt(2) / 2, 15)
+    expect(Sin(Math.PI / 3)).toBeCloseTo(Math.sqrt(3) / 2, 15)
+  })
+
+  it('should handle special values', () => {
+    expect(Number.isNaN(Sin(Number.POSITIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Sin(Number.NEGATIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Sin(Number.NaN))).toBe(true)
+  })
+
+  it('should handle large values', () => {
+    expect(Sin(2 * Math.PI)).toBeCloseTo(0, 14)
+    expect(Sin(4 * Math.PI)).toBeCloseTo(0, 14)
+    expect(Sin(100 * Math.PI)).toBeCloseTo(0, 10)
+  })
+
+  it('should be periodic', () => {
+    const x = 1.5
+    expect(Sin(x)).toBeCloseTo(Sin(x + 2 * Math.PI), 14)
+    expect(Sin(x)).toBeCloseTo(Sin(x + 4 * Math.PI), 14)
+  })
+})
+
+describe('sin', () => {
+  it('should work the same as Sin', () => {
+    expect(sin(0)).toBe(Sin(0))
+    expect(sin(Math.PI / 2)).toBe(Sin(Math.PI / 2))
+    expect(sin(-Math.PI / 2)).toBe(Sin(-Math.PI / 2))
+    expect(sin(Math.PI)).toBe(Sin(Math.PI))
+  })
+})
+
+describe('Cos', () => {
+  it('should return correct cosine values', () => {
+    expect(Cos(0)).toBe(1)
+    expect(Cos(Math.PI / 2)).toBeCloseTo(0, 15)
+    expect(Cos(-Math.PI / 2)).toBeCloseTo(0, 15)
+    expect(Cos(Math.PI)).toBeCloseTo(-1, 15)
+    expect(Cos(-Math.PI)).toBeCloseTo(-1, 15)
+    expect(Cos(Math.PI / 3)).toBeCloseTo(0.5, 15)
+    expect(Cos(Math.PI / 4)).toBeCloseTo(Math.sqrt(2) / 2, 15)
+    expect(Cos(Math.PI / 6)).toBeCloseTo(Math.sqrt(3) / 2, 15)
+  })
+
+  it('should handle special values', () => {
+    expect(Number.isNaN(Cos(Number.POSITIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Cos(Number.NEGATIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Cos(Number.NaN))).toBe(true)
+  })
+
+  it('should handle large values', () => {
+    expect(Cos(2 * Math.PI)).toBeCloseTo(1, 14)
+    expect(Cos(4 * Math.PI)).toBeCloseTo(1, 14)
+    expect(Cos(100 * Math.PI)).toBeCloseTo(1, 10)
+  })
+
+  it('should be periodic', () => {
+    const x = 1.5
+    expect(Cos(x)).toBeCloseTo(Cos(x + 2 * Math.PI), 14)
+    expect(Cos(x)).toBeCloseTo(Cos(x + 4 * Math.PI), 14)
+  })
+})
+
+describe('cos', () => {
+  it('should work the same as Cos', () => {
+    expect(cos(0)).toBe(Cos(0))
+    expect(cos(Math.PI / 2)).toBe(Cos(Math.PI / 2))
+    expect(cos(-Math.PI / 2)).toBe(Cos(-Math.PI / 2))
+    expect(cos(Math.PI)).toBe(Cos(Math.PI))
+  })
+}) 

package/gs/math/sin.gs.ts

@@ -0,0 +1,38 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Abs } from "./abs.gs.js";
+import { IsInf, IsNaN, NaN } from "./bits.gs.js";
+import { trigReduce } from "./trig_reduce.gs.js";
+
+let _sin = $.arrayToSlice<number>([1.58962301576546568060e-10, -2.50507477628578072866e-8, 2.75573136213857245213e-6, -1.98412698295895385996e-4, 8.33333333332211858878e-3, -1.66666666666666307295e-1])
+
+let _cos = $.arrayToSlice<number>([-1.13585365213876817300e-11, 2.08757008419747316778e-9, -2.75573141792967388112e-7, 2.48015872888517045348e-5, -1.38888888888730564116e-3, 4.16666666666665929218e-2])
+
+// Cos returns the cosine of the radian argument x.
+//
+// Special cases are:
+//
+//	Cos(±Inf) = NaN
+//	Cos(NaN) = NaN
+export function Cos(x: number): number {
+	return Math.cos(x)
+}
+
+export function cos(x: number): number {
+	return Math.cos(x)
+}
+
+// Sin returns the sine of the radian argument x.
+//
+// Special cases are:
+//
+//	Sin(±0) = ±0
+//	Sin(±Inf) = NaN
+//	Sin(NaN) = NaN
+export function Sin(x: number): number {
+	return Math.sin(x)
+}
+
+export function sin(x: number): number {
+	return Math.sin(x)
+}
+

package/gs/math/sincos.gs.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest'
+import { Sincos } from './sincos.gs.js'
+
+describe('Sincos', () => {
+  it('should return correct sin and cos values for zero', () => {
+    const [sin, cos] = Sincos(0)
+    expect(sin).toBe(0)
+    expect(cos).toBe(1)
+    
+    const [sinNeg, cosNeg] = Sincos(-0)
+    expect(sinNeg).toBe(-0)
+    expect(cosNeg).toBe(1)
+  })
+
+  it('should return correct sin and cos values for common angles', () => {
+    const [sin1, cos1] = Sincos(Math.PI / 2)
+    expect(sin1).toBeCloseTo(1, 15)
+    expect(cos1).toBeCloseTo(0, 15)
+    
+    const [sin2, cos2] = Sincos(-Math.PI / 2)
+    expect(sin2).toBeCloseTo(-1, 15)
+    expect(cos2).toBeCloseTo(0, 15)
+    
+    const [sin3, cos3] = Sincos(Math.PI)
+    expect(sin3).toBeCloseTo(0, 15)
+    expect(cos3).toBeCloseTo(-1, 15)
+    
+    const [sin4, cos4] = Sincos(-Math.PI)
+    expect(sin4).toBeCloseTo(0, 15)
+    expect(cos4).toBeCloseTo(-1, 15)
+  })
+
+  it('should return correct sin and cos values for special angles', () => {
+    const [sin1, cos1] = Sincos(Math.PI / 6)
+    expect(sin1).toBeCloseTo(0.5, 15)
+    expect(cos1).toBeCloseTo(Math.sqrt(3) / 2, 15)
+    
+    const [sin2, cos2] = Sincos(Math.PI / 4)
+    expect(sin2).toBeCloseTo(Math.sqrt(2) / 2, 15)
+    expect(cos2).toBeCloseTo(Math.sqrt(2) / 2, 15)
+    
+    const [sin3, cos3] = Sincos(Math.PI / 3)
+    expect(sin3).toBeCloseTo(Math.sqrt(3) / 2, 15)
+    expect(cos3).toBeCloseTo(0.5, 15)
+  })
+
+  it('should handle special values', () => {
+    const [sin1, cos1] = Sincos(Number.POSITIVE_INFINITY)
+    expect(Number.isNaN(sin1)).toBe(true)
+    expect(Number.isNaN(cos1)).toBe(true)
+    
+    const [sin2, cos2] = Sincos(Number.NEGATIVE_INFINITY)
+    expect(Number.isNaN(sin2)).toBe(true)
+    expect(Number.isNaN(cos2)).toBe(true)
+    
+    const [sin3, cos3] = Sincos(Number.NaN)
+    expect(Number.isNaN(sin3)).toBe(true)
+    expect(Number.isNaN(cos3)).toBe(true)
+  })
+
+  it('should satisfy the Pythagorean identity', () => {
+    const testValues = [0, Math.PI / 6, Math.PI / 4, Math.PI / 3, Math.PI / 2, Math.PI, 1.5, 2.7, -1.2]
+    
+    for (const x of testValues) {
+      const [sin, cos] = Sincos(x)
+      expect(sin * sin + cos * cos).toBeCloseTo(1, 14)
+    }
+  })
+
+  it('should be periodic with period 2π', () => {
+    const x = 1.5
+    const [sin1, cos1] = Sincos(x)
+    const [sin2, cos2] = Sincos(x + 2 * Math.PI)
+    const [sin3, cos3] = Sincos(x + 4 * Math.PI)
+    
+    expect(sin1).toBeCloseTo(sin2, 14)
+    expect(cos1).toBeCloseTo(cos2, 14)
+    expect(sin1).toBeCloseTo(sin3, 14)
+    expect(cos1).toBeCloseTo(cos3, 14)
+  })
+
+  it('should match individual Math.sin and Math.cos calls', () => {
+    const testValues = [0, Math.PI / 6, Math.PI / 4, Math.PI / 3, Math.PI / 2, Math.PI, 1.5, -1.2]
+    
+    for (const x of testValues) {
+      const [sin, cos] = Sincos(x)
+      expect(sin).toBeCloseTo(Math.sin(x), 15)
+      expect(cos).toBeCloseTo(Math.cos(x), 15)
+    }
+  })
+}) 

package/gs/math/sincos.gs.ts

@@ -0,0 +1,15 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { IsInf, IsNaN, NaN } from "./bits.gs.js";
+import { trigReduce } from "./trig_reduce.gs.js";
+
+// Sincos returns Sin(x), Cos(x).
+//
+// Special cases are:
+//
+//	Sincos(±0) = ±0, 1
+//	Sincos(±Inf) = NaN, NaN
+//	Sincos(NaN) = NaN, NaN
+export function Sincos(x: number): [number, number] {
+	return [Math.sin(x), Math.cos(x)]
+}
+

package/gs/math/sinh.gs.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest'
+import { Sinh, sinh, Cosh, cosh } from './sinh.gs.js'
+
+describe('Sinh', () => {
+  it('should return correct hyperbolic sine values', () => {
+    expect(Sinh(0)).toBe(0)
+    expect(Sinh(-0)).toBe(-0)
+    expect(Sinh(1)).toBeCloseTo(1.1752011936438014, 15)
+    expect(Sinh(-1)).toBeCloseTo(-1.1752011936438014, 15)
+    expect(Sinh(2)).toBeCloseTo(3.626860407847019, 15)
+    expect(Sinh(-2)).toBeCloseTo(-3.626860407847019, 15)
+  })
+
+  it('should handle special values', () => {
+    expect(Sinh(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Sinh(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Number.isNaN(Sinh(Number.NaN))).toBe(true)
+  })
+
+  it('should handle edge cases', () => {
+    expect(Sinh(Number.MAX_VALUE)).toBe(Number.POSITIVE_INFINITY)
+    expect(Sinh(-Number.MAX_VALUE)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Sinh(Number.MIN_VALUE)).toBeCloseTo(Number.MIN_VALUE, 15)
+  })
+})
+
+describe('sinh', () => {
+  it('should work the same as Sinh', () => {
+    expect(sinh(0)).toBe(Sinh(0))
+    expect(sinh(1)).toBe(Sinh(1))
+    expect(sinh(-1)).toBe(Sinh(-1))
+    expect(sinh(Number.POSITIVE_INFINITY)).toBe(Sinh(Number.POSITIVE_INFINITY))
+  })
+})
+
+describe('Cosh', () => {
+  it('should return correct hyperbolic cosine values', () => {
+    expect(Cosh(0)).toBe(1)
+    expect(Cosh(-0)).toBe(1)
+    expect(Cosh(1)).toBeCloseTo(1.5430806348152437, 15)
+    expect(Cosh(-1)).toBeCloseTo(1.5430806348152437, 15)
+    expect(Cosh(2)).toBeCloseTo(3.7621956910836314, 15)
+    expect(Cosh(-2)).toBeCloseTo(3.7621956910836314, 15)
+  })
+
+  it('should handle special values', () => {
+    expect(Cosh(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Cosh(Number.NEGATIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Number.isNaN(Cosh(Number.NaN))).toBe(true)
+  })
+
+  it('should handle edge cases', () => {
+    expect(Cosh(Number.MAX_VALUE)).toBe(Number.POSITIVE_INFINITY)
+    expect(Cosh(-Number.MAX_VALUE)).toBe(Number.POSITIVE_INFINITY)
+    expect(Cosh(Number.MIN_VALUE)).toBeCloseTo(1, 15)
+  })
+})
+
+describe('cosh', () => {
+  it('should work the same as Cosh', () => {
+    expect(cosh(0)).toBe(Cosh(0))
+    expect(cosh(1)).toBe(Cosh(1))
+    expect(cosh(-1)).toBe(Cosh(-1))
+    expect(cosh(Number.POSITIVE_INFINITY)).toBe(Cosh(Number.POSITIVE_INFINITY))
+  })
+}) 

package/gs/math/sinh.gs.ts

@@ -0,0 +1,34 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Abs } from "./abs.gs.js";
+import { Exp } from "./exp.gs.js";
+
+// Sinh returns the hyperbolic sine of x.
+//
+// Special cases are:
+//
+//	Sinh(±0) = ±0
+//	Sinh(±Inf) = ±Inf
+//	Sinh(NaN) = NaN
+export function Sinh(x: number): number {
+	return Math.sinh(x)
+}
+
+export function sinh(x: number): number {
+	return Math.sinh(x)
+}
+
+// Cosh returns the hyperbolic cosine of x.
+//
+// Special cases are:
+//
+//	Cosh(±0) = 1
+//	Cosh(±Inf) = +Inf
+//	Cosh(NaN) = NaN
+export function Cosh(x: number): number {
+	return Math.cosh(x)
+}
+
+export function cosh(x: number): number {
+	return Math.cosh(x)
+}
+

package/gs/math/sqrt.gs.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest'
+import { Sqrt, sqrt } from './sqrt.gs.js'
+
+describe('Sqrt', () => {
+  it('should return correct square root values', () => {
+    expect(Sqrt(0)).toBe(0)
+    expect(Sqrt(-0)).toBe(-0)
+    expect(Sqrt(1)).toBe(1)
+    expect(Sqrt(4)).toBe(2)
+    expect(Sqrt(9)).toBe(3)
+    expect(Sqrt(16)).toBe(4)
+    expect(Sqrt(25)).toBe(5)
+  })
+
+  it('should handle fractional values', () => {
+    expect(Sqrt(0.25)).toBe(0.5)
+    expect(Sqrt(0.01)).toBe(0.1)
+    expect(Sqrt(2)).toBeCloseTo(1.4142135623730951, 14)
+    expect(Sqrt(3)).toBeCloseTo(1.7320508075688772, 15)
+  })
+
+  it('should handle special values', () => {
+    expect(Sqrt(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Number.isNaN(Sqrt(-1))).toBe(true)
+    expect(Number.isNaN(Sqrt(-10))).toBe(true)
+    expect(Number.isNaN(Sqrt(Number.NaN))).toBe(true)
+    expect(Number.isNaN(Sqrt(Number.NEGATIVE_INFINITY))).toBe(true)
+  })
+
+  it('should handle edge cases', () => {
+    expect(Sqrt(Number.MAX_VALUE)).toBeCloseTo(1.3407807929942596e154, 140)
+    expect(Sqrt(Number.MIN_VALUE)).toBeCloseTo(1.4916681462400413e-154, 150)
+  })
+
+  it('should handle very small positive values', () => {
+    expect(Sqrt(1e-100)).toBeCloseTo(1e-50, 14)
+    expect(Sqrt(1e-200)).toBeCloseTo(1e-100, 14)
+  })
+})
+
+describe('sqrt', () => {
+  it('should work the same as Sqrt', () => {
+    expect(sqrt(0)).toBe(Sqrt(0))
+    expect(sqrt(1)).toBe(Sqrt(1))
+    expect(sqrt(4)).toBe(Sqrt(4))
+    expect(sqrt(9)).toBe(Sqrt(9))
+    expect(Number.isNaN(sqrt(-1))).toBe(Number.isNaN(Sqrt(-1)))
+  })
+}) 

package/gs/math/sqrt.gs.ts

@@ -0,0 +1,20 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { IsInf, IsNaN, NaN } from "./bits.gs.js";
+import { Float64bits, Float64frombits } from "./unsafe.gs.js";
+
+// Sqrt returns the square root of x.
+//
+// Special cases are:
+//
+//	Sqrt(+Inf) = +Inf
+//	Sqrt(±0) = ±0
+//	Sqrt(x < 0) = NaN
+//	Sqrt(NaN) = NaN
+export function Sqrt(x: number): number {
+	return Math.sqrt(x)
+}
+
+export function sqrt(x: number): number {
+	return Math.sqrt(x)
+}
+

package/gs/math/tan.gs.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest'
+import { Tan, tan } from './tan.gs.js'
+
+describe('Tan', () => {
+  it('should return correct tangent values', () => {
+    expect(Tan(0)).toBe(0)
+    expect(Tan(-0)).toBe(-0)
+    expect(Tan(Math.PI / 4)).toBeCloseTo(1, 14)
+    expect(Tan(-Math.PI / 4)).toBeCloseTo(-1, 15)
+    expect(Tan(Math.PI)).toBeCloseTo(0, 14)
+    expect(Tan(-Math.PI)).toBeCloseTo(0, 14)
+    expect(Tan(Math.PI / 6)).toBeCloseTo(0.5773502691896257, 14)
+    expect(Tan(Math.PI / 3)).toBeCloseTo(1.7320508075688772, 14)
+  })
+
+  it('should handle special values', () => {
+    expect(Number.isNaN(Tan(Number.POSITIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Tan(Number.NEGATIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Tan(Number.NaN))).toBe(true)
+  })
+
+  it('should approach infinity near asymptotes', () => {
+    const nearPiOver2 = Math.PI / 2 - 1e-10
+    expect(Math.abs(Tan(nearPiOver2))).toBeGreaterThan(1e9)
+    
+    const near3PiOver2 = 3 * Math.PI / 2 - 1e-10
+    expect(Math.abs(Tan(near3PiOver2))).toBeGreaterThan(1e9)
+  })
+
+  it('should be periodic', () => {
+    const x = 1.5
+    expect(Tan(x)).toBeCloseTo(Tan(x + Math.PI), 13)
+    expect(Tan(x)).toBeCloseTo(Tan(x + 2 * Math.PI), 13)
+  })
+
+  it('should handle edge cases', () => {
+    expect(Tan(Number.MIN_VALUE)).toBeCloseTo(Number.MIN_VALUE, 14)
+    expect(Tan(-Number.MIN_VALUE)).toBeCloseTo(-Number.MIN_VALUE, 14)
+  })
+})
+
+describe('tan', () => {
+  it('should work the same as Tan', () => {
+    expect(tan(0)).toBe(Tan(0))
+    expect(tan(Math.PI / 4)).toBe(Tan(Math.PI / 4))
+    expect(tan(-Math.PI / 4)).toBe(Tan(-Math.PI / 4))
+    expect(tan(Math.PI)).toBe(Tan(Math.PI))
+    expect(Number.isNaN(tan(Number.NaN))).toBe(Number.isNaN(Tan(Number.NaN)))
+  })
+})