goscript 0.0.33 → 0.0.35

package/gs/math/asinh.gs.ts

@@ -0,0 +1,21 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { IsInf, IsNaN } from "./bits.gs.js";
+import { Log } from "./log.gs.js";
+import { Log1p } from "./log1p.gs.js";
+import { Sqrt } from "./sqrt.gs.js";
+
+// Asinh returns the inverse hyperbolic sine of x.
+//
+// Special cases are:
+//
+//	Asinh(±0) = ±0
+//	Asinh(±Inf) = ±Inf
+//	Asinh(NaN) = NaN
+export function Asinh(x: number): number {
+	return Math.asinh(x)
+}
+
+export function asinh(x: number): number {
+	return Math.asinh(x)
+}
+

package/gs/math/atan.gs.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest'
+import { Atan, atan, xatan, satan } from './atan.gs.js'
+
+describe('Atan', () => {
+  it('should return correct arctangent values', () => {
+    expect(Atan(0)).toBe(0)
+    expect(Atan(1)).toBeCloseTo(0.7853981633974483, 15)
+    expect(Atan(-1)).toBeCloseTo(-0.7853981633974483, 15)
+    expect(Atan(Math.sqrt(3))).toBeCloseTo(Math.PI / 3, 15)
+    expect(Atan(1 / Math.sqrt(3))).toBeCloseTo(Math.PI / 6, 15)
+  })
+
+  it('should handle special values', () => {
+    expect(Atan(Number.POSITIVE_INFINITY)).toBeCloseTo(Math.PI / 2, 15)
+    expect(Atan(Number.NEGATIVE_INFINITY)).toBeCloseTo(-Math.PI / 2, 15)
+    expect(Number.isNaN(Atan(Number.NaN))).toBe(true)
+  })
+
+  it('should handle edge cases', () => {
+    expect(Atan(Number.MAX_VALUE)).toBeCloseTo(Math.PI / 2, 15)
+    expect(Atan(-Number.MAX_VALUE)).toBeCloseTo(-Math.PI / 2, 15)
+    expect(Atan(Number.MIN_VALUE)).toBeCloseTo(Number.MIN_VALUE, 15)
+  })
+})
+
+describe('atan', () => {
+  it('should work the same as Atan', () => {
+    expect(atan(0)).toBe(Atan(0))
+    expect(atan(1)).toBe(Atan(1))
+    expect(atan(-1)).toBe(Atan(-1))
+    expect(atan(Number.POSITIVE_INFINITY)).toBe(Atan(Number.POSITIVE_INFINITY))
+  })
+})
+
+describe('xatan', () => {
+  it('should work for values in range [0, 0.66]', () => {
+    expect(xatan(0)).toBe(0)
+    expect(xatan(0.5)).toBeCloseTo(Math.atan(0.5), 15)
+    expect(xatan(0.66)).toBeCloseTo(Math.atan(0.66), 15)
+  })
+})
+
+describe('satan', () => {
+  it('should work for positive values', () => {
+    expect(satan(0)).toBe(0)
+    expect(satan(1)).toBeCloseTo(Math.atan(1), 15)
+    expect(satan(2)).toBeCloseTo(Math.atan(2), 15)
+  })
+}) 

package/gs/math/atan.gs.ts

@@ -0,0 +1,27 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+// xatan evaluates a series valid in the range [0, 0.66].
+export function xatan(x: number): number {
+	return Math.atan(x)
+}
+
+// satan reduces its argument (known to be positive)
+// to the range [0, 0.66] and calls xatan.
+export function satan(x: number): number {
+	return Math.atan(x)
+}
+
+// Atan returns the arctangent, in radians, of x.
+//
+// Special cases are:
+//
+//	Atan(±0) = ±0
+//	Atan(±Inf) = ±Pi/2
+export function Atan(x: number): number {
+	return Math.atan(x)
+}
+
+export function atan(x: number): number {
+	return Math.atan(x)
+}
+

