package core:math

Source

Float_Class :: enum int {
	Normal,    // an ordinary nonzero floating point value
	Subnormal, // a subnormal floating point value
	Zero,      // zero
	Neg_Zero,  // the negative zero
	NaN,       // Not-A-Number (NaN)
	Inf,       // positive infinity
	Neg_Inf,   // negative infinity
}

DEG_PER_RAD :: 360.0 / TAU

E :: 2.71828182845904523536

F16_BIAS :: 0xf

F16_DIG :: 3

F16_EPSILON :: 0.00097656

F16_GUARD :: 0

F16_MANT_DIG :: 11

F16_MASK :: 0x1f

F16_MAX :: 65504.0

F16_MAX_10_EXP :: 4

F16_MAX_EXP :: 15

F16_MIN :: 6.10351562e-5

F16_MIN_10_EXP :: -4

F16_MIN_EXP :: -14

F16_NORMALIZE :: 0

F16_RADIX :: 2

F16_ROUNDS :: 1

F16_SHIFT :: 16 - 6

F32_BIAS :: 0x7f

F32_DIG :: 6

F32_EPSILON :: 1.192092896e-07

F32_GUARD :: 0

F32_MANT_DIG :: 24

F32_MASK :: 0xff

F32_MAX :: 3.402823466e+38

F32_MAX_10_EXP :: 38

F32_MAX_EXP :: 128

F32_MIN :: 1.175494351e-38

F32_MIN_10_EXP :: -37

F32_MIN_EXP :: -125

F32_NORMALIZE :: 0

F32_RADIX :: 2

F32_ROUNDS :: 1

F32_SHIFT :: 32 - 9

F64_BIAS :: 0x3ff

F64_DIG :: 15

F64_EPSILON :: 2.2204460492503131e-016

F64_MANT_DIG :: 53

F64_MASK :: 0x7ff

F64_MAX :: 1.7976931348623158e+308

F64_MAX_10_EXP :: 308

F64_MAX_EXP :: 1024

F64_MIN :: 2.2250738585072014e-308

F64_MIN_10_EXP :: -307

F64_MIN_EXP :: -1021

F64_RADIX :: 2

F64_ROUNDS :: 1

F64_SHIFT :: 64 - 12

INF_F16 :: f16(0h7C00)

INF_F32 :: f32(0h7F80_0000)

INF_F64 :: f64(0h7FF0_0000_0000_0000)

LN10 :: 2.30258509299404568401799145468436421

LN2 :: 0.693147180559945309417232121458176568

MAX_F16_PRECISION :: 4

MAX_F32_PRECISION :: 8

MAX_F64_PRECISION :: 16

NEG_INF_F16 :: f16(0hFC00)

NEG_INF_F32 :: f32(0hFF80_0000)

NEG_INF_F64 :: f64(0hFFF0_0000_0000_0000)

PI :: 3.14159265358979323846264338327950288

QNAN_F16 :: f16(0h7E01)

QNAN_F32 :: f32(0hFFC0_0001)

QNAN_F64 :: f64(0h7FF8_0000_0000_0001)

RAD_PER_DEG :: TAU / 360.0

SNAN_F16 :: f16(0h7C01)

SNAN_F32 :: f32(0hFF80_0001)

SNAN_F64 :: f64(0h7FF0_0000_0000_0001)

SQRT_FIVE :: 2.23606797749978969640917366873127623

SQRT_THREE :: 1.73205080756887729352744634150587236

SQRT_TWO :: 1.41421356237309504880168872420969808

TAU :: 6.28318530717958647692528676655900576

e :: E

π :: PI

τ :: TAU

abs :: builtin.abs

acos_f16 :: proc "contextless" (x: f16) -> f16 {…}

acos_f16be :: proc "contextless" (x: f16be) -> f16be {…}

acos_f16le :: proc "contextless" (x: f16le) -> f16le {…}

acos_f32 :: proc "contextless" (x: f32) -> f32 {…}

acos_f32be :: proc "contextless" (x: f32be) -> f32be {…}

acos_f32le :: proc "contextless" (x: f32le) -> f32le {…}

acos_f64 :: proc "contextless" (x: f64) -> f64 {…}

acos_f64be :: proc "contextless" (x: f64be) -> f64be {…}

acos_f64le :: proc "contextless" (x: f64le) -> f64le {…}

