// Generated by Lisette bindgen
// Source: math (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.11

/// Abs returns the absolute value of x.
/// 
/// Special cases are:
/// 
/// 	Abs(±Inf) = +Inf
/// 	Abs(NaN) = NaN
pub fn Abs(x: float64) -> float64

/// Acos returns the arccosine, in radians, of x.
/// 
/// Special case is:
/// 
/// 	Acos(x) = NaN if x < -1 or x > 1
pub fn Acos(x: float64) -> float64

/// Acosh returns the inverse hyperbolic cosine of x.
/// 
/// Special cases are:
/// 
/// 	Acosh(+Inf) = +Inf
/// 	Acosh(x) = NaN if x < 1
/// 	Acosh(NaN) = NaN
pub fn Acosh(x: float64) -> float64

/// Asin returns the arcsine, in radians, of x.
/// 
/// Special cases are:
/// 
/// 	Asin(±0) = ±0
/// 	Asin(x) = NaN if x < -1 or x > 1
pub fn Asin(x: float64) -> float64

/// Asinh returns the inverse hyperbolic sine of x.
/// 
/// Special cases are:
/// 
/// 	Asinh(±0) = ±0
/// 	Asinh(±Inf) = ±Inf
/// 	Asinh(NaN) = NaN
pub fn Asinh(x: float64) -> float64

/// Atan returns the arctangent, in radians, of x.
/// 
/// Special cases are:
/// 
/// 	Atan(±0) = ±0
/// 	Atan(±Inf) = ±Pi/2
pub fn Atan(x: float64) -> float64

/// 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
pub fn Atan2(y: float64, x: float64) -> float64

/// 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
pub fn Atanh(x: float64) -> float64

/// Cbrt returns the cube root of x.
/// 
/// Special cases are:
/// 
/// 	Cbrt(±0) = ±0
/// 	Cbrt(±Inf) = ±Inf
/// 	Cbrt(NaN) = NaN
pub fn Cbrt(x: float64) -> float64

/// Ceil returns the least integer value greater than or equal to x.
/// 
/// Special cases are:
/// 
/// 	Ceil(±0) = ±0
/// 	Ceil(±Inf) = ±Inf
/// 	Ceil(NaN) = NaN
pub fn Ceil(x: float64) -> float64

/// Copysign returns a value with the magnitude of f
/// and the sign of sign.
pub fn Copysign(f: float64, sign: float64) -> float64

/// Cos returns the cosine of the radian argument x.
/// 
/// Special cases are:
/// 
/// 	Cos(±Inf) = NaN
/// 	Cos(NaN) = NaN
pub fn Cos(x: float64) -> float64

/// Cosh returns the hyperbolic cosine of x.
/// 
/// Special cases are:
/// 
/// 	Cosh(±0) = 1
/// 	Cosh(±Inf) = +Inf
/// 	Cosh(NaN) = NaN
pub fn Cosh(x: float64) -> float64

/// Dim returns the maximum of x-y or 0.
/// 
/// Special cases are:
/// 
/// 	Dim(+Inf, +Inf) = NaN
/// 	Dim(-Inf, -Inf) = NaN
/// 	Dim(x, NaN) = Dim(NaN, x) = NaN
pub fn Dim(x: float64, y: float64) -> float64

/// Erf returns the error function of x.
/// 
/// Special cases are:
/// 
/// 	Erf(+Inf) = 1
/// 	Erf(-Inf) = -1
/// 	Erf(NaN) = NaN
pub fn Erf(x: float64) -> float64

/// Erfc returns the complementary error function of x.
/// 
/// Special cases are:
/// 
/// 	Erfc(+Inf) = 0
/// 	Erfc(-Inf) = 2
/// 	Erfc(NaN) = NaN
pub fn Erfc(x: float64) -> float64

/// 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
pub fn Erfcinv(x: float64) -> float64

/// 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
pub fn Erfinv(x: float64) -> float64

/// 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.
pub fn Exp(x: float64) -> float64

/// Exp2 returns 2**x, the base-2 exponential of x.
/// 
/// Special cases are the same as [Exp].
pub fn Exp2(x: float64) -> float64

