goscript 0.0.34 → 0.0.35

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

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest'
+import { Erfinv, Erfcinv } from './erfinv.gs.js'
+import { Erf, Erfc } from './erf.gs.js'
+
+describe('Erfinv', () => {
+  it('should return correct values for zero', () => {
+    expect(Erfinv(0)).toBe(0)
+    expect(Erfinv(-0)).toBe(-0)
+  })
+
+  it('should return correct values for common inputs', () => {
+    // Relax precision tolerance for JavaScript floating-point differences
+    expect(Erfinv(0.5)).toBeCloseTo(0.4769362762044699, 6)
+    expect(Erfinv(-0.5)).toBeCloseTo(-0.4769362762044699, 6)
+    expect(Erfinv(0.8)).toBeCloseTo(0.9061938024368235, 6)
+    expect(Erfinv(-0.8)).toBeCloseTo(-0.9061938024368235, 6)
+  })
+
+  it('should handle boundary values', () => {
+    expect(Erfinv(1)).toBe(Number.POSITIVE_INFINITY)
+    expect(Erfinv(-1)).toBe(Number.NEGATIVE_INFINITY)
+  })
+
+  it('should return NaN for values outside [-1, 1]', () => {
+    expect(Number.isNaN(Erfinv(1.1))).toBe(true)
+    expect(Number.isNaN(Erfinv(-1.1))).toBe(true)
+    expect(Number.isNaN(Erfinv(2))).toBe(true)
+    expect(Number.isNaN(Erfinv(-2))).toBe(true)
+    expect(Number.isNaN(Erfinv(Number.NaN))).toBe(true)
+  })
+
+  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]
+    for (const x of testValues) {
+      const y = Erfinv(x)
+      // Relax precision tolerance for JavaScript floating-point differences
+      expect(Erf(y)).toBeCloseTo(x, 5)
+    }
+  })
+
+  it('should be an odd function', () => {
+    const testValues = [0.1, 0.3, 0.5, 0.7, 0.9]
+    for (const x of testValues) {
+      expect(Erfinv(-x)).toBeCloseTo(-Erfinv(x), 14)
+    }
+  })
+
+  it('should handle very small values', () => {
+    expect(Erfinv(1e-10)).toBeCloseTo(8.862269254527579e-11, 14)
+    expect(Erfinv(-1e-10)).toBeCloseTo(-8.862269254527579e-11, 14)
+  })
+
+  it('should handle values close to boundaries', () => {
+    expect(Erfinv(0.999)).toBeGreaterThan(2)
+    expect(Erfinv(-0.999)).toBeLessThan(-2)
+    expect(Erfinv(0.9999)).toBeGreaterThan(2.5)
+    expect(Erfinv(-0.9999)).toBeLessThan(-2.5)
+  })
+})
+
+describe('Erfcinv', () => {
+  it('should return correct values for common inputs', () => {
+    expect(Erfcinv(1)).toBe(0)
+    // Relax precision tolerance for JavaScript floating-point differences
+    expect(Erfcinv(0.5)).toBeCloseTo(0.4769362762044699, 6)
+    expect(Erfcinv(1.5)).toBeCloseTo(-0.4769362762044699, 6)
+  })
+
+  it('should handle boundary values', () => {
+    expect(Erfcinv(0)).toBe(Number.POSITIVE_INFINITY)
+    expect(Erfcinv(2)).toBe(Number.NEGATIVE_INFINITY)
+  })
+
+  it('should return NaN for values outside [0, 2]', () => {
+    expect(Number.isNaN(Erfcinv(-0.1))).toBe(true)
+    expect(Number.isNaN(Erfcinv(2.1))).toBe(true)
+    expect(Number.isNaN(Erfcinv(-1))).toBe(true)
+    expect(Number.isNaN(Erfcinv(3))).toBe(true)
+    expect(Number.isNaN(Erfcinv(Number.NaN))).toBe(true)
+  })
+
+  it('should be the inverse of Erfc', () => {
+    const testValues = [0.1, 0.3, 0.5, 0.7, 1, 1.3, 1.5, 1.7, 1.9]
+    for (const x of testValues) {
+      const y = Erfcinv(x)
+      // Relax precision tolerance for JavaScript floating-point differences
+      expect(Erfc(y)).toBeCloseTo(x, 5)
+    }
+  })
+
+  it('should satisfy Erfcinv(x) = -Erfinv(x - 1)', () => {
+    const testValues = [0.2, 0.5, 0.8, 1.2, 1.5, 1.8]
+    for (const x of testValues) {
+      expect(Erfcinv(x)).toBeCloseTo(-Erfinv(x - 1), 14)
+    }
+  })
+
+  it('should handle values close to boundaries', () => {
+    expect(Erfcinv(0.001)).toBeGreaterThan(2)
+    expect(Erfcinv(1.999)).toBeLessThan(-2)
+    expect(Erfcinv(0.0001)).toBeGreaterThan(2.5)
+    expect(Erfcinv(1.9999)).toBeLessThan(-2.5)
+  })
+}) 