acosh :: proc "contextless" (y: $T) -> $T {…}

angle_diff :: proc "contextless" (a, b: $T) -> $T {…}

angle_lerp :: proc "contextless" (a, b, t: $T) -> $T {…}

asin_f16 :: proc "contextless" (x: f16) -> f16 {…}

asin_f16be :: proc "contextless" (x: f16be) -> f16be {…}

asin_f16le :: proc "contextless" (x: f16le) -> f16le {…}

asin_f32 :: proc "contextless" (x: f32) -> f32 {…}

asin_f32be :: proc "contextless" (x: f32be) -> f32be {…}

asin_f32le :: proc "contextless" (x: f32le) -> f32le {…}

asin_f64 :: proc "contextless" (x: f64) -> f64 {…}

asin_f64be :: proc "contextless" (x: f64be) -> f64be {…}

asin_f64le :: proc "contextless" (x: f64le) -> f64le {…}

asinh :: proc "contextless" (y: $T) -> $T {…}

atan :: proc "contextless" (x: $T) -> $T {…}

atan2_f16 :: proc "contextless" (y, x: f16) -> f16 {…}

atan2_f16be :: proc "contextless" (y, x: f16be) -> f16be {…}

atan2_f16le :: proc "contextless" (y, x: f16le) -> f16le {…}

atan2_f32 :: proc "contextless" (y, x: f32) -> f32 {…}

atan2_f32be :: proc "contextless" (y, x: f32be) -> f32be {…}

atan2_f32le :: proc "contextless" (y, x: f32le) -> f32le {…}

atan2_f64 :: proc "contextless" (y, x: f64) -> f64 {…}

atan2_f64be :: proc "contextless" (y, x: f64be) -> f64be {…}

atan2_f64le :: proc "contextless" (y, x: f64le) -> f64le {…}

atanh :: proc "contextless" (y: $T) -> $T {…}

bias :: proc "contextless" (t, b: $T) -> $T {…}

binomial :: proc "contextless" (n, k: int) -> int {…}

ceil_f16 :: proc "contextless" (x: f16) -> f16 {…}

ceil_f16be :: proc "contextless" (x: f16be) -> f16be {…}

ceil_f16le :: proc "contextless" (x: f16le) -> f16le {…}

ceil_f32 :: proc "contextless" (x: f32) -> f32 {…}

ceil_f32be :: proc "contextless" (x: f32be) -> f32be {…}

ceil_f32le :: proc "contextless" (x: f32le) -> f32le {…}

ceil_f64 :: proc "contextless" (x: f64) -> f64 {…}

ceil_f64be :: proc "contextless" (x: f64be) -> f64be {…}

ceil_f64le :: proc "contextless" (x: f64le) -> f64le {…}

clamp :: builtin.clamp

classify_f16 :: proc "contextless" (x: f16) -> Float_Class {…}

classify_f16be :: proc "contextless" (x: f16be) -> Float_Class {…}

classify_f16le :: proc "contextless" (x: f16le) -> Float_Class {…}

classify_f32 :: proc "contextless" (x: f32) -> Float_Class {…}

classify_f32be :: proc "contextless" (x: f32be) -> Float_Class {…}

classify_f32le :: proc "contextless" (x: f32le) -> Float_Class {…}

classify_f64 :: proc "contextless" (x: f64) -> Float_Class {…}

classify_f64be :: proc "contextless" (x: f64be) -> Float_Class {…}

classify_f64le :: proc "contextless" (x: f64le) -> Float_Class {…}

copy_sign_f16 :: proc "contextless" (x, y: f16) -> f16 {…}

copy_sign_f16be :: proc "contextless" (x, y: f16be) -> f16be {…}

copy_sign_f16le :: proc "contextless" (x, y: f16le) -> f16le {…}

copy_sign_f32 :: proc "contextless" (x, y: f32) -> f32 {…}

copy_sign_f32be :: proc "contextless" (x, y: f32be) -> f32be {…}

copy_sign_f32le :: proc "contextless" (x, y: f32le) -> f32le {…}

copy_sign_f64 :: proc "contextless" (x, y: f64) -> f64 {…}

copy_sign_f64be :: proc "contextless" (x, y: f64be) -> f64be {…}

copy_sign_f64le :: proc "contextless" (x, y: f64le) -> f64le {…}

cos_f16 :: proc "contextless" (θ: f16) -> f16 {…}