/// 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.
pub fn Expm1(x: float64) -> float64

/// FMA returns x * y + z, computed with only one rounding.
/// (That is, FMA returns the fused multiply-add of x, y, and z.)
pub fn FMA(x: float64, y: float64, z: float64) -> float64

/// Float32bits returns the IEEE 754 binary representation of f,
/// with the sign bit of f and the result in the same bit position.
/// Float32bits(Float32frombits(x)) == x.
pub fn Float32bits(f: float32) -> uint32

/// Float32frombits returns the floating-point number corresponding
/// to the IEEE 754 binary representation b, with the sign bit of b
/// and the result in the same bit position.
/// Float32frombits(Float32bits(x)) == x.
pub fn Float32frombits(b: uint32) -> float32

/// Float64bits returns the IEEE 754 binary representation of f,
/// with the sign bit of f and the result in the same bit position,
/// and Float64bits(Float64frombits(x)) == x.
pub fn Float64bits(f: float64) -> uint64

/// Float64frombits returns the floating-point number corresponding
/// to the IEEE 754 binary representation b, with the sign bit of b
/// and the result in the same bit position.
/// Float64frombits(Float64bits(x)) == x.
pub fn Float64frombits(b: uint64) -> float64

/// Floor returns the greatest integer value less than or equal to x.
/// 
/// Special cases are:
/// 
/// 	Floor(±0) = ±0
/// 	Floor(±Inf) = ±Inf
/// 	Floor(NaN) = NaN
pub fn Floor(x: float64) -> float64

/// Frexp breaks f into a normalized fraction
/// and an integral power of two.
/// It returns frac and exp satisfying f == frac × 2**exp,
/// with the absolute value of frac in the interval [½, 1).
/// 
/// Special cases are:
/// 
/// 	Frexp(±0) = ±0, 0
/// 	Frexp(±Inf) = ±Inf, 0
/// 	Frexp(NaN) = NaN, 0
pub fn Frexp(f: float64) -> (float64, int)

/// Gamma returns the Gamma function of x.
/// 
/// Special cases are:
/// 
/// 	Gamma(+Inf) = +Inf
/// 	Gamma(+0) = +Inf
/// 	Gamma(-0) = -Inf
/// 	Gamma(x) = NaN for integer x < 0
/// 	Gamma(-Inf) = NaN
/// 	Gamma(NaN) = NaN
pub fn Gamma(x: float64) -> float64

/// Hypot returns [Sqrt](p*p + q*q), taking care to avoid
/// unnecessary overflow and underflow.
/// 
/// Special cases are:
/// 
/// 	Hypot(±Inf, q) = +Inf
/// 	Hypot(p, ±Inf) = +Inf
/// 	Hypot(NaN, q) = NaN
/// 	Hypot(p, NaN) = NaN
pub fn Hypot(p: float64, q: float64) -> float64

/// Ilogb returns the binary exponent of x as an integer.
/// 
/// Special cases are:
/// 
/// 	Ilogb(±Inf) = MaxInt32
/// 	Ilogb(0) = MinInt32
/// 	Ilogb(NaN) = MaxInt32
pub fn Ilogb(x: float64) -> int

/// Inf returns positive infinity if sign >= 0, negative infinity if sign < 0.
pub fn Inf(sign: int) -> float64

/// 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.
pub fn IsInf(f: float64, sign: int) -> bool

/// IsNaN reports whether f is an IEEE 754 “not-a-number” value.
pub fn IsNaN(f: float64) -> bool

/// J0 returns the order-zero Bessel function of the first kind.
/// 
/// Special cases are:
/// 
/// 	J0(±Inf) = 0
/// 	J0(0) = 1
/// 	J0(NaN) = NaN
pub fn J0(x: float64) -> float64

/// J1 returns the order-one Bessel function of the first kind.
/// 
/// Special cases are:
/// 
/// 	J1(±Inf) = 0
/// 	J1(NaN) = NaN
pub fn J1(x: float64) -> float64

/// Jn returns the order-n Bessel function of the first kind.
/// 
/// Special cases are:
/// 
/// 	Jn(n, ±Inf) = 0
/// 	Jn(n, NaN) = NaN
pub fn Jn(n: int, x: float64) -> float64