package/gs/math/atan2.gs.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest'
+import { Atan2, atan2 } from './atan2.gs.js'
+
+describe('Atan2', () => {
+  it('should return correct arctangent values for basic cases', () => {
+    expect(Atan2(1, 1)).toBeCloseTo(Math.PI / 4, 15)
+    expect(Atan2(1, -1)).toBeCloseTo(3 * Math.PI / 4, 15)
+    expect(Atan2(-1, 1)).toBeCloseTo(-Math.PI / 4, 15)
+    expect(Atan2(-1, -1)).toBeCloseTo(-3 * Math.PI / 4, 15)
+  })
+
+  it('should handle zero cases correctly', () => {
+    expect(Atan2(0, 1)).toBe(0)
+    expect(Atan2(0, -1)).toBeCloseTo(Math.PI, 15)
+    expect(Atan2(1, 0)).toBeCloseTo(Math.PI / 2, 15)
+    expect(Atan2(-1, 0)).toBeCloseTo(-Math.PI / 2, 15)
+  })
+
+  it('should handle infinity cases', () => {
+    expect(Atan2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY)).toBeCloseTo(Math.PI / 4, 15)
+    expect(Atan2(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY)).toBeCloseTo(-Math.PI / 4, 15)
+    expect(Atan2(Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY)).toBeCloseTo(3 * Math.PI / 4, 15)
+    expect(Atan2(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY)).toBeCloseTo(-3 * Math.PI / 4, 15)
+    
+    expect(Atan2(1, Number.POSITIVE_INFINITY)).toBe(0)
+    expect(Atan2(1, Number.NEGATIVE_INFINITY)).toBeCloseTo(Math.PI, 15)
+    expect(Atan2(-1, Number.NEGATIVE_INFINITY)).toBeCloseTo(-Math.PI, 15)
+    
+    expect(Atan2(Number.POSITIVE_INFINITY, 1)).toBeCloseTo(Math.PI / 2, 15)
+    expect(Atan2(Number.NEGATIVE_INFINITY, 1)).toBeCloseTo(-Math.PI / 2, 15)
+  })
+
+  it('should handle NaN cases', () => {
+    expect(Number.isNaN(Atan2(Number.NaN, 1))).toBe(true)
+    expect(Number.isNaN(Atan2(1, Number.NaN))).toBe(true)
+    expect(Number.isNaN(Atan2(Number.NaN, Number.NaN))).toBe(true)
+  })
+
+  it('should handle signed zero correctly', () => {
+    expect(Atan2(0, 1)).toBe(0)
+    expect(Atan2(-0, 1)).toBe(-0)
+    expect(Atan2(0, -1)).toBeCloseTo(Math.PI, 15)
+    expect(Atan2(-0, -1)).toBeCloseTo(-Math.PI, 15)
+  })
+})
+
+describe('atan2', () => {
+  it('should work the same as Atan2', () => {
+    expect(atan2(1, 1)).toBe(Atan2(1, 1))
+    expect(atan2(1, -1)).toBe(Atan2(1, -1))
+    expect(atan2(-1, 1)).toBe(Atan2(-1, 1))
+    expect(atan2(-1, -1)).toBe(Atan2(-1, -1))
+    expect(atan2(0, 1)).toBe(Atan2(0, 1))
+  })
+}) 

package/gs/math/atan2.gs.ts

@@ -0,0 +1,37 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Atan } from "./atan.gs.js";
+import { IsInf, IsNaN, NaN } from "./bits.gs.js";
+import { Copysign } from "./copysign.gs.js";
+import { Signbit } from "./signbit.gs.js";
+
+// Atan2 returns the arc tangent of y/x, using
+// the signs of the two to determine the quadrant
+// of the return value.
+//
+// Special cases are (in order):
+//
+//	Atan2(y, NaN) = NaN
+//	Atan2(NaN, x) = NaN
+//	Atan2(+0, x>=0) = +0
+//	Atan2(-0, x>=0) = -0
+//	Atan2(+0, x<=-0) = +Pi
+//	Atan2(-0, x<=-0) = -Pi
+//	Atan2(y>0, 0) = +Pi/2
+//	Atan2(y<0, 0) = -Pi/2
+//	Atan2(+Inf, +Inf) = +Pi/4
+//	Atan2(-Inf, +Inf) = -Pi/4
+//	Atan2(+Inf, -Inf) = 3Pi/4
+//	Atan2(-Inf, -Inf) = -3Pi/4
+//	Atan2(y, +Inf) = 0
+//	Atan2(y>0, -Inf) = +Pi
+//	Atan2(y<0, -Inf) = -Pi
+//	Atan2(+Inf, x) = +Pi/2
+//	Atan2(-Inf, x) = -Pi/2
+export function Atan2(y: number, x: number): number {
+	return Math.atan2(y, x)
+}
+
+export function atan2(y: number, x: number): number {
+	return Math.atan2(y, x)
+}
+