cos_f16be :: proc "contextless" (θ: f16be) -> f16be {…}

cos_f16le :: proc "contextless" (θ: f16le) -> f16le {…}

cos_f32 :: proc "contextless" (θ: f32) -> f32 {…}

cos_f32be :: proc "contextless" (θ: f32be) -> f32be {…}

cos_f32le :: proc "contextless" (θ: f32le) -> f32le {…}

cos_f64 :: proc "contextless" (θ: f64) -> f64 {…}

cos_f64be :: proc "contextless" (θ: f64be) -> f64be {…}

cos_f64le :: proc "contextless" (θ: f64le) -> f64le {…}

cosh :: proc "contextless" (x: $T) -> $T {…}

count_digits_of_base :: proc "contextless" (value: $T, $base: int = ) -> (digits: int) {…}

cumsum :: proc "contextless" (dst, src: $T/[]$T) -> $T/[]$T {…}

cumsum_inplace :: proc "contextless" (x: $T/[]$T) {…}

divmod :: proc "contextless" (x, y: $T) -> (div, mod: $T) {…}

erf_f16 :: proc "contextless" (x: f16) -> f16 {…}

erf_f16be :: proc "contextless" (x: f16be) -> f16be {…}

erf_f16le :: proc "contextless" (x: f16le) -> f16le {…}

erf_f32 :: proc "contextless" (x: f32) -> f32 {…}

erf_f32be :: proc "contextless" (x: f32be) -> f32be {…}

erf_f32le :: proc "contextless" (x: f32le) -> f32le {…}

erf_f64 :: proc "contextless" (x: f64) -> f64 {…}

erfc_f16 :: proc "contextless" (x: f16) -> f16 {…}

erfc_f16be :: proc "contextless" (x: f16be) -> f16be {…}

erfc_f16le :: proc "contextless" (x: f16le) -> f16le {…}

erfc_f32 :: proc "contextless" (x: f32) -> f32 {…}

erfc_f32be :: proc "contextless" (x: f32be) -> f32be {…}

erfc_f32le :: proc "contextless" (x: f32le) -> f32le {…}

erfc_f64 :: proc "contextless" (x: f64) -> f64 {…}

exp_f16 :: proc "contextless" (x: f16) -> f16 {…}

exp_f16be :: proc "contextless" (x: f16be) -> f16be {…}

exp_f16le :: proc "contextless" (x: f16le) -> f16le {…}

exp_f32 :: proc "contextless" (x: f32) -> f32 {…}

exp_f32be :: proc "contextless" (x: f32be) -> f32be {…}

exp_f32le :: proc "contextless" (x: f32le) -> f32le {…}

exp_f64 :: proc "contextless" (x: f64) -> f64 {…}

exp_f64be :: proc "contextless" (x: f64be) -> f64be {…}

exp_f64le :: proc "contextless" (x: f64le) -> f64le {…}

factorial :: proc "contextless" (n: int) -> int {…}

floor_div :: proc "contextless" (x, y: $T) -> $T {…}

floor_divmod :: proc "contextless" (x, y: $T) -> (div, mod: $T) {…}

floor_f16 :: proc "contextless" (x: f16) -> f16 {…}

floor_f16be :: proc "contextless" (x: f16be) -> f16be {…}

floor_f16le :: proc "contextless" (x: f16le) -> f16le {…}

floor_f32 :: proc "contextless" (x: f32) -> f32 {…}

floor_f32be :: proc "contextless" (x: f32be) -> f32be {…}

floor_f32le :: proc "contextless" (x: f32le) -> f32le {…}

floor_f64 :: proc "contextless" (x: f64) -> f64 {…}

floor_f64be :: proc "contextless" (x: f64be) -> f64be {…}

floor_f64le :: proc "contextless" (x: f64le) -> f64le {…}

floor_mod :: proc "contextless" (x, y: $T) -> $T {…}

fmuladd_f16 :: proc "contextless" (a, b, c: f16) -> f16 {…}

fmuladd_f16be :: proc "contextless" (a, b, c: f16be) -> f16be {…}

fmuladd_f16le :: proc "contextless" (a, b, c: f16le) -> f16le {…}

fmuladd_f32 :: proc "contextless" (a, b, c: f32) -> f32 {…}

fmuladd_f32be :: proc "contextless" (a, b, c: f32be) -> f32be {…}

