// Generated by Lisette bindgen
// Source: math (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.14
/// 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