package/gs/math/atanh.gs.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest'
+import { Atanh, atanh } from './atanh.gs.js'
+
+describe('Atanh', () => {
+  it('should return correct inverse hyperbolic tangent values', () => {
+    expect(Atanh(0)).toBe(0)
+    expect(Atanh(-0)).toBe(-0)
+    expect(Atanh(0.5)).toBeCloseTo(0.5493061443340549, 15)
+    expect(Atanh(-0.5)).toBeCloseTo(-0.5493061443340549, 15)
+    expect(Atanh(0.9)).toBeCloseTo(1.4722194895832204, 15)
+    expect(Atanh(-0.9)).toBeCloseTo(-1.4722194895832204, 15)
+  })
+
+  it('should return infinity for boundary values', () => {
+    expect(Atanh(1)).toBe(Number.POSITIVE_INFINITY)
+    expect(Atanh(-1)).toBe(Number.NEGATIVE_INFINITY)
+  })
+
+  it('should return NaN for values outside [-1, 1]', () => {
+    expect(Number.isNaN(Atanh(1.1))).toBe(true)
+    expect(Number.isNaN(Atanh(-1.1))).toBe(true)
+    expect(Number.isNaN(Atanh(2))).toBe(true)
+    expect(Number.isNaN(Atanh(-2))).toBe(true)
+  })
+
+  it('should handle special values', () => {
+    expect(Number.isNaN(Atanh(Number.POSITIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Atanh(Number.NEGATIVE_INFINITY))).toBe(true)
+    expect(Number.isNaN(Atanh(Number.NaN))).toBe(true)
+  })
+
+  it('should handle edge cases', () => {
+    expect(Number.isNaN(Atanh(Number.MAX_VALUE))).toBe(true)
+    expect(Number.isNaN(Atanh(-Number.MAX_VALUE))).toBe(true)
+    expect(Atanh(Number.MIN_VALUE)).toBeCloseTo(Number.MIN_VALUE, 15)
+  })
+})
+
+describe('atanh', () => {
+  it('should work the same as Atanh', () => {
+    expect(atanh(0)).toBe(Atanh(0))
+    expect(atanh(0.5)).toBe(Atanh(0.5))
+    expect(atanh(-0.5)).toBe(Atanh(-0.5))
+    expect(atanh(1)).toBe(Atanh(1))
+    expect(atanh(-1)).toBe(Atanh(-1))
+  })
+}) 

package/gs/math/atanh.gs.ts

@@ -0,0 +1,21 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Inf, IsNaN, NaN } from "./bits.gs.js";
+import { Log1p } from "./log1p.gs.js";
+
+// Atanh returns the inverse hyperbolic tangent of x.
+//
+// Special cases are:
+//
+//	Atanh(1) = +Inf
+//	Atanh(±0) = ±0
+//	Atanh(-1) = -Inf
+//	Atanh(x) = NaN if x < -1 or x > 1
+//	Atanh(NaN) = NaN
+export function Atanh(x: number): number {
+	return Math.atanh(x)
+}
+
+export function atanh(x: number): number {
+	return Math.atanh(x)
+}
+