fmuladd_f32le :: proc "contextless" (a, b, c: f32le) -> f32le {…}

fmuladd_f64 :: proc "contextless" (a, b, c: f64) -> f64 {…}

fmuladd_f64be :: proc "contextless" (a, b, c: f64be) -> f64be {…}

fmuladd_f64le :: proc "contextless" (a, b, c: f64le) -> f64le {…}

frexp_f16 :: proc "contextless" (x: f16) -> (significand: f16, exponent: int) {…}

frexp_f16be :: proc "contextless" (x: f16be) -> (significand: f16be, exponent: int) {…}

frexp_f16le :: proc "contextless" (x: f16le) -> (significand: f16le, exponent: int) {…}

frexp_f32 :: proc "contextless" (x: f32) -> (significand: f32, exponent: int) {…}

frexp_f32be :: proc "contextless" (x: f32be) -> (significand: f32be, exponent: int) {…}

frexp_f32le :: proc "contextless" (x: f32le) -> (significand: f32le, exponent: int) {…}

frexp_f64 :: proc "contextless" (f: f64) -> (significand: f64, exponent: int) {…}

frexp_f64be :: proc "contextless" (x: f64be) -> (significand: f64be, exponent: int) {…}

frexp_f64le :: proc "contextless" (x: f64le) -> (significand: f64le, exponent: int) {…}

gain :: proc "contextless" (t, g: $T) -> $T {…}

gamma_f16 :: proc "contextless" (x: f16) -> f16 {…}

gamma_f16be :: proc "contextless" (x: f16be) -> f16be {…}

gamma_f16le :: proc "contextless" (x: f16le) -> f16le {…}

gamma_f32 :: proc "contextless" (x: f32) -> f32 {…}

gamma_f32be :: proc "contextless" (x: f32be) -> f32be {…}

gamma_f32le :: proc "contextless" (x: f32le) -> f32le {…}

gamma_f64 :: proc "contextless" (x: f64) -> f64 {…}

gamma_f64be :: proc "contextless" (x: f64be) -> f64be {…}

gamma_f64le :: proc "contextless" (x: f64le) -> f64le {…}

gcd :: proc "contextless" (x, y: $T) -> $T {…}

hypot_f16 :: proc "contextless" (x, y: f16) -> (r: f16) {…}

hypot_f16be :: proc "contextless" (x, y: f16be) -> (r: f16be) {…}

hypot_f16le :: proc "contextless" (x, y: f16le) -> (r: f16le) {…}

hypot_f32 :: proc "contextless" (x, y: f32) -> (r: f32) {…}

hypot_f32be :: proc "contextless" (x, y: f32be) -> (r: f32be) {…}

hypot_f32le :: proc "contextless" (x, y: f32le) -> (r: f32le) {…}

hypot_f64 :: proc "contextless" (x, y: f64) -> (r: f64) {…}

hypot_f64be :: proc "contextless" (x, y: f64be) -> (r: f64be) {…}

hypot_f64le :: proc "contextless" (x, y: f64le) -> (r: f64le) {…}

ilogb_f16 :: proc "contextless" (val: f16) -> int {…}

ilogb_f16be :: proc "contextless" (value: f16be) -> int {…}

ilogb_f16le :: proc "contextless" (value: f16le) -> int {…}

ilogb_f32 :: proc "contextless" (val: f32) -> int {…}

ilogb_f32be :: proc "contextless" (value: f32be) -> int {…}

ilogb_f32le :: proc "contextless" (value: f32le) -> int {…}

ilogb_f64 :: proc "contextless" (val: f64) -> int {…}

ilogb_f64be :: proc "contextless" (value: f64be) -> int {…}

ilogb_f64le :: proc "contextless" (value: f64le) -> int {…}

inf_f16 :: proc "contextless" (sign: int) -> f16 {…}

inf_f16be :: proc "contextless" (sign: int) -> f16be {…}

inf_f16le :: proc "contextless" (sign: int) -> f16le {…}

inf_f32 :: proc "contextless" (sign: int) -> f32 {…}

inf_f32be :: proc "contextless" (sign: int) -> f32be {…}

inf_f32le :: proc "contextless" (sign: int) -> f32le {…}

inf_f64 :: proc "contextless" (sign: int) -> f64 {…}

inf_f64be :: proc "contextless" (sign: int) -> f64be {…}