/// Ldexp is the inverse of [Frexp].
/// It returns frac × 2**exp.
/// 
/// Special cases are:
/// 
/// 	Ldexp(±0, exp) = ±0
/// 	Ldexp(±Inf, exp) = ±Inf
/// 	Ldexp(NaN, exp) = NaN
pub fn Ldexp(frac: float64, exp: int) -> float64

/// Lgamma returns the natural logarithm and sign (-1 or +1) of [Gamma](x).
/// 
/// Special cases are:
/// 
/// 	Lgamma(+Inf) = +Inf
/// 	Lgamma(0) = +Inf
/// 	Lgamma(-integer) = +Inf
/// 	Lgamma(-Inf) = -Inf
/// 	Lgamma(NaN) = NaN
pub fn Lgamma(x: float64) -> (float64, int)

/// Log returns the natural logarithm of x.
/// 
/// Special cases are:
/// 
/// 	Log(+Inf) = +Inf
/// 	Log(0) = -Inf
/// 	Log(x < 0) = NaN
/// 	Log(NaN) = NaN
pub fn Log(x: float64) -> float64

/// Log10 returns the decimal logarithm of x.
/// The special cases are the same as for [Log].
pub fn Log10(x: float64) -> float64

/// Log1p returns the natural logarithm of 1 plus its argument x.
/// It is more accurate than [Log](1 + x) when x is near zero.
/// 
/// Special cases are:
/// 
/// 	Log1p(+Inf) = +Inf
/// 	Log1p(±0) = ±0
/// 	Log1p(-1) = -Inf
/// 	Log1p(x < -1) = NaN
/// 	Log1p(NaN) = NaN
pub fn Log1p(x: float64) -> float64

/// Log2 returns the binary logarithm of x.
/// The special cases are the same as for [Log].
pub fn Log2(x: float64) -> float64

/// Logb returns the binary exponent of x.
/// 
/// Special cases are:
/// 
/// 	Logb(±Inf) = +Inf
/// 	Logb(0) = -Inf
/// 	Logb(NaN) = NaN
pub fn Logb(x: float64) -> float64

/// Max returns the larger of x or y.
/// 
/// Special cases are:
/// 
/// 	Max(x, +Inf) = Max(+Inf, x) = +Inf
/// 	Max(x, NaN) = Max(NaN, x) = NaN
/// 	Max(+0, ±0) = Max(±0, +0) = +0
/// 	Max(-0, -0) = -0
/// 
/// Note that this differs from the built-in function max when called
/// with NaN and +Inf.
pub fn Max(x: float64, y: float64) -> float64

/// Min returns the smaller of x or y.
/// 
/// Special cases are:
/// 
/// 	Min(x, -Inf) = Min(-Inf, x) = -Inf
/// 	Min(x, NaN) = Min(NaN, x) = NaN
/// 	Min(-0, ±0) = Min(±0, -0) = -0
/// 
/// Note that this differs from the built-in function min when called
/// with NaN and -Inf.
pub fn Min(x: float64, y: float64) -> float64

/// Mod returns the floating-point remainder of x/y.
/// The magnitude of the result is less than y and its
/// sign agrees with that of x.
/// 
/// Special cases are:
/// 
/// 	Mod(±Inf, y) = NaN
/// 	Mod(NaN, y) = NaN
/// 	Mod(x, 0) = NaN
/// 	Mod(x, ±Inf) = x
/// 	Mod(x, NaN) = NaN
pub fn Mod(x: float64, y: float64) -> float64

/// Modf returns integer and fractional floating-point numbers
/// that sum to f. Both values have the same sign as f.
/// 
/// Special cases are:
/// 
/// 	Modf(±Inf) = ±Inf, NaN
/// 	Modf(NaN) = NaN, NaN
pub fn Modf(f: float64) -> (float64, float64)

/// NaN returns an IEEE 754 “not-a-number” value.
pub fn NaN() -> float64

/// Nextafter returns the next representable float64 value after x towards y.
/// 
/// Special cases are:
/// 
/// 	Nextafter(x, x)   = x
/// 	Nextafter(NaN, y) = NaN
/// 	Nextafter(x, NaN) = NaN
pub fn Nextafter(x: float64, y: float64) -> float64