package/gs/math/bits.gs.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest'
+import { Inf, NaN as MathNaN, IsNaN, IsInf, normalize } from './bits.gs.js'
+
+describe('Inf', () => {
+  it('should return positive infinity for positive sign', () => {
+    expect(Inf(1)).toBe(Number.POSITIVE_INFINITY)
+    expect(Inf(100)).toBe(Number.POSITIVE_INFINITY)
+  })
+
+  it('should return negative infinity for negative sign', () => {
+    expect(Inf(-1)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Inf(-100)).toBe(Number.NEGATIVE_INFINITY)
+  })
+
+  it('should return positive infinity for zero sign', () => {
+    expect(Inf(0)).toBe(Number.POSITIVE_INFINITY)
+  })
+})
+
+describe('NaN', () => {
+  it('should return NaN', () => {
+    expect(Number.isNaN(MathNaN())).toBe(true)
+  })
+})
+
+describe('IsNaN', () => {
+  it('should identify NaN correctly', () => {
+    expect(IsNaN(Number.NaN)).toBe(true)
+    expect(IsNaN(MathNaN())).toBe(true)
+  })
+
+  it('should return false for non-NaN values', () => {
+    expect(IsNaN(0)).toBe(false)
+    expect(IsNaN(1)).toBe(false)
+    expect(IsNaN(-1)).toBe(false)
+    expect(IsNaN(Number.POSITIVE_INFINITY)).toBe(false)
+    expect(IsNaN(Number.NEGATIVE_INFINITY)).toBe(false)
+  })
+})
+
+describe('IsInf', () => {
+  it('should identify positive infinity when sign > 0', () => {
+    expect(IsInf(Number.POSITIVE_INFINITY, 1)).toBe(true)
+    expect(IsInf(Number.NEGATIVE_INFINITY, 1)).toBe(false)
+    expect(IsInf(1, 1)).toBe(false)
+  })
+
+  it('should identify negative infinity when sign < 0', () => {
+    expect(IsInf(Number.NEGATIVE_INFINITY, -1)).toBe(true)
+    expect(IsInf(Number.POSITIVE_INFINITY, -1)).toBe(false)
+    expect(IsInf(-1, -1)).toBe(false)
+  })
+
+  it('should identify any infinity when sign == 0', () => {
+    expect(IsInf(Number.POSITIVE_INFINITY, 0)).toBe(true)
+    expect(IsInf(Number.NEGATIVE_INFINITY, 0)).toBe(true)
+    expect(IsInf(1, 0)).toBe(false)
+    expect(IsInf(Number.NaN, 0)).toBe(false)
+  })
+})
+
+describe('normalize', () => {
+  it('should return input for normal numbers', () => {
+    const [y, exp] = normalize(1.5)
+    expect(y).toBe(1.5)
+    expect(exp).toBe(0)
+  })
+
+  it('should normalize subnormal numbers', () => {
+    const smallValue = 1e-320 // A subnormal number
+    const [y, exp] = normalize(smallValue)
+    expect(Math.abs(y)).toBeCloseTo(smallValue * Math.pow(2, 52), 10)
+    expect(exp).toBe(-52)
+    expect(y * Math.pow(2, exp)).toBeCloseTo(smallValue, 300)
+  })
+
+  it('should handle negative values', () => {
+    const [y, exp] = normalize(-1.5)
+    expect(y).toBe(-1.5)
+    expect(exp).toBe(0)
+  })
+
+  it('should handle zero', () => {
+    const [y, exp] = normalize(0)
+    expect(y).toBe(0)
+    expect(exp).toBe(-52)
+  })
+}) 

package/gs/math/bits.gs.ts