inf_f64le :: proc "contextless" (sign: int) -> f64le {…}

is_inf_f16 :: proc "contextless" (x: f16, sign: int = 0) -> bool {…}

is_inf_f16be :: proc "contextless" (x: f16be, sign: int = 0) -> bool {…}

is_inf_f16le :: proc "contextless" (x: f16le, sign: int = 0) -> bool {…}

is_inf_f32 :: proc "contextless" (x: f32, sign: int = 0) -> bool {…}

is_inf_f32be :: proc "contextless" (x: f32be, sign: int = 0) -> bool {…}

is_inf_f32le :: proc "contextless" (x: f32le, sign: int = 0) -> bool {…}

is_inf_f64 :: proc "contextless" (x: f64, sign: int = 0) -> bool {…}

is_inf_f64be :: proc "contextless" (x: f64be, sign: int = 0) -> bool {…}

is_inf_f64le :: proc "contextless" (x: f64le, sign: int = 0) -> bool {…}

is_nan_f16 :: proc "contextless" (x: f16) -> bool {…}

is_nan_f16be :: proc "contextless" (x: f16be) -> bool {…}

is_nan_f16le :: proc "contextless" (x: f16le) -> bool {…}

is_nan_f32 :: proc "contextless" (x: f32) -> bool {…}

is_nan_f32be :: proc "contextless" (x: f32be) -> bool {…}

is_nan_f32le :: proc "contextless" (x: f32le) -> bool {…}

is_nan_f64 :: proc "contextless" (x: f64) -> bool {…}

is_nan_f64be :: proc "contextless" (x: f64be) -> bool {…}

is_nan_f64le :: proc "contextless" (x: f64le) -> bool {…}

is_power_of_two :: proc "contextless" (x: int) -> bool {…}

lcm :: proc "contextless" (x, y: $T) -> $T {…}

ldexp_f16 :: proc "contextless" (val: f16, exp: int) -> f16 {…}

ldexp_f16be :: proc "contextless" (val: f16be, exp: int) -> f16be {…}

ldexp_f16le :: proc "contextless" (val: f16le, exp: int) -> f16le {…}

ldexp_f32 :: proc "contextless" (val: f32, exp: int) -> f32 {…}

ldexp_f32be :: proc "contextless" (val: f32be, exp: int) -> f32be {…}

ldexp_f32le :: proc "contextless" (val: f32le, exp: int) -> f32le {…}

ldexp_f64 :: proc "contextless" (val: f64, exp: int) -> f64 {…}

ldexp_f64be :: proc "contextless" (val: f64be, exp: int) -> f64be {…}

ldexp_f64le :: proc "contextless" (val: f64le, exp: int) -> f64le {…}

lerp :: proc "contextless" (a, b, t: $T) -> (x: $T) {…}

lgamma_f16 :: proc "contextless" (x: f16) -> (lgamma: f16, sign: int) {…}

lgamma_f16be :: proc "contextless" (x: f16be) -> (lgamma: f16be, sign: int) {…}

lgamma_f16le :: proc "contextless" (x: f16le) -> (lgamma: f16le, sign: int) {…}

lgamma_f32 :: proc "contextless" (x: f32) -> (lgamma: f32, sign: int) {…}

lgamma_f32be :: proc "contextless" (x: f32be) -> (lgamma: f32be, sign: int) {…}

lgamma_f32le :: proc "contextless" (x: f32le) -> (lgamma: f32le, sign: int) {…}

lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {…}

lgamma_f64be :: proc "contextless" (x: f64be) -> (lgamma: f64be, sign: int) {…}

lgamma_f64le :: proc "contextless" (x: f64le) -> (lgamma: f64le, sign: int) {…}

ln_f16 :: proc "contextless" (x: f16) -> f16 {…}

ln_f16be :: proc "contextless" (x: f16be) -> f16be {…}

ln_f16le :: proc "contextless" (x: f16le) -> f16le {…}

ln_f32 :: proc "contextless" (x: f32) -> f32 {…}

ln_f32be :: proc "contextless" (x: f32be) -> f32be {…}

ln_f32le :: proc "contextless" (x: f32le) -> f32le {…}

ln_f64 :: proc "contextless" (x: f64) -> f64 {…}

ln_f64be :: proc "contextless" (x: f64be) -> f64be {…}

ln_f64le :: proc "contextless" (x: f64le) -> f64le {…}