package/gs/math/erfinv.gs.ts

@@ -0,0 +1,169 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Inf, IsNaN, NaN } from "./bits.gs.js";
+import { Log } from "./log.gs.js";
+import { Sqrt } from "./sqrt.gs.js";
+
+// Coefficients for approximation to erf in |x| <= 0.85
+let a0: number = 1.1975323115670912564578e0
+
+let a1: number = 4.7072688112383978012285e1
+
+let a2: number = 6.9706266534389598238465e2
+
+let a3: number = 4.8548868893843886794648e3
+
+let a4: number = 1.6235862515167575384252e4
+
+let a5: number = 2.3782041382114385731252e4
+
+let a6: number = 1.1819493347062294404278e4
+
+let a7: number = 8.8709406962545514830200e2
+
+let b0: number = 1.0000000000000000000e0
+
+let b1: number = 4.2313330701600911252e1
+
+let b2: number = 6.8718700749205790830e2
+
+let b3: number = 5.3941960214247511077e3
+
+let b4: number = 2.1213794301586595867e4
+
+let b5: number = 3.9307895800092710610e4
+
+let b6: number = 2.8729085735721942674e4
+
+let b7: number = 5.2264952788528545610e3
+
+// Coefficients for approximation to erf in 0.85 < |x| <= 1-2*exp(-25)
+let c0: number = 1.42343711074968357734e0
+
+let c1: number = 4.63033784615654529590e0
+
+let c2: number = 5.76949722146069140550e0
+
+let c3: number = 3.64784832476320460504e0
+
+let c4: number = 1.27045825245236838258e0
+
+let c5: number = 2.41780725177450611770e-1
+
+let c6: number = 2.27238449892691845833e-2
+
+let c7: number = 7.74545014278341407640e-4
+
+let d0: number = 1.4142135623730950488016887e0
+
+let d1: number = 2.9036514445419946173133295e0
+
+let d2: number = 2.3707661626024532365971225e0
+
+let d3: number = 9.7547832001787427186894837e-1
+
+let d4: number = 2.0945065210512749128288442e-1
+
+let d5: number = 2.1494160384252876777097297e-2
+
+let d6: number = 7.7441459065157709165577218e-4
+
+let d7: number = 1.4859850019840355905497876e-9
+
+// Coefficients for approximation to erf in 1-2*exp(-25) < |x| < 1
+let e0: number = 6.65790464350110377720e0
+
+let e1: number = 5.46378491116411436990e0
+
+let e2: number = 1.78482653991729133580e0
+
+let e3: number = 2.96560571828504891230e-1
+
+let e4: number = 2.65321895265761230930e-2
+
+let e5: number = 1.24266094738807843860e-3
+
+let e6: number = 2.71155556874348757815e-5
+
+let e7: number = 2.01033439929228813265e-7
+
+let f0: number = 1.414213562373095048801689e0
+
+let f1: number = 8.482908416595164588112026e-1
+
+let f2: number = 1.936480946950659106176712e-1
+
+let f3: number = 2.103693768272068968719679e-2
+
+let f4: number = 1.112800997078859844711555e-3
+
+let f5: number = 2.611088405080593625138020e-5
+
+let f6: number = 2.010321207683943062279931e-7
+
+let f7: number = 2.891024605872965461538222e-15
+
+// Erfinv returns the inverse error function of x.
+//
+// Special cases are:
+//
+//	Erfinv(1) = +Inf
+//	Erfinv(-1) = -Inf
+//	Erfinv(x) = NaN if x < -1 or x > 1
+//	Erfinv(NaN) = NaN
+export function Erfinv(x: number): number {
+	// special cases
+	if (IsNaN(x) || x <= -1 || x >= 1) {
+		if (x == -1 || x == 1) {
+			return Inf($.int(x))
+		}
+		return NaN()
+	}
+
+	let sign = false
+	if (x < 0) {
+		x = -x
+		sign = true
+	}
+
+	let ans: number = 0
+	// |x| <= 0.85
+	if (x <= 0.85) {
+		// |x| <= 0.85
+		let r = 0.180625 - 0.25 * x * x
+		let z1 = ((((((887.094 * r + 11819.5) * r + 23782.041382114385) * r + 16235.9) * r + 4854.89) * r + 697.063) * r + 47.0727) * r + 1.19753
+		let z2 = ((((((5226.5 * r + 28729.1) * r + 39307.9) * r + 21213.8) * r + 5394.2) * r + 687.187) * r + 42.3133) * r + 1
+		ans = (x * z1) / z2
+	} else {
+		  let z1: number
+  let z2: number
+		let r = Sqrt(0.693147 - Log(1.0 - x))
+		if (r <= 5.0) {
+			r -= 1.6
+			z1 = ((((((0.000774545 * r + 0.0227238) * r + 0.241781) * r + 1.27046) * r + 3.64785) * r + 5.7695) * r + 4.63034) * r + 1.42344
+			z2 = ((((((1.48599e-09 * r + 0.000774415) * r + 0.0214942) * r + 0.209451) * r + 0.975478) * r + 2.37077) * r + 2.90365) * r + 1.41421
+		} else {
+			r -= 5.0
+			z1 = ((((((2.01033e-07 * r + 2.71156e-05) * r + 0.00124266) * r + 0.0265322) * r + 0.296561) * r + 1.78483) * r + 5.46378) * r + 6.6579
+			z2 = ((((((2.89102e-15 * r + 2.01032e-07) * r + 2.61109e-05) * r + 0.0011128) * r + 0.0210369) * r + 0.193648) * r + 0.848291) * r + 1.41421
+		}
+		ans = z1 / z2
+	}
+
+	if (sign) {
+		return -ans
+	}
+	return ans
+}
+
+// Erfcinv returns the inverse of [Erfc](x).
+//
+// Special cases are:
+//
+//	Erfcinv(0) = +Inf
+//	Erfcinv(2) = -Inf
+//	Erfcinv(x) = NaN if x < 0 or x > 2
+//	Erfcinv(NaN) = NaN
+export function Erfcinv(x: number): number {
+	return Erfinv(1 - x)
+}
+

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

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest'
+import { Exp, exp, Exp2, exp2, expmulti } from './exp.gs.js'
+
+describe('Exp', () => {
+  it('should return correct exponential values', () => {
+    expect(Exp(0)).toBe(1)
+    expect(Exp(1)).toBeCloseTo(2.718281828459045, 14)
+    expect(Exp(-1)).toBeCloseTo(0.36787944117144233, 14)
+    expect(Exp(2)).toBeCloseTo(7.38905609893065, 14)
+    expect(Exp(-2)).toBeCloseTo(0.1353352832366127, 14)
+  })
+
+  it('should handle special values', () => {
+    expect(Exp(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Exp(Number.NEGATIVE_INFINITY)).toBe(0)
+    expect(Number.isNaN(Exp(Number.NaN))).toBe(true)
+  })
+
+  it('should handle large values', () => {
+    expect(Exp(710)).toBe(Number.POSITIVE_INFINITY)
+    // For very large negative values, result should be very close to 0
+    const result = Exp(-710)
+    expect(result).toBeLessThan(1e-300)
+    expect(result).toBeGreaterThanOrEqual(0)
+  })
+
+  it('should handle edge cases', () => {
+    expect(Exp(Number.MIN_VALUE)).toBeCloseTo(1, 14)
+    expect(Exp(-Number.MIN_VALUE)).toBeCloseTo(1, 14)
+  })
+})
+
+describe('exp', () => {
+  it('should work the same as Exp', () => {
+    expect(exp(0)).toBe(Exp(0))
+    expect(exp(1)).toBe(Exp(1))
+    expect(exp(-1)).toBe(Exp(-1))
+    expect(exp(Number.POSITIVE_INFINITY)).toBe(Exp(Number.POSITIVE_INFINITY))
+  })
+})
+
+describe('Exp2', () => {
+  it('should return correct base-2 exponential values', () => {
+    expect(Exp2(0)).toBe(1)
+    expect(Exp2(1)).toBe(2)
+    expect(Exp2(2)).toBe(4)
+    expect(Exp2(3)).toBe(8)
+    expect(Exp2(-1)).toBe(0.5)
+    expect(Exp2(-2)).toBe(0.25)
+  })
+
+  it('should handle special values', () => {
+    expect(Exp2(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Exp2(Number.NEGATIVE_INFINITY)).toBe(0)
+    expect(Number.isNaN(Exp2(Number.NaN))).toBe(true)
+  })
+
+  it('should handle large values', () => {
+    expect(Exp2(1024)).toBe(Number.POSITIVE_INFINITY)
+    // For very large negative values, result should be very close to 0
+    const result = Exp2(-1024)
+    expect(result).toBeLessThan(1e-300)
+    expect(result).toBeGreaterThanOrEqual(0)
+  })
+})
+
+describe('exp2', () => {
+  it('should work the same as Exp2', () => {
+    expect(exp2(0)).toBe(Exp2(0))
+    expect(exp2(1)).toBe(Exp2(1))
+    expect(exp2(-1)).toBe(Exp2(-1))
+    expect(exp2(Number.POSITIVE_INFINITY)).toBe(Exp2(Number.POSITIVE_INFINITY))
+  })
+})
+
+describe('expmulti', () => {
+  it('should compute e^r * 2^k correctly', () => {
+    expect(expmulti(1, 0, 0)).toBeCloseTo(Math.E, 14)
+    expect(expmulti(0, 0, 1)).toBe(2)
+    expect(expmulti(1, 0, 1)).toBeCloseTo(Math.E * 2, 14)
+  })
+}) 

package/gs/math/exp.gs.ts

@@ -0,0 +1,39 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Inf, IsInf, IsNaN } from "./bits.gs.js";
+// archExp2 and archExp imports removed - using optimized implementation
+import { Ldexp } from "./ldexp.gs.js";
+
+// Exp returns e**x, the base-e exponential of x.
+//
+// Special cases are:
+//
+//	Exp(+Inf) = +Inf
+//	Exp(NaN) = NaN
+//
+// Very large values overflow to 0 or +Inf.
+// Very small values underflow to 1.
+export function Exp(x: number): number {
+	return Math.exp(x)
+}
+
+export function exp(x: number): number {
+	return Math.exp(x)
+}
+
+// Exp2 returns 2**x, the base-2 exponential of x.
+//
+// Special cases are the same as [Exp].
+export function Exp2(x: number): number {
+	return Math.pow(2, x)
+}
+
+export function exp2(x: number): number {
+	return Math.pow(2, x)
+}
+
+// exp1 returns e**r × 2**k where r = hi - lo and |r| ≤ ln(2)/2.
+export function expmulti(hi: number, lo: number, k: number): number {
+	const r = hi - lo
+	return Math.exp(r) * Math.pow(2, k)
+}
+

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

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest'
+import { Expm1, expm1 } from './expm1.gs.js'
+
+describe('Expm1', () => {
+  it('should return correct values for small inputs', () => {
+    expect(Expm1(0)).toBe(0)
+    expect(Expm1(-0)).toBe(-0)
+    expect(Expm1(1e-10)).toBeCloseTo(1e-10, 15)
+    expect(Expm1(-1e-10)).toBeCloseTo(-1e-10, 15)
+  })
+
+  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(2)).toBeCloseTo(Math.E * Math.E - 1, 14)
+    expect(Expm1(0.5)).toBeCloseTo(Math.sqrt(Math.E) - 1, 15)
+  })
+
+  it('should handle special values', () => {
+    expect(Expm1(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Expm1(Number.NEGATIVE_INFINITY)).toBe(-1)
+    expect(Number.isNaN(Expm1(Number.NaN))).toBe(true)
+  })
+
+  it('should handle large values', () => {
+    expect(Expm1(710)).toBe(Number.POSITIVE_INFINITY)
+    expect(Expm1(-700)).toBeCloseTo(-1, 15)
+  })
+
+  it('should be more accurate than exp(x) - 1 for small x', () => {
+    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))
+  })
+})
+
+describe('expm1', () => {
+  it('should work the same as Expm1', () => {
+    expect(expm1(0)).toBe(Expm1(0))
+    expect(expm1(1)).toBe(Expm1(1))
+    expect(expm1(-1)).toBe(Expm1(-1))
+    expect(expm1(0.5)).toBe(Expm1(0.5))
+    expect(Number.isNaN(expm1(Number.NaN))).toBe(true)
+  })
+}) 

