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 "none" (θ: f16) -> f16 ---

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

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

cos_f32 :: proc "none" (θ: f32) -> f32 ---

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

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

cos_f64 :: proc "none" (θ: f64) -> f64 ---

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

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

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

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 "none" (x: f16) -> f16 ---

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

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

exp_f32 :: proc "none" (x: f32) -> f32 ---

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

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

exp_f64 :: proc "none" (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 "none" (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 "none" (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 "none" (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 {…}

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

pow_f16 :: proc "none" (x, power: f16) -> f16 ---

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

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

pow_f32 :: proc "none" (x, power: f32) -> f32 ---

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

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

pow_f64 :: proc "none" (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) {…}

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

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

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

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

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

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

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

sin_f16 :: proc "none" (θ: f16) -> f16 ---

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

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

sin_f32 :: proc "none" (θ: f32) -> f32 ---

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

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

sin_f64 :: proc "none" (θ: f64) -> f64 ---

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

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

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

smoothstep :: proc "contextless" (edge0, edge1, x: $T) -> $T {…}

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

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

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

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

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

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

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

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

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

step :: proc "contextless" (edge, x: $T) -> $T {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

acos :: proc{
	acos_f64,
	acos_f32,
	acos_f16,
	acos_f64le,
	acos_f64be,
	acos_f32le,
	acos_f32be,
	acos_f16le,
	acos_f16be,
}

asin :: proc{
	asin_f64,
	asin_f32,
	asin_f16,
	asin_f64le,
	asin_f64be,
	asin_f32le,
	asin_f32be,
	asin_f16le,
	asin_f16be,
}

atan2 :: proc{
	atan2_f64,
	atan2_f32,
	atan2_f16,
	atan2_f64le,
	atan2_f64be,
	atan2_f32le,
	atan2_f32be,
	atan2_f16le,
	atan2_f16be,
}

ceil :: proc{
	ceil_f16,
	ceil_f16le,
	ceil_f16be,
	ceil_f32,
	ceil_f32le,
	ceil_f32be,
	ceil_f64,
	ceil_f64le,
	ceil_f64be,
}

classify :: proc{
	classify_f16,
	classify_f16le,
	classify_f16be,
	classify_f32,
	classify_f32le,
	classify_f32be,
	classify_f64,
	classify_f64le,
	classify_f64be,
}

copy_sign :: proc{
	copy_sign_f16,
	copy_sign_f16le,
	copy_sign_f16be,
	copy_sign_f32,
	copy_sign_f32le,
	copy_sign_f32be,
	copy_sign_f64,
	copy_sign_f64le,
	copy_sign_f64be,
}

cos :: proc{
	cos_f16,
	cos_f16le,
	cos_f16be,
	cos_f32,
	cos_f32le,
	cos_f32be,
	cos_f64,
	cos_f64le,
	cos_f64be,
}

erf :: proc{
	erf_f16,
	erf_f16le,
	erf_f16be,
	erf_f32,
	erf_f32le,
	erf_f32be,
	erf_f64,
}

erfc :: proc{
	erfc_f16,
	erfc_f16le,
	erfc_f16be,
	erfc_f32,
	erfc_f32le,
	erfc_f32be,
	erfc_f64,
}

exp :: proc{
	exp_f16,
	exp_f16le,
	exp_f16be,
	exp_f32,
	exp_f32le,
	exp_f32be,
	exp_f64,
	exp_f64le,
	exp_f64be,
}

floor :: proc{
	floor_f16,
	floor_f16le,
	floor_f16be,
	floor_f32,
	floor_f32le,
	floor_f32be,
	floor_f64,
	floor_f64le,
	floor_f64be,
}

fmuladd :: proc{
	fmuladd_f16,
	fmuladd_f16le,
	fmuladd_f16be,
	fmuladd_f32,
	fmuladd_f32le,
	fmuladd_f32be,
	fmuladd_f64,
	fmuladd_f64le,
	fmuladd_f64be,
}

frexp :: proc{
	frexp_f16,
	frexp_f16le,
	frexp_f16be,
	frexp_f32,
	frexp_f32le,
	frexp_f32be,
	frexp_f64,
	frexp_f64le,
	frexp_f64be,
}

gamma :: proc{
	gamma_f16,
	gamma_f16le,
	gamma_f16be,
	gamma_f32,
	gamma_f32le,
	gamma_f32be,
	gamma_f64,
	gamma_f64le,
	gamma_f64be,
}

ilogb :: proc{
	ilogb_f16,
	ilogb_f32,
	ilogb_f64,
	ilogb_f16le,
	ilogb_f16be,
	ilogb_f32le,
	ilogb_f32be,
	ilogb_f64le,
	ilogb_f64be,
}

is_inf :: proc{
	is_inf_f16,
	is_inf_f16le,
	is_inf_f16be,
	is_inf_f32,
	is_inf_f32le,
	is_inf_f32be,
	is_inf_f64,
	is_inf_f64le,
	is_inf_f64be,
}

is_nan :: proc{
	is_nan_f16,
	is_nan_f16le,
	is_nan_f16be,
	is_nan_f32,
	is_nan_f32le,
	is_nan_f32be,
	is_nan_f64,
	is_nan_f64le,
	is_nan_f64be,
}

ldexp :: proc{
	ldexp_f16,
	ldexp_f16le,
	ldexp_f16be,
	ldexp_f32,
	ldexp_f32le,
	ldexp_f32be,
	ldexp_f64,
	ldexp_f64le,
	ldexp_f64be,
}

lgamma :: proc{
	lgamma_f16,
	lgamma_f16le,
	lgamma_f16be,
	lgamma_f32,
	lgamma_f32le,
	lgamma_f32be,
	lgamma_f64,
	lgamma_f64le,
	lgamma_f64be,
}

ln :: proc{
	ln_f16,
	ln_f16le,
	ln_f16be,
	ln_f32,
	ln_f32le,
	ln_f32be,
	ln_f64,
	ln_f64le,
	ln_f64be,
}

log :: proc{
	log_f16,
	log_f16le,
	log_f16be,
	log_f32,
	log_f32le,
	log_f32be,
	log_f64,
	log_f64le,
	log_f64be,
}

log10 :: proc{
	log10_f16,
	log10_f16le,
	log10_f16be,
	log10_f32,
	log10_f32le,
	log10_f32be,
	log10_f64,
	log10_f64le,
	log10_f64be,
}

log1p :: proc{
	log1p_f16,
	log1p_f32,
	log1p_f64,
	log1p_f16le,
	log1p_f16be,
	log1p_f32le,
	log1p_f32be,
	log1p_f64le,
	log1p_f64be,
}

log2 :: proc{
	log2_f16,
	log2_f16le,
	log2_f16be,
	log2_f32,
	log2_f32le,
	log2_f32be,
	log2_f64,
	log2_f64le,
	log2_f64be,
}

logb :: proc{
	logb_f16,
	logb_f32,
	logb_f64,
	logb_f16le,
	logb_f16be,
	logb_f32le,
	logb_f32be,
	logb_f64le,
	logb_f64be,
}