log10_f16 :: proc "contextless" (x: f16) -> f16 {…}

log10_f16be :: proc "contextless" (x: f16be) -> f16be {…}

log10_f16le :: proc "contextless" (x: f16le) -> f16le {…}

log10_f32 :: proc "contextless" (x: f32) -> f32 {…}

log10_f32be :: proc "contextless" (x: f32be) -> f32be {…}

log10_f32le :: proc "contextless" (x: f32le) -> f32le {…}

log10_f64 :: proc "contextless" (x: f64) -> f64 {…}

log10_f64be :: proc "contextless" (x: f64be) -> f64be {…}

log10_f64le :: proc "contextless" (x: f64le) -> f64le {…}

log1p_f16 :: proc "contextless" (x: f16) -> f16 {…}

log1p_f16be :: proc "contextless" (x: f16be) -> f16be {…}

log1p_f16le :: proc "contextless" (x: f16le) -> f16le {…}

log1p_f32 :: proc "contextless" (x: f32) -> f32 {…}

log1p_f32be :: proc "contextless" (x: f32be) -> f32be {…}

log1p_f32le :: proc "contextless" (x: f32le) -> f32le {…}

log1p_f64 :: proc "contextless" (x: f64) -> f64 {…}

log1p_f64be :: proc "contextless" (x: f64be) -> f64be {…}

log1p_f64le :: proc "contextless" (x: f64le) -> f64le {…}

log2_f16 :: proc "contextless" (x: f16) -> f16 {…}

log2_f16be :: proc "contextless" (x: f16be) -> f16be {…}

log2_f16le :: proc "contextless" (x: f16le) -> f16le {…}

log2_f32 :: proc "contextless" (x: f32) -> f32 {…}

log2_f32be :: proc "contextless" (x: f32be) -> f32be {…}

log2_f32le :: proc "contextless" (x: f32le) -> f32le {…}

log2_f64 :: proc "contextless" (x: f64) -> f64 {…}

log2_f64be :: proc "contextless" (x: f64be) -> f64be {…}

log2_f64le :: proc "contextless" (x: f64le) -> f64le {…}

log_f16 :: proc "contextless" (x, base: f16) -> f16 {…}

log_f16be :: proc "contextless" (x, base: f16be) -> f16be {…}

log_f16le :: proc "contextless" (x, base: f16le) -> f16le {…}

log_f32 :: proc "contextless" (x, base: f32) -> f32 {…}

log_f32be :: proc "contextless" (x, base: f32be) -> f32be {…}

log_f32le :: proc "contextless" (x, base: f32le) -> f32le {…}

log_f64 :: proc "contextless" (x, base: f64) -> f64 {…}

log_f64be :: proc "contextless" (x, base: f64be) -> f64be {…}

log_f64le :: proc "contextless" (x, base: f64le) -> f64le {…}

logb_f16 :: proc "contextless" (val: f16) -> f16 {…}

logb_f16be :: proc "contextless" (value: f16be) -> f16be {…}

logb_f16le :: proc "contextless" (value: f16le) -> f16le {…}

logb_f32 :: proc "contextless" (val: f32) -> f32 {…}

logb_f32be :: proc "contextless" (value: f32be) -> f32be {…}

logb_f32le :: proc "contextless" (value: f32le) -> f32le {…}

logb_f64 :: proc "contextless" (val: f64) -> f64 {…}

logb_f64be :: proc "contextless" (value: f64be) -> f64be {…}

logb_f64le :: proc "contextless" (value: f64le) -> f64le {…}

max :: builtin.max

min :: builtin.min

mod_f16 :: proc "contextless" (x, y: f16) -> (n: f16) {…}

mod_f16be :: proc "contextless" (x, y: f16be) -> (n: f16be) {…}

mod_f16le :: proc "contextless" (x, y: f16le) -> (n: f16le) {…}

mod_f32 :: proc "contextless" (x, y: f32) -> (n: f32) {…}

mod_f32be :: proc "contextless" (x, y: f32be) -> (n: f32be) {…}

mod_f32le :: proc "contextless" (x, y: f32le) -> (n: f32le) {…}

mod_f64 :: proc "contextless" (x, y: f64) -> (n: f64) {…}

mod_f64be :: proc "contextless" (x, y: f64be) -> (n: f64be) {…}