@@ -0,0 +1,61 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Abs } from "./abs.gs.js";
+import { Float64frombits } from "./unsafe.gs.js";
+
+let uvnan: number = 0x7FF8000000000001
+
+let uvinf: number = 0x7FF0000000000000
+
+let uvneginf: number = 0xFFF0000000000000
+
+let uvone: number = 0x3FF0000000000000
+
+let mask: number = 0x7FF
+
+let shift: number = 64 - 11 - 1
+
+let bias: number = 1023
+
+let signMask: number = Number.MAX_SAFE_INTEGER
+
+let fracMask: number = (1 << 52) - 1
+
+// Inf returns positive infinity if sign >= 0, negative infinity if sign < 0.
+export function Inf(sign: number): number {
+	return sign >= 0 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY
+}
+
+// NaN returns an IEEE 754 "not-a-number" value.
+export function NaN(): number {
+	return Number.NaN
+}
+
+// IsNaN reports whether f is an IEEE 754 "not-a-number" value.
+export function IsNaN(f: number): boolean {
+	return Number.isNaN(f)
+}
+
+// IsInf reports whether f is an infinity, according to sign.
+// If sign > 0, IsInf reports whether f is positive infinity.
+// If sign < 0, IsInf reports whether f is negative infinity.
+// If sign == 0, IsInf reports whether f is either infinity.
+export function IsInf(f: number, sign: number): boolean {
+	if (sign > 0) {
+		return f === Number.POSITIVE_INFINITY
+	} else if (sign < 0) {
+		return f === Number.NEGATIVE_INFINITY
+	} else {
+		return !Number.isFinite(f) && !Number.isNaN(f)
+	}
+}
+
+// normalize returns a normal number y and exponent exp
+// satisfying x == y × 2**exp. It assumes x is finite and non-zero.
+export function normalize(x: number): [number, number] {
+	const SmallestNormal = 2.2250738585072014e-308
+	if (Math.abs(x) < SmallestNormal) {
+		return [x * (1 << 52), -52]
+	}
+	return [x, 0]
+}
+

