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: f64 : 360.0 / TAU

E: f64 : 2.71828182845904523536

F16_BIAS: int : 0xf

F16_DIG: int : 3

F16_EPSILON: f64 : 0.00097656

F16_GUARD: int : 0

F16_MANT_DIG: int : 11

F16_MASK: int : 0x1f

F16_MAX: f64 : 65504.0

F16_MAX_10_EXP: int : 4

F16_MAX_EXP: int : 15

F16_MIN: f64 : 6.10351562e-5

F16_MIN_10_EXP: int : -4

F16_MIN_EXP: int : -14

F16_NORMALIZE: int : 0

F16_RADIX: int : 2

F16_ROUNDS: int : 1

F16_SHIFT: int : 16 - 6

F32_BIAS: int : 0x7f

F32_DIG: int : 6

F32_EPSILON: f64 : 1.192092896e-07

F32_GUARD: int : 0

F32_MANT_DIG: int : 24

F32_MASK: int : 0xff

F32_MAX: f64 : 3.402823466e+38

F32_MAX_10_EXP: int : 38

F32_MAX_EXP: int : 128

F32_MIN: f64 : 1.175494351e-38

F32_MIN_10_EXP: int : -37

F32_MIN_EXP: int : -125

F32_NORMALIZE: int : 0

F32_RADIX: int : 2

F32_ROUNDS: int : 1

F32_SHIFT: int : 32 - 9

F64_BIAS: int : 0x3ff

F64_DIG: int : 15

F64_EPSILON: f64 : 2.2204460492503131e-016

F64_MANT_DIG: int : 53

F64_MASK: int : 0x7ff

F64_MAX: f64 : 1.7976931348623158e+308

F64_MAX_10_EXP: int : 308

F64_MAX_EXP: int : 1024

F64_MIN: f64 : 2.2250738585072014e-308

F64_MIN_10_EXP: int : -307

F64_MIN_EXP: int : -1021

F64_RADIX: int : 2

F64_ROUNDS: int : 1

F64_SHIFT: int : 64 - 12

INF_F16 :: f16(0h7C00)

INF_F32 :: f32(0h7F80_0000)

INF_F64 :: f64(0h7FF0_0000_0000_0000)

LN10: f64 : 2.30258509299404568401799145468436421

LN2: f64 : 0.693147180559945309417232121458176568

MAX_F16_PRECISION: int : 4

MAX_F32_PRECISION: int : 8

MAX_F64_PRECISION: int : 16

NEG_INF_F16 :: f16(0hFC00)

NEG_INF_F32 :: f32(0hFF80_0000)

NEG_INF_F64 :: f64(0hFFF0_0000_0000_0000)

PI: f64 : 3.14159265358979323846264338327950288

QNAN_F16 :: f16(0h7E01)

QNAN_F32 :: f32(0hFFC0_0001)

QNAN_F64 :: f64(0h7FF8_0000_0000_0001)

RAD_PER_DEG: f64 : TAU / 360.0

SNAN_F16 :: f16(0h7C01)

SNAN_F32 :: f32(0hFF80_0001)

SNAN_F64 :: f64(0h7FF0_0000_0000_0001)

SQRT_FIVE: f64 : 2.23606797749978969640917366873127623

SQRT_THREE: f64 : 1.73205080756887729352744634150587236

SQRT_TWO: f64 : 1.41421356237309504880168872420969808

TAU: f64 : 6.28318530717958647692528676655900576

e: f64 : E

π: f64 : PI

τ: f64 : 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/[]$E) -> $T/[]$E {…}

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

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: $E) -> (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/[]$E) -> (res: $E) {…}

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 {…}