mod_f64le :: proc "contextless" (x, y: f64le) -> (n: f64le) {…}

modf_f16 :: proc "contextless" (x: f16) -> (int: f16, frac: f16) {…}

modf_f16be :: proc "contextless" (x: f16be) -> (int: f16be, frac: f16be) {…}

modf_f16le :: proc "contextless" (x: f16le) -> (int: f16le, frac: f16le) {…}

modf_f32 :: proc "contextless" (x: f32) -> (int: f32, frac: f32) {…}

modf_f32be :: proc "contextless" (x: f32be) -> (int: f32be, frac: f32be) {…}

modf_f32le :: proc "contextless" (x: f32le) -> (int: f32le, frac: f32le) {…}

modf_f64 :: proc "contextless" (x: f64) -> (int: f64, frac: f64) {…}

modf_f64be :: proc "contextless" (x: f64be) -> (int: f64be, frac: f64be) {…}

modf_f64le :: proc "contextless" (x: f64le) -> (int: f64le, frac: f64le) {…}

nan_f16 :: proc "contextless" () -> f16 {…}

nan_f16be :: proc "contextless" () -> f16be {…}

nan_f16le :: proc "contextless" () -> f16le {…}

nan_f32 :: proc "contextless" () -> f32 {…}

nan_f32be :: proc "contextless" () -> f32be {…}

nan_f32le :: proc "contextless" () -> f32le {…}

nan_f64 :: proc "contextless" () -> f64 {…}

nan_f64be :: proc "contextless" () -> f64be {…}

nan_f64le :: proc "contextless" () -> f64le {…}

next_power_of_two :: proc "contextless" (x: int) -> int {…}

nextafter_f16 :: proc "contextless" (x, y: f16) -> (r: f16) {…}

nextafter_f16be :: proc "contextless" (x, y: f16be) -> (r: f16be) {…}

nextafter_f16le :: proc "contextless" (x, y: f16le) -> (r: f16le) {…}

nextafter_f32 :: proc "contextless" (x, y: f32) -> (r: f32) {…}

nextafter_f32be :: proc "contextless" (x, y: f32be) -> (r: f32be) {…}

nextafter_f32le :: proc "contextless" (x, y: f32le) -> (r: f32le) {…}

nextafter_f64 :: proc "contextless" (x, y: f64) -> (r: f64) {…}

nextafter_f64be :: proc "contextless" (x, y: f64be) -> (r: f64be) {…}

nextafter_f64le :: proc "contextless" (x, y: f64le) -> (r: f64le) {…}

normalize_f16 :: proc "contextless" (x: f16) -> (y: f16, exponent: int) {…}

normalize_f16be :: proc "contextless" (x: f16be) -> (y: f16be, exponent: int) {…}

normalize_f16le :: proc "contextless" (x: f16le) -> (y: f16le, exponent: int) {…}

normalize_f32 :: proc "contextless" (x: f32) -> (y: f32, exponent: int) {…}

normalize_f32be :: proc "contextless" (x: f32be) -> (y: f32be, exponent: int) {…}

normalize_f32le :: proc "contextless" (x: f32le) -> (y: f32le, exponent: int) {…}

normalize_f64 :: proc "contextless" (x: f64) -> (y: f64, exponent: int) {…}

normalize_f64be :: proc "contextless" (x: f64be) -> (y: f64be, exponent: int) {…}

normalize_f64le :: proc "contextless" (x: f64le) -> (y: f64le, exponent: int) {…}

pow10_f16 :: proc "contextless" (n: f16) -> f16 {…}

pow10_f16be :: proc "contextless" (x: f16be) -> f16be {…}

pow10_f16le :: proc "contextless" (x: f16le) -> f16le {…}

pow10_f32 :: proc "contextless" (n: f32) -> f32 {…}

pow10_f32be :: proc "contextless" (x: f32be) -> f32be {…}

pow10_f32le :: proc "contextless" (x: f32le) -> f32le {…}

pow10_f64 :: proc "contextless" (n: f64) -> f64 {…}

pow10_f64be :: proc "contextless" (x: f64be) -> f64be {…}

pow10_f64le :: proc "contextless" (x: f64le) -> f64le {…}