/// Nextafter32 returns the next representable float32 value after x towards y.
/// 
/// Special cases are:
/// 
/// 	Nextafter32(x, x)   = x
/// 	Nextafter32(NaN, y) = NaN
/// 	Nextafter32(x, NaN) = NaN
pub fn Nextafter32(x: float32, y: float32) -> float32

/// Pow returns x**y, the base-x exponential of y.
/// 
/// Special cases are (in order):
/// 
/// 	Pow(x, ±0) = 1 for any x
/// 	Pow(1, y) = 1 for any y
/// 	Pow(x, 1) = x for any x
/// 	Pow(NaN, y) = NaN
/// 	Pow(x, NaN) = NaN
/// 	Pow(±0, y) = ±Inf for y an odd integer < 0
/// 	Pow(±0, -Inf) = +Inf
/// 	Pow(±0, +Inf) = +0
/// 	Pow(±0, y) = +Inf for finite y < 0 and not an odd integer
/// 	Pow(±0, y) = ±0 for y an odd integer > 0
/// 	Pow(±0, y) = +0 for finite y > 0 and not an odd integer
/// 	Pow(-1, ±Inf) = 1
/// 	Pow(x, +Inf) = +Inf for |x| > 1
/// 	Pow(x, -Inf) = +0 for |x| > 1
/// 	Pow(x, +Inf) = +0 for |x| < 1
/// 	Pow(x, -Inf) = +Inf for |x| < 1
/// 	Pow(+Inf, y) = +Inf for y > 0
/// 	Pow(+Inf, y) = +0 for y < 0
/// 	Pow(-Inf, y) = Pow(-0, -y)
/// 	Pow(x, y) = NaN for finite x < 0 and finite non-integer y
pub fn Pow(x: float64, y: float64) -> float64

/// 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
pub fn Pow10(n: int) -> float64

/// 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
pub fn Remainder(x: float64, y: float64) -> float64

/// Round returns the nearest integer, rounding half away from zero.
/// 
/// Special cases are:
/// 
/// 	Round(±0) = ±0
/// 	Round(±Inf) = ±Inf
/// 	Round(NaN) = NaN
pub fn Round(x: float64) -> float64

/// RoundToEven returns the nearest integer, rounding ties to even.
/// 
/// Special cases are:
/// 
/// 	RoundToEven(±0) = ±0
/// 	RoundToEven(±Inf) = ±Inf
/// 	RoundToEven(NaN) = NaN
pub fn RoundToEven(x: float64) -> float64

/// Signbit reports whether x is negative or negative zero.
pub fn Signbit(x: float64) -> bool

/// Sin returns the sine of the radian argument x.
/// 
/// Special cases are:
/// 
/// 	Sin(±0) = ±0
/// 	Sin(±Inf) = NaN
/// 	Sin(NaN) = NaN
pub fn Sin(x: float64) -> float64

/// Sincos returns Sin(x), Cos(x).
/// 
/// Special cases are:
/// 
/// 	Sincos(±0) = ±0, 1
/// 	Sincos(±Inf) = NaN, NaN
/// 	Sincos(NaN) = NaN, NaN
pub fn Sincos(x: float64) -> (float64, float64)

/// Sinh returns the hyperbolic sine of x.
/// 
/// Special cases are:
/// 
/// 	Sinh(±0) = ±0
/// 	Sinh(±Inf) = ±Inf
/// 	Sinh(NaN) = NaN
pub fn Sinh(x: float64) -> float64

/// Sqrt returns the square root of x.
/// 
/// Special cases are:
/// 
/// 	Sqrt(+Inf) = +Inf
/// 	Sqrt(±0) = ±0
/// 	Sqrt(x < 0) = NaN
/// 	Sqrt(NaN) = NaN
pub fn Sqrt(x: float64) -> float64

/// Tan returns the tangent of the radian argument x.
/// 
/// Special cases are:
/// 
/// 	Tan(±0) = ±0
/// 	Tan(±Inf) = NaN
/// 	Tan(NaN) = NaN
pub fn Tan(x: float64) -> float64