package/gs/math/expm1.gs.ts

@@ -0,0 +1,23 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Inf, IsInf, IsNaN } from "./bits.gs.js";
+
+import { Float64bits, Float64frombits } from "./unsafe.gs.js";
+
+// Expm1 returns e**x - 1, the base-e exponential of x minus 1.
+// It is more accurate than [Exp](x) - 1 when x is near zero.
+//
+// Special cases are:
+//
+//	Expm1(+Inf) = +Inf
+//	Expm1(-Inf) = -1
+//	Expm1(NaN) = NaN
+//
+// Very large values overflow to -1 or +Inf.
+export function Expm1(x: number): number {
+	return Math.expm1(x)
+}
+
+export function expm1(x: number): number {
+	return Math.expm1(x)
+}
+

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

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest'
+import { Floor, floor, Ceil, ceil, Trunc, trunc, Round, RoundToEven } from './floor.gs.js'
+
+describe('Floor', () => {
+  it('should return correct floor values', () => {
+    expect(Floor(4.8)).toBe(4)
+    expect(Floor(4.2)).toBe(4)
+    expect(Floor(-4.2)).toBe(-5)
+    expect(Floor(-4.8)).toBe(-5)
+    expect(Floor(0)).toBe(0)
+    expect(Floor(-0)).toBe(-0)
+  })
+
+  it('should handle special values', () => {
+    expect(Floor(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Floor(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Number.isNaN(Floor(Number.NaN))).toBe(true)
+  })
+
+  it('should handle integer values', () => {
+    expect(Floor(5)).toBe(5)
+    expect(Floor(-5)).toBe(-5)
+    expect(Floor(0)).toBe(0)
+  })
+})
+
+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))
+  })
+})
+
+describe('Ceil', () => {
+  it('should return correct ceiling values', () => {
+    expect(Ceil(4.2)).toBe(5)
+    expect(Ceil(4.8)).toBe(5)
+    expect(Ceil(-4.8)).toBe(-4)
+    expect(Ceil(-4.2)).toBe(-4)
+    expect(Ceil(0)).toBe(0)
+    expect(Ceil(-0)).toBe(-0)
+  })
+
+  it('should handle special values', () => {
+    expect(Ceil(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Ceil(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Number.isNaN(Ceil(Number.NaN))).toBe(true)
+  })
+
+  it('should handle integer values', () => {
+    expect(Ceil(5)).toBe(5)
+    expect(Ceil(-5)).toBe(-5)
+    expect(Ceil(0)).toBe(0)
+  })
+})
+
+describe('ceil', () => {
+  it('should work the same as Ceil', () => {
+    expect(ceil(4.2)).toBe(Ceil(4.2))
+    expect(ceil(-4.8)).toBe(Ceil(-4.8))
+    expect(ceil(Number.POSITIVE_INFINITY)).toBe(Ceil(Number.POSITIVE_INFINITY))
+  })
+})
+
+describe('Trunc', () => {
+  it('should return correct truncated values', () => {
+    expect(Trunc(4.8)).toBe(4)
+    expect(Trunc(4.2)).toBe(4)
+    expect(Trunc(-4.2)).toBe(-4)
+    expect(Trunc(-4.8)).toBe(-4)
+    expect(Trunc(0)).toBe(0)
+    expect(Trunc(-0)).toBe(-0)
+  })
+
+  it('should handle special values', () => {
+    expect(Trunc(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Trunc(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Number.isNaN(Trunc(Number.NaN))).toBe(true)
+  })
+
+  it('should handle integer values', () => {
+    expect(Trunc(5)).toBe(5)
+    expect(Trunc(-5)).toBe(-5)
+    expect(Trunc(0)).toBe(0)
+  })
+})
+
+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))
+  })
+})
+
+describe('Round', () => {
+  it('should return correct rounded values', () => {
+    expect(Round(4.5)).toBe(5)
+    expect(Round(4.4)).toBe(4)
+    expect(Round(4.6)).toBe(5)
+    expect(Round(-4.5)).toBe(-4)
+    expect(Round(-4.4)).toBe(-4)
+    expect(Round(-4.6)).toBe(-5)
+    expect(Round(0)).toBe(0)
+    expect(Round(-0)).toBe(-0)
+  })
+
+  it('should handle special values', () => {
+    expect(Round(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Round(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Number.isNaN(Round(Number.NaN))).toBe(true)
+  })
+
+  it('should handle integer values', () => {
+    expect(Round(5)).toBe(5)
+    expect(Round(-5)).toBe(-5)
+    expect(Round(0)).toBe(0)
+  })
+})
+
+describe('RoundToEven', () => {
+  it('should round ties to even', () => {
+    expect(RoundToEven(2.5)).toBe(2)
+    expect(RoundToEven(3.5)).toBe(4)
+    expect(RoundToEven(4.5)).toBe(4)
+    expect(RoundToEven(5.5)).toBe(6)
+    expect(RoundToEven(-2.5)).toBe(-2)
+    expect(RoundToEven(-3.5)).toBe(-4)
+  })
+
+  it('should round normally when not exactly halfway', () => {
+    expect(RoundToEven(2.4)).toBe(2)
+    expect(RoundToEven(2.6)).toBe(3)
+    expect(RoundToEven(-2.4)).toBe(-2)
+    expect(RoundToEven(-2.6)).toBe(-3)
+  })
+
+  it('should handle special values', () => {
+    expect(RoundToEven(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(RoundToEven(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Number.isNaN(RoundToEven(Number.NaN))).toBe(true)
+    expect(RoundToEven(0)).toBe(0)
+    expect(RoundToEven(-0)).toBe(-0)
+  })
+}) 

package/gs/math/floor.gs.ts

@@ -0,0 +1,88 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { IsInf, IsNaN } from "./bits.gs.js";
+// archCeil, archFloor, archTrunc imports removed - using optimized implementation
+import { Modf } from "./modf.gs.js";
+import { Float64bits, Float64frombits } from "./unsafe.gs.js";
+
+// Floor returns the greatest integer value less than or equal to x.
+//
+// Special cases are:
+//
+//	Floor(±0) = ±0
+//	Floor(±Inf) = ±Inf
+//	Floor(NaN) = NaN
+export function Floor(x: number): number {
+	return Math.floor(x)
+}
+
+export function floor(x: number): number {
+	return Math.floor(x)
+}
+
+// Ceil returns the least integer value greater than or equal to x.
+//
+// Special cases are:
+//
+//	Ceil(±0) = ±0
+//	Ceil(±Inf) = ±Inf
+//	Ceil(NaN) = NaN
+export function Ceil(x: number): number {
+	return Math.ceil(x)
+}
+
+export function ceil(x: number): number {
+	return Math.ceil(x)
+}
+
+// Trunc returns the integer value of x.
+//
+// Special cases are:
+//
+//	Trunc(±0) = ±0
+//	Trunc(±Inf) = ±Inf
+//	Trunc(NaN) = NaN
+export function Trunc(x: number): number {
+	return Math.trunc(x)
+}
+
+export function trunc(x: number): number {
+	return Math.trunc(x)
+}
+
+// Round returns the nearest integer, rounding half away from zero.
+//
+// Special cases are:
+//
+//	Round(±0) = ±0
+//	Round(±Inf) = ±Inf
+//	Round(NaN) = NaN
+export function Round(x: number): number {
+	return Math.round(x)
+}
+
+// RoundToEven returns the nearest integer, rounding ties to even.
+//
+// Special cases are:
+//
+//	RoundToEven(±0) = ±0
+//	RoundToEven(±Inf) = ±Inf
+//	RoundToEven(NaN) = NaN
+export function RoundToEven(x: number): number {
+	// JavaScript doesn't have a built-in round-to-even, so we implement it
+	if (isNaN(x) || !isFinite(x)) {
+		return x
+	}
+	
+	const truncated = Math.trunc(x)
+	const fractional = Math.abs(x - truncated)
+	
+	if (fractional < 0.5) {
+		return truncated
+	} else if (fractional > 0.5) {
+		return truncated + Math.sign(x)
+	} else {
+		// Exactly 0.5 - round to even
+		return truncated % 2 === 0 ? truncated : truncated + Math.sign(x)
+	}
+}
+