pow2_f16 :: proc "contextless" (#any_int exp: int) -> (res: f16) {…}

pow2_f32 :: proc "contextless" (#any_int exp: int) -> (res: f32) {…}

pow2_f64 :: proc "contextless" (#any_int exp: int) -> (res: f64) {…}

pow_f16 :: proc "contextless" (x, power: f16) -> f16 {…}

pow_f16be :: proc "contextless" (x, power: f16be) -> f16be {…}

pow_f16le :: proc "contextless" (x, power: f16le) -> f16le {…}

pow_f32 :: proc "contextless" (x, power: f32) -> f32 {…}

pow_f32be :: proc "contextless" (x, power: f32be) -> f32be {…}

pow_f32le :: proc "contextless" (x, power: f32le) -> f32le {…}

pow_f64 :: proc "contextless" (x, power: f64) -> f64 {…}

pow_f64be :: proc "contextless" (x, power: f64be) -> f64be {…}

pow_f64le :: proc "contextless" (x, power: f64le) -> f64le {…}

prod :: proc "contextless" (x: $T/[]$T) -> (res: $T) {…}

remainder_f16 :: proc "contextless" (x, y: f16) -> f16 {…}

remainder_f16be :: proc "contextless" (x, y: f16be) -> f16be {…}

remainder_f16le :: proc "contextless" (x, y: f16le) -> f16le {…}

remainder_f32 :: proc "contextless" (x, y: f32) -> f32 {…}

remainder_f32be :: proc "contextless" (x, y: f32be) -> f32be {…}

remainder_f32le :: proc "contextless" (x, y: f32le) -> f32le {…}

remainder_f64 :: proc "contextless" (x, y: f64) -> f64 {…}

remainder_f64be :: proc "contextless" (x, y: f64be) -> f64be {…}

remainder_f64le :: proc "contextless" (x, y: f64le) -> f64le {…}

remap :: proc "contextless" (old_value, old_min, old_max, new_min, new_max: $T) -> (x: $T) {…}

remap_clamped :: proc "contextless" (old_value, old_min, old_max, new_min, new_max: $T) -> (x: $T) {…}

round_f16 :: proc "contextless" (x: f16) -> f16 {…}

round_f16be :: proc "contextless" (x: f16be) -> f16be {…}

round_f16le :: proc "contextless" (x: f16le) -> f16le {…}

round_f32 :: proc "contextless" (x: f32) -> f32 {…}

round_f32be :: proc "contextless" (x: f32be) -> f32be {…}

round_f32le :: proc "contextless" (x: f32le) -> f32le {…}

round_f64 :: proc "contextless" (x: f64) -> f64 {…}

round_f64be :: proc "contextless" (x: f64be) -> f64be {…}

round_f64le :: proc "contextless" (x: f64le) -> f64le {…}

saturate :: proc "contextless" (a: $T) -> (x: $T) {…}

sign_bit_f16 :: proc "contextless" (x: f16) -> bool {…}

sign_bit_f16be :: proc "contextless" (x: f16be) -> bool {…}

sign_bit_f16le :: proc "contextless" (x: f16le) -> bool {…}

sign_bit_f32 :: proc "contextless" (x: f32) -> bool {…}

sign_bit_f32be :: proc "contextless" (x: f32be) -> bool {…}

sign_bit_f32le :: proc "contextless" (x: f32le) -> bool {…}

sign_bit_f64 :: proc "contextless" (x: f64) -> bool {…}

sign_bit_f64be :: proc "contextless" (x: f64be) -> bool {…}

sign_bit_f64le :: proc "contextless" (x: f64le) -> bool {…}

sign_f16 :: proc "contextless" (x: f16) -> f16 {…}

sign_f16be :: proc "contextless" (x: f16be) -> f16be {…}

sign_f16le :: proc "contextless" (x: f16le) -> f16le {…}

sign_f32 :: proc "contextless" (x: f32) -> f32 {…}

sign_f32be :: proc "contextless" (x: f32be) -> f32be {…}

sign_f32le :: proc "contextless" (x: f32le) -> f32le {…}

sign_f64 :: proc "contextless" (x: f64) -> f64 {…}

sign_f64be :: proc "contextless" (x: f64be) -> f64be {…}

sign_f64le :: proc "contextless" (x: f64le) -> f64le {…}

signbit_f16 :: proc "contextless" (x: f16) -> bool {…}

signbit_f16be :: proc "contextless" (x: f16be) -> bool {…}

signbit_f16le :: proc "contextless" (x: f16le) -> bool {…}