/// Tanh returns the hyperbolic tangent of x.
/// 
/// Special cases are:
/// 
/// 	Tanh(±0) = ±0
/// 	Tanh(±Inf) = ±1
/// 	Tanh(NaN) = NaN
pub fn Tanh(x: float64) -> float64

/// Trunc returns the integer value of x.
/// 
/// Special cases are:
/// 
/// 	Trunc(±0) = ±0
/// 	Trunc(±Inf) = ±Inf
/// 	Trunc(NaN) = NaN
pub fn Trunc(x: float64) -> float64

/// Y0 returns the order-zero Bessel function of the second kind.
/// 
/// Special cases are:
/// 
/// 	Y0(+Inf) = 0
/// 	Y0(0) = -Inf
/// 	Y0(x < 0) = NaN
/// 	Y0(NaN) = NaN
pub fn Y0(x: float64) -> float64

/// Y1 returns the order-one Bessel function of the second kind.
/// 
/// Special cases are:
/// 
/// 	Y1(+Inf) = 0
/// 	Y1(0) = -Inf
/// 	Y1(x < 0) = NaN
/// 	Y1(NaN) = NaN
pub fn Y1(x: float64) -> float64

/// Yn returns the order-n Bessel function of the second kind.
/// 
/// Special cases are:
/// 
/// 	Yn(n, +Inf) = 0
/// 	Yn(n ≥ 0, 0) = -Inf
/// 	Yn(n < 0, 0) = +Inf if n is odd, -Inf if n is even
/// 	Yn(n, x < 0) = NaN
/// 	Yn(n, NaN) = NaN
pub fn Yn(n: int, x: float64) -> float64

/// Mathematical constants.
const E = 2.718281828459045

/// Mathematical constants.
const Ln10 = 2.302585092994046

/// Mathematical constants.
const Ln2 = 0.6931471805599453

/// Mathematical constants.
const Log10E = 0.4342944819032518

/// Mathematical constants.
const Log2E = 1.4426950408889634

/// Floating-point limit values.
/// Max is the largest finite value representable by the type.
/// SmallestNonzero is the smallest positive, non-zero value representable by the type.
const MaxFloat32 = 3.4028234663852886e+38

/// Floating-point limit values.
/// Max is the largest finite value representable by the type.
/// SmallestNonzero is the smallest positive, non-zero value representable by the type.
const MaxFloat64 = 1.7976931348623157e+308

/// Integer limit values.
const MaxInt = 9223372036854775807

/// Integer limit values.
const MaxInt16 = 32767

/// Integer limit values.
const MaxInt32 = 2147483647

/// Integer limit values.
const MaxInt64 = 9223372036854775807

/// Integer limit values.
const MaxInt8 = 127

/// Integer limit values.
const MaxUint = 18446744073709551615

/// Integer limit values.
const MaxUint16 = 65535

/// Integer limit values.
const MaxUint32 = 4294967295

/// Integer limit values.
const MaxUint64 = 18446744073709551615

/// Integer limit values.
const MaxUint8 = 255

/// Integer limit values.
const MinInt = -9223372036854775808

/// Integer limit values.
const MinInt16 = -32768

/// Integer limit values.
const MinInt32 = -2147483648

/// Integer limit values.
const MinInt64 = -9223372036854775808

/// Integer limit values.
const MinInt8 = -128

/// Mathematical constants.
const Phi = 1.618033988749895

/// Mathematical constants.
const Pi = 3.141592653589793

/// Floating-point limit values.
/// Max is the largest finite value representable by the type.
/// SmallestNonzero is the smallest positive, non-zero value representable by the type.
const SmallestNonzeroFloat32 = 1.401298464324817e-45

/// Floating-point limit values.
/// Max is the largest finite value representable by the type.
/// SmallestNonzero is the smallest positive, non-zero value representable by the type.
const SmallestNonzeroFloat64 = 5e-324

/// Mathematical constants.
const Sqrt2 = 1.4142135623730951

/// Mathematical constants.
const SqrtE = 1.6487212707001282

/// Mathematical constants.
const SqrtPhi = 1.272019649514069

/// Mathematical constants.
const SqrtPi = 1.772453850905516