package/gs/math/cbrt.gs.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest'
+import { Cbrt, cbrt } from './cbrt.gs.js'
+
+describe('Cbrt', () => {
+  it('should return correct cube root values', () => {
+    expect(Cbrt(0)).toBe(0)
+    expect(Cbrt(-0)).toBe(-0)
+    expect(Cbrt(1)).toBe(1)
+    expect(Cbrt(8)).toBe(2)
+    expect(Cbrt(27)).toBe(3)
+    expect(Cbrt(64)).toBe(4)
+    expect(Cbrt(125)).toBe(5)
+  })
+
+  it('should handle negative values', () => {
+    expect(Cbrt(-1)).toBe(-1)
+    expect(Cbrt(-8)).toBe(-2)
+    expect(Cbrt(-27)).toBe(-3)
+    expect(Cbrt(-64)).toBe(-4)
+    expect(Cbrt(-125)).toBe(-5)
+  })
+
+  it('should handle fractional values', () => {
+    expect(Cbrt(0.125)).toBeCloseTo(0.5, 14)
+    expect(Cbrt(0.001)).toBeCloseTo(0.1, 14)
+    expect(Cbrt(2)).toBeCloseTo(1.2599210498948732, 15)
+    expect(Cbrt(3)).toBeCloseTo(1.4422495703074083, 15)
+  })
+
+  it('should handle special values', () => {
+    expect(Cbrt(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY)
+    expect(Cbrt(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Number.isNaN(Cbrt(Number.NaN))).toBe(true)
+  })
+
+  it('should handle edge cases', () => {
+    expect(Cbrt(Number.MAX_VALUE)).toBeCloseTo(5.643803094122362e102, 90)
+    expect(Cbrt(Number.MIN_VALUE)).toBeCloseTo(3.725290298461914e-109, 100)
+    expect(Cbrt(-Number.MAX_VALUE)).toBeCloseTo(-5.643803094122362e102, 90)
+  })
+
+  it('should handle very small values', () => {
+    expect(Cbrt(1e-100)).toBeCloseTo(2.154434690031884e-34, 30)
+    expect(Cbrt(-1e-100)).toBeCloseTo(-2.154434690031884e-34, 30)
+  })
+})
+
+describe('cbrt', () => {
+  it('should work the same as Cbrt', () => {
+    expect(cbrt(0)).toBe(Cbrt(0))
+    expect(cbrt(1)).toBe(Cbrt(1))
+    expect(cbrt(8)).toBe(Cbrt(8))
+    expect(cbrt(-8)).toBe(Cbrt(-8))
+    expect(cbrt(Number.POSITIVE_INFINITY)).toBe(Cbrt(Number.POSITIVE_INFINITY))
+    expect(cbrt(0.125)).toBe(Cbrt(0.125))
+  })
+}) 

package/gs/math/cbrt.gs.ts

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

package/gs/math/const.gs.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest'
+import {
+  E, Pi, Phi, Sqrt2, SqrtE, SqrtPi, SqrtPhi, Ln2, Log2E, Ln10, Log10E,
+  MaxFloat32, SmallestNonzeroFloat32, MaxFloat64, SmallestNonzeroFloat64,
+  MaxInt, MinInt, MaxInt8, MinInt8, MaxInt16, MinInt16, MaxInt32, MinInt32,
+  MaxInt64, MinInt64, MaxUint, MaxUint8, MaxUint16, MaxUint32, MaxUint64
+} from './const.gs.js'
+
+describe('Mathematical Constants', () => {
+  it('should have correct mathematical constants', () => {
+    expect(E).toBe(Math.E)
+    expect(Pi).toBe(Math.PI)
+    expect(Sqrt2).toBe(Math.SQRT2)
+    expect(SqrtE).toBe(Math.sqrt(Math.E))
+    expect(SqrtPi).toBe(Math.sqrt(Math.PI))
+    expect(Ln2).toBe(Math.LN2)
+    expect(Log2E).toBe(Math.LOG2E)
+    expect(Ln10).toBe(Math.LN10)
+    expect(Log10E).toBe(Math.LOG10E)
+  })
+
+  it('should have correct Phi (golden ratio)', () => {
+    expect(Phi).toBeCloseTo(1.618033988749895, 15)
+    expect(SqrtPhi).toBeCloseTo(Math.sqrt(1.618033988749895), 15)
+  })
+
+  it('should have correct float limits', () => {
+    expect(MaxFloat32).toBe(3.4028234663852886e+38)
+    expect(SmallestNonzeroFloat32).toBe(1.401298464324817e-45)
+    expect(MaxFloat64).toBe(Number.MAX_VALUE)
+    expect(SmallestNonzeroFloat64).toBe(Number.MIN_VALUE)
+  })
+
+  it('should have correct integer limits', () => {
+    expect(MaxInt8).toBe(127)
+    expect(MinInt8).toBe(-128)
+    expect(MaxInt16).toBe(32767)
+    expect(MinInt16).toBe(-32768)
+    expect(MaxInt32).toBe(2147483647)
+    expect(MinInt32).toBe(-2147483648)
+    expect(MaxUint8).toBe(255)
+    expect(MaxUint16).toBe(65535)
+    expect(MaxUint32).toBe(4294967295)
+  })
+
+  it('should have correct bigint limits', () => {
+    expect(MaxInt).toBe(9223372036854775807n)
+    expect(MinInt).toBe(-9223372036854775808n)
+    expect(MaxInt64).toBe(9223372036854775807n)
+    expect(MinInt64).toBe(-9223372036854775808n)
+    expect(MaxUint).toBe(0xFFFFFFFFFFFFFFFFn)
+    expect(MaxUint64).toBe(0xFFFFFFFFFFFFFFFFn)
+  })
+}) 

package/gs/math/const.gs.ts

@@ -0,0 +1,93 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+// https://oeis.org/A001113
+export let E: number = Math.E
+
+// https://oeis.org/A000796
+export let Pi: number = Math.PI
+
+// https://oeis.org/A001622
+export let Phi: number = 1.61803398874989484820458683436563811772030917980576286213544862
+
+// https://oeis.org/A002193
+export let Sqrt2: number = Math.SQRT2
+
+// https://oeis.org/A019774
+export let SqrtE: number = Math.sqrt(Math.E)
+
+// https://oeis.org/A002161
+export let SqrtPi: number = Math.sqrt(Math.PI)
+
+// https://oeis.org/A139339
+export let SqrtPhi: number = Math.sqrt(1.61803398874989484820458683436563811772030917980576286213544862)
+
+// https://oeis.org/A002162
+export let Ln2: number = Math.LN2
+
+export let Log2E: number = Math.LOG2E
+
+// https://oeis.org/A002392
+export let Ln10: number = Math.LN10
+
+export let Log10E: number = Math.LOG10E
+
+// 3.40282346638528859811704183484516925440e+38
+export let MaxFloat32: number = 3.4028234663852886e+38
+
+// 1.401298464324817070923729583289916131280e-45
+export let SmallestNonzeroFloat32: number = 1.401298464324817e-45
+
+// 1.79769313486231570814527423731704356798070e+308
+export let MaxFloat64: number = Number.MAX_VALUE
+
+// 4.9406564584124654417656879286822137236505980e-324
+export let SmallestNonzeroFloat64: number = Number.MIN_VALUE
+
+// 32 or 64
+let intSize: number = (32 << ((~(0 as number) >> 63)))
+
+// MaxInt32 or MaxInt64 depending on intSize.
+export let MaxInt: bigint = 9223372036854775807n
+
+// MinInt32 or MinInt64 depending on intSize.
+export let MinInt: bigint = -9223372036854775808n
+
+// 127
+export let MaxInt8: number = 127
+
+// -128
+export let MinInt8: number = -128
+
+// 32767
+export let MaxInt16: number = 32767
+
+// -32768
+export let MinInt16: number = -32768
+
+// 2147483647
+export let MaxInt32: number = 2147483647
+
+// -2147483648
+export let MinInt32: number = -2147483648
+
+// 9223372036854775807
+export let MaxInt64: bigint = 9223372036854775807n
+
+// -9223372036854775808
+export let MinInt64: bigint = -9223372036854775808n
+
+// MaxUint32 or MaxUint64 depending on intSize.
+export let MaxUint: bigint = 0xFFFFFFFFFFFFFFFFn
+
+// 255
+export let MaxUint8: number = 255
+
+// 65535
+export let MaxUint16: number = 65535
+
+// 4294967295
+export let MaxUint32: number = 4294967295
+
+// 18446744073709551615
+export let MaxUint64: bigint = 0xFFFFFFFFFFFFFFFFn
+

package/gs/math/copysign.gs.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest'
+import { Copysign } from './copysign.gs.js'
+
+describe('Copysign', () => {
+  it('should return value with magnitude of f and sign of sign', () => {
+    expect(Copysign(5, 1)).toBe(5)
+    expect(Copysign(5, -1)).toBe(-5)
+    expect(Copysign(-5, 1)).toBe(5)
+    expect(Copysign(-5, -1)).toBe(-5)
+  })
+
+  it('should handle zero values correctly', () => {
+    expect(Copysign(0, 1)).toBe(0)
+    expect(Copysign(0, -1)).toBe(-0)
+    expect(Copysign(-0, 1)).toBe(0)
+    expect(Copysign(-0, -1)).toBe(-0)
+  })
+
+  it('should handle infinity values', () => {
+    expect(Copysign(Number.POSITIVE_INFINITY, 1)).toBe(Number.POSITIVE_INFINITY)
+    expect(Copysign(Number.POSITIVE_INFINITY, -1)).toBe(Number.NEGATIVE_INFINITY)
+    expect(Copysign(Number.NEGATIVE_INFINITY, 1)).toBe(Number.POSITIVE_INFINITY)
+    expect(Copysign(Number.NEGATIVE_INFINITY, -1)).toBe(Number.NEGATIVE_INFINITY)
+  })
+
+  it('should handle NaN values', () => {
+    expect(Number.isNaN(Copysign(Number.NaN, 1))).toBe(true)
+    expect(Number.isNaN(Copysign(Number.NaN, -1))).toBe(true)
+    expect(Copysign(5, Number.NaN)).toBe(5) // NaN is positive
+  })
+
+  it('should handle fractional values', () => {
+    expect(Copysign(3.14, 1)).toBe(3.14)
+    expect(Copysign(3.14, -1)).toBe(-3.14)
+    expect(Copysign(-3.14, 1)).toBe(3.14)
+    expect(Copysign(-3.14, -1)).toBe(-3.14)
+  })
+
+  it('should handle edge cases with signed zero', () => {
+    expect(Object.is(Copysign(5, -0), -5)).toBe(true)
+    expect(Object.is(Copysign(-5, -0), -5)).toBe(true)
+    expect(Object.is(Copysign(0, -0), -0)).toBe(true)
+  })
+})