package core:math
Index
Types (1)
Constants (74)
- DEG_PER_RAD
- E
- F16_BIAS
- F16_DIG
- F16_EPSILON
- F16_GUARD
- F16_MANT_DIG
- F16_MASK
- F16_MAX
- F16_MAX_10_EXP
- F16_MAX_EXP
- F16_MIN
- F16_MIN_10_EXP
- F16_MIN_EXP
- F16_NORMALIZE
- F16_RADIX
- F16_ROUNDS
- F16_SHIFT
- F32_BIAS
- F32_DIG
- F32_EPSILON
- F32_GUARD
- F32_MANT_DIG
- F32_MASK
- F32_MAX
- F32_MAX_10_EXP
- F32_MAX_EXP
- F32_MIN
- F32_MIN_10_EXP
- F32_MIN_EXP
- F32_NORMALIZE
- F32_RADIX
- F32_ROUNDS
- F32_SHIFT
- F64_BIAS
- F64_DIG
- F64_EPSILON
- F64_MANT_DIG
- F64_MASK
- F64_MAX
- F64_MAX_10_EXP
- F64_MAX_EXP
- F64_MIN
- F64_MIN_10_EXP
- F64_MIN_EXP
- F64_RADIX
- F64_ROUNDS
- F64_SHIFT
- INF_F16
- INF_F32
- INF_F64
- LN10
- LN2
- MAX_F16_PRECISION
- MAX_F32_PRECISION
- MAX_F64_PRECISION
- NEG_INF_F16
- NEG_INF_F32
- NEG_INF_F64
- PI
- QNAN_F16
- QNAN_F32
- QNAN_F64
- RAD_PER_DEG
- SNAN_F16
- SNAN_F32
- SNAN_F64
- SQRT_FIVE
- SQRT_THREE
- SQRT_TWO
- TAU
- e
- π
- τ
Variables (0)
This section is empty.
Procedures (428)
- abs
- acos_f16
- acos_f16be
- acos_f16le
- acos_f32
- acos_f32be
- acos_f32le
- acos_f64
- acos_f64be
- acos_f64le
- acosh
- angle_diff
- angle_lerp
- asin_f16
- asin_f16be
- asin_f16le
- asin_f32
- asin_f32be
- asin_f32le
- asin_f64
- asin_f64be
- asin_f64le
- asinh
- atan
- atan2_f16
- atan2_f16be
- atan2_f16le
- atan2_f32
- atan2_f32be
- atan2_f32le
- atan2_f64
- atan2_f64be
- atan2_f64le
- atanh
- bias
- binomial
- ceil_f16
- ceil_f16be
- ceil_f16le
- ceil_f32
- ceil_f32be
- ceil_f32le
- ceil_f64
- ceil_f64be
- ceil_f64le
- clamp
- classify_f16
- classify_f16be
- classify_f16le
- classify_f32
- classify_f32be
- classify_f32le
- classify_f64
- classify_f64be
- classify_f64le
- copy_sign_f16
- copy_sign_f16be
- copy_sign_f16le
- copy_sign_f32
- copy_sign_f32be
- copy_sign_f32le
- copy_sign_f64
- copy_sign_f64be
- copy_sign_f64le
- cos_f16
- cos_f16be
- cos_f16le
- cos_f32
- cos_f32be
- cos_f32le
- cos_f64
- cos_f64be
- cos_f64le
- cosh
- cumsum
- cumsum_inplace
- divmod
- erf_f16
- erf_f16be
- erf_f16le
- erf_f32
- erf_f32be
- erf_f32le
- erf_f64
- erfc_f16
- erfc_f16be
- erfc_f16le
- erfc_f32
- erfc_f32be
- erfc_f32le
- erfc_f64
- exp_f16
- exp_f16be
- exp_f16le
- exp_f32
- exp_f32be
- exp_f32le
- exp_f64
- exp_f64be
- exp_f64le
- factorial
- floor_div
- floor_divmod
- floor_f16
- floor_f16be
- floor_f16le
- floor_f32
- floor_f32be
- floor_f32le
- floor_f64
- floor_f64be
- floor_f64le
- floor_mod
- fmuladd_f16
- fmuladd_f16be
- fmuladd_f16le
- fmuladd_f32
- fmuladd_f32be
- fmuladd_f32le
- fmuladd_f64
- fmuladd_f64be
- fmuladd_f64le
- frexp_f16
- frexp_f16be
- frexp_f16le
- frexp_f32
- frexp_f32be
- frexp_f32le
- frexp_f64
- frexp_f64be
- frexp_f64le
- gain
- gamma_f16
- gamma_f16be
- gamma_f16le
- gamma_f32
- gamma_f32be
- gamma_f32le
- gamma_f64
- gamma_f64be
- gamma_f64le
- gcd
- ilogb_f16
- ilogb_f16be
- ilogb_f16le
- ilogb_f32
- ilogb_f32be
- ilogb_f32le
- ilogb_f64
- ilogb_f64be
- ilogb_f64le
- inf_f16
- inf_f16be
- inf_f16le
- inf_f32
- inf_f32be
- inf_f32le
- inf_f64
- inf_f64be
- inf_f64le
- is_inf_f16
- is_inf_f16be
- is_inf_f16le
- is_inf_f32
- is_inf_f32be
- is_inf_f32le
- is_inf_f64
- is_inf_f64be
- is_inf_f64le
- is_nan_f16
- is_nan_f16be
- is_nan_f16le
- is_nan_f32
- is_nan_f32be
- is_nan_f32le
- is_nan_f64
- is_nan_f64be
- is_nan_f64le
- is_power_of_two
- lcm
- ldexp_f16
- ldexp_f16be
- ldexp_f16le
- ldexp_f32
- ldexp_f32be
- ldexp_f32le
- ldexp_f64
- ldexp_f64be
- ldexp_f64le
- lerp
- lgamma_f16
- lgamma_f16be
- lgamma_f16le
- lgamma_f32
- lgamma_f32be
- lgamma_f32le
- lgamma_f64
- lgamma_f64be
- lgamma_f64le
- ln_f16
- ln_f16be
- ln_f16le
- ln_f32
- ln_f32be
- ln_f32le
- ln_f64
- ln_f64be
- ln_f64le
- log10_f16
- log10_f16be
- log10_f16le
- log10_f32
- log10_f32be
- log10_f32le
- log10_f64
- log10_f64be
- log10_f64le
- log1p_f16
- log1p_f16be
- log1p_f16le
- log1p_f32
- log1p_f32be
- log1p_f32le
- log1p_f64
- log1p_f64be
- log1p_f64le
- log2_f16
- log2_f16be
- log2_f16le
- log2_f32
- log2_f32be
- log2_f32le
- log2_f64
- log2_f64be
- log2_f64le
- log_f16
- log_f16be
- log_f16le
- log_f32
- log_f32be
- log_f32le
- log_f64
- log_f64be
- log_f64le
- logb_f16
- logb_f16be
- logb_f16le
- logb_f32
- logb_f32be
- logb_f32le
- logb_f64
- logb_f64be
- logb_f64le
- max
- min
- mod_f16
- mod_f16be
- mod_f16le
- mod_f32
- mod_f32be
- mod_f32le
- mod_f64
- mod_f64be
- mod_f64le
- modf_f16
- modf_f16be
- modf_f16le
- modf_f32
- modf_f32be
- modf_f32le
- modf_f64
- modf_f64be
- modf_f64le
- nan_f16
- nan_f16be
- nan_f16le
- nan_f32
- nan_f32be
- nan_f32le
- nan_f64
- nan_f64be
- nan_f64le
- next_power_of_two
- nextafter_f16
- nextafter_f16be
- nextafter_f16le
- nextafter_f32
- nextafter_f32be
- nextafter_f32le
- nextafter_f64
- nextafter_f64be
- nextafter_f64le
- normalize_f16
- normalize_f16be
- normalize_f16le
- normalize_f32
- normalize_f32be
- normalize_f32le
- normalize_f64
- normalize_f64be
- normalize_f64le
- pow10_f16
- pow10_f16be
- pow10_f16le
- pow10_f32
- pow10_f32be
- pow10_f32le
- pow10_f64
- pow10_f64be
- pow10_f64le
- pow_f16
- pow_f16be
- pow_f16le
- pow_f32
- pow_f32be
- pow_f32le
- pow_f64
- pow_f64be
- pow_f64le
- prod
- remainder_f16
- remainder_f16be
- remainder_f16le
- remainder_f32
- remainder_f32be
- remainder_f32le
- remainder_f64
- remainder_f64be
- remainder_f64le
- remap
- round_f16
- round_f16be
- round_f16le
- round_f32
- round_f32be
- round_f32le
- round_f64
- round_f64be
- round_f64le
- saturate
- sign_bit_f16
- sign_bit_f16be
- sign_bit_f16le
- sign_bit_f32
- sign_bit_f32be
- sign_bit_f32le
- sign_bit_f64
- sign_bit_f64be
- sign_bit_f64le
- sign_f16
- sign_f16be
- sign_f16le
- sign_f32
- sign_f32be
- sign_f32le
- sign_f64
- sign_f64be
- sign_f64le
- signbit_f16
- signbit_f16be
- signbit_f16le
- signbit_f32
- signbit_f32be
- signbit_f32le
- signbit_f64
- signbit_f64be
- signbit_f64le
- sin_f16
- sin_f16be
- sin_f16le
- sin_f32
- sin_f32be
- sin_f32le
- sin_f64
- sin_f64be
- sin_f64le
- sinh
- smoothstep
- sqrt_f16
- sqrt_f16be
- sqrt_f16le
- sqrt_f32
- sqrt_f32be
- sqrt_f32le
- sqrt_f64
- sqrt_f64be
- sqrt_f64le
- step
- sum
- tan_f16
- tan_f16be
- tan_f16le
- tan_f32
- tan_f32be
- tan_f32le
- tan_f64
- tan_f64be
- tan_f64le
- tanh
- to_degrees_f16
- to_degrees_f16be
- to_degrees_f16le
- to_degrees_f32
- to_degrees_f32be
- to_degrees_f32le
- to_degrees_f64
- to_degrees_f64be
- to_degrees_f64le
- to_radians_f16
- to_radians_f16be
- to_radians_f16le
- to_radians_f32
- to_radians_f32be
- to_radians_f32le
- to_radians_f64
- to_radians_f64be
- to_radians_f64le
- trunc_f16
- trunc_f16be
- trunc_f16le
- trunc_f32
- trunc_f32be
- trunc_f32le
- trunc_f64
- trunc_f64be
- trunc_f64le
- unlerp
- wrap
Types
Float_Class ¶
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 }
Constants
DEG_PER_RAD ¶
DEG_PER_RAD :: 360.0 / TAU
F16_BIAS ¶
F16_BIAS :: 0xf
F16_EPSILON ¶
F16_EPSILON :: 0.00097656
F16_GUARD ¶
F16_GUARD :: 0
F16_MANT_DIG ¶
F16_MANT_DIG :: 11
F16_MASK ¶
F16_MASK :: 0x1f
F16_MAX_10_EXP ¶
F16_MAX_10_EXP :: 4
F16_MAX_EXP ¶
F16_MAX_EXP :: 15
F16_MIN_10_EXP ¶
F16_MIN_10_EXP :: -4
F16_MIN_EXP ¶
F16_MIN_EXP :: -14
F16_NORMALIZE ¶
F16_NORMALIZE :: 0
F16_RADIX ¶
F16_RADIX :: 2
F16_ROUNDS ¶
F16_ROUNDS :: 1
F16_SHIFT ¶
F16_SHIFT :: 16 - 6
F32_BIAS ¶
F32_BIAS :: 0x7f
F32_EPSILON ¶
F32_EPSILON :: 1.192092896e-07
F32_GUARD ¶
F32_GUARD :: 0
F32_MANT_DIG ¶
F32_MANT_DIG :: 24
F32_MASK ¶
F32_MASK :: 0xff
F32_MAX_10_EXP ¶
F32_MAX_10_EXP :: 38
F32_MAX_EXP ¶
F32_MAX_EXP :: 128
F32_MIN_10_EXP ¶
F32_MIN_10_EXP :: -37
F32_MIN_EXP ¶
F32_MIN_EXP :: -125
F32_NORMALIZE ¶
F32_NORMALIZE :: 0
F32_RADIX ¶
F32_RADIX :: 2
F32_ROUNDS ¶
F32_ROUNDS :: 1
F32_SHIFT ¶
F32_SHIFT :: 32 - 9
F64_BIAS ¶
F64_BIAS :: 0x3ff
F64_MASK ¶
F64_MASK :: 0x7ff
F64_SHIFT ¶
F64_SHIFT :: 64 - 12
MAX_F16_PRECISION ¶
MAX_F16_PRECISION :: 4
Maximum number of meaningful digits after the decimal point for 'f16'
MAX_F32_PRECISION ¶
MAX_F32_PRECISION :: 8
Maximum number of meaningful digits after the decimal point for 'f32'
MAX_F64_PRECISION ¶
MAX_F64_PRECISION :: 16
Maximum number of meaningful digits after the decimal point for 'f64'
NEG_INF_F16 ¶
NEG_INF_F16: f16 : 0hFC00
NEG_INF_F32 ¶
NEG_INF_F32: f32 : 0hFF80_0000
NEG_INF_F64 ¶
NEG_INF_F64: f64 : 0hFFF0_0000_0000_0000
QNAN_F16 ¶
QNAN_F16: f16 : 0h7E01
QNAN_F32 ¶
QNAN_F32: f32 : 0hFFC0_0001
QNAN_F64 ¶
QNAN_F64: f64 : 0h7FF8_0000_0000_0001
RAD_PER_DEG ¶
RAD_PER_DEG :: TAU / 360.0
SNAN_F16 ¶
SNAN_F16: f16 : 0h7C01
SNAN_F32 ¶
SNAN_F32: f32 : 0hFF80_0001
SNAN_F64 ¶
SNAN_F64: f64 : 0h7FF0_0000_0000_0001
SQRT_FIVE ¶
SQRT_FIVE :: 2.23606797749978969640917366873127623
SQRT_THREE ¶
SQRT_THREE :: 1.73205080756887729352744634150587236
SQRT_TWO ¶
SQRT_TWO :: 1.41421356237309504880168872420969808
Variables
This section is empty.
Procedures
acos_f16 ¶
acos_f16 :: proc "contextless" (x: f16) -> f16 {…}
acos_f16be ¶
acos_f16be :: proc "contextless" (x: f16be) -> f16be {…}
acos_f16le ¶
acos_f16le :: proc "contextless" (x: f16le) -> f16le {…}
acos_f32 ¶
acos_f32 :: proc "contextless" (x: f32) -> f32 {…}
acos_f32be ¶
acos_f32be :: proc "contextless" (x: f32be) -> f32be {…}
acos_f32le ¶
acos_f32le :: proc "contextless" (x: f32le) -> f32le {…}
acos_f64 ¶
acos_f64 :: proc "contextless" (x: f64) -> f64 {…}
acos_f64be ¶
acos_f64be :: proc "contextless" (x: f64be) -> f64be {…}
acos_f64le ¶
acos_f64le :: proc "contextless" (x: f64le) -> f64le {…}
angle_diff ¶
angle_diff :: proc "contextless" (a, b: $T) -> $T {…}
angle_lerp ¶
angle_lerp :: proc "contextless" (a, b, t: $T) -> $T {…}
asin_f16 ¶
asin_f16 :: proc "contextless" (x: f16) -> f16 {…}
asin_f16be ¶
asin_f16be :: proc "contextless" (x: f16be) -> f16be {…}
asin_f16le ¶
asin_f16le :: proc "contextless" (x: f16le) -> f16le {…}
asin_f32 ¶
asin_f32 :: proc "contextless" (x: f32) -> f32 {…}
asin_f32be ¶
asin_f32be :: proc "contextless" (x: f32be) -> f32be {…}
asin_f32le ¶
asin_f32le :: proc "contextless" (x: f32le) -> f32le {…}
asin_f64 ¶
asin_f64 :: proc "contextless" (x: f64) -> f64 {…}
asin_f64be ¶
asin_f64be :: proc "contextless" (x: f64be) -> f64be {…}
asin_f64le ¶
asin_f64le :: proc "contextless" (x: f64le) -> f64le {…}
atan2_f16 ¶
atan2_f16 :: proc "contextless" (y, x: f16) -> f16 {…}
atan2_f16be ¶
atan2_f16be :: proc "contextless" (y, x: f16be) -> f16be {…}
atan2_f16le ¶
atan2_f16le :: proc "contextless" (y, x: f16le) -> f16le {…}
atan2_f32 ¶
atan2_f32 :: proc "contextless" (y, x: f32) -> f32 {…}
atan2_f32be ¶
atan2_f32be :: proc "contextless" (y, x: f32be) -> f32be {…}
atan2_f32le ¶
atan2_f32le :: proc "contextless" (y, x: f32le) -> f32le {…}
atan2_f64 ¶
atan2_f64 :: proc "contextless" (y, x: f64) -> f64 {…}
atan2_f64be ¶
atan2_f64be :: proc "contextless" (y, x: f64be) -> f64be {…}
atan2_f64le ¶
atan2_f64le :: proc "contextless" (y, x: f64le) -> f64le {…}
binomial ¶
binomial :: proc "contextless" (n, k: int) -> int {…}
ceil_f16 ¶
ceil_f16 :: proc "contextless" (x: f16) -> f16 {…}
ceil_f16be ¶
ceil_f16be :: proc "contextless" (x: f16be) -> f16be {…}
ceil_f16le ¶
ceil_f16le :: proc "contextless" (x: f16le) -> f16le {…}
ceil_f32 ¶
ceil_f32 :: proc "contextless" (x: f32) -> f32 {…}
ceil_f32be ¶
ceil_f32be :: proc "contextless" (x: f32be) -> f32be {…}
ceil_f32le ¶
ceil_f32le :: proc "contextless" (x: f32le) -> f32le {…}
ceil_f64 ¶
ceil_f64 :: proc "contextless" (x: f64) -> f64 {…}
ceil_f64be ¶
ceil_f64be :: proc "contextless" (x: f64be) -> f64be {…}
ceil_f64le ¶
ceil_f64le :: proc "contextless" (x: f64le) -> f64le {…}
classify_f16 ¶
classify_f16 :: proc "contextless" (x: f16) -> Float_Class {…}
classify_f16be ¶
classify_f16be :: proc "contextless" (x: f16be) -> Float_Class {…}
classify_f16le ¶
classify_f16le :: proc "contextless" (x: f16le) -> Float_Class {…}
classify_f32 ¶
classify_f32 :: proc "contextless" (x: f32) -> Float_Class {…}
classify_f32be ¶
classify_f32be :: proc "contextless" (x: f32be) -> Float_Class {…}
classify_f32le ¶
classify_f32le :: proc "contextless" (x: f32le) -> Float_Class {…}
classify_f64 ¶
classify_f64 :: proc "contextless" (x: f64) -> Float_Class {…}
classify_f64be ¶
classify_f64be :: proc "contextless" (x: f64be) -> Float_Class {…}
classify_f64le ¶
classify_f64le :: proc "contextless" (x: f64le) -> Float_Class {…}
copy_sign_f16 ¶
copy_sign_f16 :: proc "contextless" (x, y: f16) -> f16 {…}
copy_sign_f16be ¶
copy_sign_f16be :: proc "contextless" (x, y: f16be) -> f16be {…}
copy_sign_f16le ¶
copy_sign_f16le :: proc "contextless" (x, y: f16le) -> f16le {…}
copy_sign_f32 ¶
copy_sign_f32 :: proc "contextless" (x, y: f32) -> f32 {…}
copy_sign_f32be ¶
copy_sign_f32be :: proc "contextless" (x, y: f32be) -> f32be {…}
copy_sign_f32le ¶
copy_sign_f32le :: proc "contextless" (x, y: f32le) -> f32le {…}
copy_sign_f64 ¶
copy_sign_f64 :: proc "contextless" (x, y: f64) -> f64 {…}
copy_sign_f64be ¶
copy_sign_f64be :: proc "contextless" (x, y: f64be) -> f64be {…}
copy_sign_f64le ¶
copy_sign_f64le :: proc "contextless" (x, y: f64le) -> f64le {…}
cos_f16be ¶
cos_f16be :: proc "contextless" (θ: f16be) -> f16be {…}
cos_f16le ¶
cos_f16le :: proc "contextless" (θ: f16le) -> f16le {…}
cos_f32be ¶
cos_f32be :: proc "contextless" (θ: f32be) -> f32be {…}
cos_f32le ¶
cos_f32le :: proc "contextless" (θ: f32le) -> f32le {…}
cos_f64be ¶
cos_f64be :: proc "contextless" (θ: f64be) -> f64be {…}
cos_f64le ¶
cos_f64le :: proc "contextless" (θ: f64le) -> f64le {…}
cumsum_inplace ¶
cumsum_inplace :: proc "contextless" (x: $T/[]$T) {…}
erf_f16be ¶
erf_f16be :: proc "contextless" (x: f16be) -> f16be {…}
erf_f16le ¶
erf_f16le :: proc "contextless" (x: f16le) -> f16le {…}
erf_f32be ¶
erf_f32be :: proc "contextless" (x: f32be) -> f32be {…}
erf_f32le ¶
erf_f32le :: proc "contextless" (x: f32le) -> f32le {…}
erfc_f16 ¶
erfc_f16 :: proc "contextless" (x: f16) -> f16 {…}
erfc_f16be ¶
erfc_f16be :: proc "contextless" (x: f16be) -> f16be {…}
erfc_f16le ¶
erfc_f16le :: proc "contextless" (x: f16le) -> f16le {…}
erfc_f32 ¶
erfc_f32 :: proc "contextless" (x: f32) -> f32 {…}
erfc_f32be ¶
erfc_f32be :: proc "contextless" (x: f32be) -> f32be {…}
erfc_f32le ¶
erfc_f32le :: proc "contextless" (x: f32le) -> f32le {…}
erfc_f64 ¶
erfc_f64 :: proc "contextless" (x: f64) -> f64 {…}
exp_f16be ¶
exp_f16be :: proc "contextless" (x: f16be) -> f16be {…}
exp_f16le ¶
exp_f16le :: proc "contextless" (x: f16le) -> f16le {…}
exp_f32be ¶
exp_f32be :: proc "contextless" (x: f32be) -> f32be {…}
exp_f32le ¶
exp_f32le :: proc "contextless" (x: f32le) -> f32le {…}
exp_f64be ¶
exp_f64be :: proc "contextless" (x: f64be) -> f64be {…}
exp_f64le ¶
exp_f64le :: proc "contextless" (x: f64le) -> f64le {…}
factorial ¶
factorial :: proc "contextless" (n: int) -> int {…}
floor_div ¶
floor_div :: proc "contextless" (x, y: $T) -> $T {…}
floor_divmod ¶
floor_divmod :: proc "contextless" (x, y: $T) -> (div, mod: $T) {…}
floor_f16 ¶
floor_f16 :: proc "contextless" (x: f16) -> f16 {…}
floor_f16be ¶
floor_f16be :: proc "contextless" (x: f16be) -> f16be {…}
floor_f16le ¶
floor_f16le :: proc "contextless" (x: f16le) -> f16le {…}
floor_f32 ¶
floor_f32 :: proc "contextless" (x: f32) -> f32 {…}
floor_f32be ¶
floor_f32be :: proc "contextless" (x: f32be) -> f32be {…}
floor_f32le ¶
floor_f32le :: proc "contextless" (x: f32le) -> f32le {…}
floor_f64 ¶
floor_f64 :: proc "contextless" (x: f64) -> f64 {…}
floor_f64be ¶
floor_f64be :: proc "contextless" (x: f64be) -> f64be {…}
floor_f64le ¶
floor_f64le :: proc "contextless" (x: f64le) -> f64le {…}
floor_mod ¶
floor_mod :: proc "contextless" (x, y: $T) -> $T {…}
fmuladd_f16 ¶
fmuladd_f16 :: proc "none" (a, b, c: f16) -> f16 ---
fmuladd_f16be ¶
fmuladd_f16be :: proc "contextless" (a, b, c: f16be) -> f16be {…}
fmuladd_f16le ¶
fmuladd_f16le :: proc "contextless" (a, b, c: f16le) -> f16le {…}
fmuladd_f32 ¶
fmuladd_f32 :: proc "none" (a, b, c: f32) -> f32 ---
fmuladd_f32be ¶
fmuladd_f32be :: proc "contextless" (a, b, c: f32be) -> f32be {…}
fmuladd_f32le ¶
fmuladd_f32le :: proc "contextless" (a, b, c: f32le) -> f32le {…}
fmuladd_f64 ¶
fmuladd_f64 :: proc "none" (a, b, c: f64) -> f64 ---
fmuladd_f64be ¶
fmuladd_f64be :: proc "contextless" (a, b, c: f64be) -> f64be {…}
fmuladd_f64le ¶
fmuladd_f64le :: proc "contextless" (a, b, c: f64le) -> f64le {…}
frexp_f16 ¶
frexp_f16 :: proc "contextless" (x: f16) -> (significand: f16, exponent: int) {…}
frexp_f16be ¶
frexp_f16be :: proc "contextless" (x: f16be) -> (significand: f16be, exponent: int) {…}
frexp_f16le ¶
frexp_f16le :: proc "contextless" (x: f16le) -> (significand: f16le, exponent: int) {…}
frexp_f32 ¶
frexp_f32 :: proc "contextless" (x: f32) -> (significand: f32, exponent: int) {…}
frexp_f32be ¶
frexp_f32be :: proc "contextless" (x: f32be) -> (significand: f32be, exponent: int) {…}
frexp_f32le ¶
frexp_f32le :: proc "contextless" (x: f32le) -> (significand: f32le, exponent: int) {…}
frexp_f64 ¶
frexp_f64 :: proc "contextless" (f: f64) -> (significand: f64, exponent: int) {…}
frexp_f64be ¶
frexp_f64be :: proc "contextless" (x: f64be) -> (significand: f64be, exponent: int) {…}
frexp_f64le ¶
frexp_f64le :: proc "contextless" (x: f64le) -> (significand: f64le, exponent: int) {…}
gamma_f16 ¶
gamma_f16 :: proc "contextless" (x: f16) -> f16 {…}
gamma_f16be ¶
gamma_f16be :: proc "contextless" (x: f16be) -> f16be {…}
gamma_f16le ¶
gamma_f16le :: proc "contextless" (x: f16le) -> f16le {…}
gamma_f32 ¶
gamma_f32 :: proc "contextless" (x: f32) -> f32 {…}
gamma_f32be ¶
gamma_f32be :: proc "contextless" (x: f32be) -> f32be {…}
gamma_f32le ¶
gamma_f32le :: proc "contextless" (x: f32le) -> f32le {…}
gamma_f64 ¶
gamma_f64 :: proc "contextless" (x: f64) -> f64 {…}
gamma_f64be ¶
gamma_f64be :: proc "contextless" (x: f64be) -> f64be {…}
gamma_f64le ¶
gamma_f64le :: proc "contextless" (x: f64le) -> f64le {…}
ilogb_f16 ¶
ilogb_f16 :: proc "contextless" (val: f16) -> int {…}
ilogb_f16be ¶
ilogb_f16be :: proc "contextless" (value: f16be) -> int {…}
ilogb_f16le ¶
ilogb_f16le :: proc "contextless" (value: f16le) -> int {…}
ilogb_f32 ¶
ilogb_f32 :: proc "contextless" (val: f32) -> int {…}
ilogb_f32be ¶
ilogb_f32be :: proc "contextless" (value: f32be) -> int {…}
ilogb_f32le ¶
ilogb_f32le :: proc "contextless" (value: f32le) -> int {…}
ilogb_f64 ¶
ilogb_f64 :: proc "contextless" (val: f64) -> int {…}
ilogb_f64be ¶
ilogb_f64be :: proc "contextless" (value: f64be) -> int {…}
ilogb_f64le ¶
ilogb_f64le :: proc "contextless" (value: f64le) -> int {…}
inf_f16be ¶
inf_f16be :: proc "contextless" (sign: int) -> f16be {…}
inf_f16le ¶
inf_f16le :: proc "contextless" (sign: int) -> f16le {…}
inf_f32be ¶
inf_f32be :: proc "contextless" (sign: int) -> f32be {…}
inf_f32le ¶
inf_f32le :: proc "contextless" (sign: int) -> f32le {…}
inf_f64be ¶
inf_f64be :: proc "contextless" (sign: int) -> f64be {…}
inf_f64le ¶
inf_f64le :: proc "contextless" (sign: int) -> f64le {…}
is_inf_f16 ¶
is_inf_f16 :: proc "contextless" (x: f16, sign: int = 0) -> bool {…}
is_inf reports whether f is an infinity, according to sign. If sign > 0, is_inf reports whether f is positive infinity. If sign < 0, is_inf reports whether f is negative infinity. If sign == 0, is_inf reports whether f is either infinity.
is_inf_f16be ¶
is_inf_f16be :: proc "contextless" (x: f16be, sign: int = 0) -> bool {…}
is_inf_f16le ¶
is_inf_f16le :: proc "contextless" (x: f16le, sign: int = 0) -> bool {…}
is_inf_f32 ¶
is_inf_f32 :: proc "contextless" (x: f32, sign: int = 0) -> bool {…}
is_inf_f32be ¶
is_inf_f32be :: proc "contextless" (x: f32be, sign: int = 0) -> bool {…}
is_inf_f32le ¶
is_inf_f32le :: proc "contextless" (x: f32le, sign: int = 0) -> bool {…}
is_inf_f64 ¶
is_inf_f64 :: proc "contextless" (x: f64, sign: int = 0) -> bool {…}
is_inf_f64be ¶
is_inf_f64be :: proc "contextless" (x: f64be, sign: int = 0) -> bool {…}
is_inf_f64le ¶
is_inf_f64le :: proc "contextless" (x: f64le, sign: int = 0) -> bool {…}
is_nan_f16 ¶
is_nan_f16 :: proc "contextless" (x: f16) -> bool {…}
is_nan_f16be ¶
is_nan_f16be :: proc "contextless" (x: f16be) -> bool {…}
is_nan_f16le ¶
is_nan_f16le :: proc "contextless" (x: f16le) -> bool {…}
is_nan_f32 ¶
is_nan_f32 :: proc "contextless" (x: f32) -> bool {…}
is_nan_f32be ¶
is_nan_f32be :: proc "contextless" (x: f32be) -> bool {…}
is_nan_f32le ¶
is_nan_f32le :: proc "contextless" (x: f32le) -> bool {…}
is_nan_f64 ¶
is_nan_f64 :: proc "contextless" (x: f64) -> bool {…}
is_nan_f64be ¶
is_nan_f64be :: proc "contextless" (x: f64be) -> bool {…}
is_nan_f64le ¶
is_nan_f64le :: proc "contextless" (x: f64le) -> bool {…}
is_power_of_two ¶
is_power_of_two :: proc "contextless" (x: int) -> bool {…}
ldexp_f16 ¶
ldexp_f16 :: proc "contextless" (val: f16, exp: int) -> f16 {…}
ldexp_f16be ¶
ldexp_f16be :: proc "contextless" (val: f16be, exp: int) -> f16be {…}
ldexp_f16le ¶
ldexp_f16le :: proc "contextless" (val: f16le, exp: int) -> f16le {…}
ldexp_f32 ¶
ldexp_f32 :: proc "contextless" (val: f32, exp: int) -> f32 {…}
ldexp_f32be ¶
ldexp_f32be :: proc "contextless" (val: f32be, exp: int) -> f32be {…}
ldexp_f32le ¶
ldexp_f32le :: proc "contextless" (val: f32le, exp: int) -> f32le {…}
ldexp_f64 ¶
ldexp_f64 :: proc "contextless" (val: f64, exp: int) -> f64 {…}
ldexp_f64be ¶
ldexp_f64be :: proc "contextless" (val: f64be, exp: int) -> f64be {…}
ldexp_f64le ¶
ldexp_f64le :: proc "contextless" (val: f64le, exp: int) -> f64le {…}
lgamma_f16 ¶
lgamma_f16 :: proc "contextless" (x: f16) -> (lgamma: f16, sign: int) {…}
lgamma_f16be ¶
lgamma_f16be :: proc "contextless" (x: f16be) -> (lgamma: f16be, sign: int) {…}
lgamma_f16le ¶
lgamma_f16le :: proc "contextless" (x: f16le) -> (lgamma: f16le, sign: int) {…}
lgamma_f32 ¶
lgamma_f32 :: proc "contextless" (x: f32) -> (lgamma: f32, sign: int) {…}
lgamma_f32be ¶
lgamma_f32be :: proc "contextless" (x: f32be) -> (lgamma: f32be, sign: int) {…}
lgamma_f32le ¶
lgamma_f32le :: proc "contextless" (x: f32le) -> (lgamma: f32le, sign: int) {…}
lgamma_f64 ¶
lgamma_f64 :: proc "contextless" (x: f64) -> (lgamma: f64, sign: int) {…}
lgamma_f64be ¶
lgamma_f64be :: proc "contextless" (x: f64be) -> (lgamma: f64be, sign: int) {…}
lgamma_f64le ¶
lgamma_f64le :: proc "contextless" (x: f64le) -> (lgamma: f64le, sign: int) {…}
ln_f16be ¶
ln_f16be :: proc "contextless" (x: f16be) -> f16be {…}
ln_f16le ¶
ln_f16le :: proc "contextless" (x: f16le) -> f16le {…}
ln_f32be ¶
ln_f32be :: proc "contextless" (x: f32be) -> f32be {…}
ln_f32le ¶
ln_f32le :: proc "contextless" (x: f32le) -> f32le {…}
ln_f64be ¶
ln_f64be :: proc "contextless" (x: f64be) -> f64be {…}
ln_f64le ¶
ln_f64le :: proc "contextless" (x: f64le) -> f64le {…}
log10_f16 ¶
log10_f16 :: proc "contextless" (x: f16) -> f16 {…}
log10_f16be ¶
log10_f16be :: proc "contextless" (x: f16be) -> f16be {…}
log10_f16le ¶
log10_f16le :: proc "contextless" (x: f16le) -> f16le {…}
log10_f32 ¶
log10_f32 :: proc "contextless" (x: f32) -> f32 {…}
log10_f32be ¶
log10_f32be :: proc "contextless" (x: f32be) -> f32be {…}
log10_f32le ¶
log10_f32le :: proc "contextless" (x: f32le) -> f32le {…}
log10_f64 ¶
log10_f64 :: proc "contextless" (x: f64) -> f64 {…}
log10_f64be ¶
log10_f64be :: proc "contextless" (x: f64be) -> f64be {…}
log10_f64le ¶
log10_f64le :: proc "contextless" (x: f64le) -> f64le {…}
log1p_f16 ¶
log1p_f16 :: proc "contextless" (x: f16) -> f16 {…}
log1p_f16be ¶
log1p_f16be :: proc "contextless" (x: f16be) -> f16be {…}
log1p_f16le ¶
log1p_f16le :: proc "contextless" (x: f16le) -> f16le {…}
log1p_f32 ¶
log1p_f32 :: proc "contextless" (x: f32) -> f32 {…}
log1p_f32be ¶
log1p_f32be :: proc "contextless" (x: f32be) -> f32be {…}
log1p_f32le ¶
log1p_f32le :: proc "contextless" (x: f32le) -> f32le {…}
log1p_f64 ¶
log1p_f64 :: proc "contextless" (x: f64) -> f64 {…}
log1p_f64be ¶
log1p_f64be :: proc "contextless" (x: f64be) -> f64be {…}
log1p_f64le ¶
log1p_f64le :: proc "contextless" (x: f64le) -> f64le {…}
log2_f16 ¶
log2_f16 :: proc "contextless" (x: f16) -> f16 {…}
log2_f16be ¶
log2_f16be :: proc "contextless" (x: f16be) -> f16be {…}
log2_f16le ¶
log2_f16le :: proc "contextless" (x: f16le) -> f16le {…}
log2_f32 ¶
log2_f32 :: proc "contextless" (x: f32) -> f32 {…}
log2_f32be ¶
log2_f32be :: proc "contextless" (x: f32be) -> f32be {…}
log2_f32le ¶
log2_f32le :: proc "contextless" (x: f32le) -> f32le {…}
log2_f64 ¶
log2_f64 :: proc "contextless" (x: f64) -> f64 {…}
log2_f64be ¶
log2_f64be :: proc "contextless" (x: f64be) -> f64be {…}
log2_f64le ¶
log2_f64le :: proc "contextless" (x: f64le) -> f64le {…}
log_f16be ¶
log_f16be :: proc "contextless" (x, base: f16be) -> f16be {…}
log_f16le ¶
log_f16le :: proc "contextless" (x, base: f16le) -> f16le {…}
log_f32be ¶
log_f32be :: proc "contextless" (x, base: f32be) -> f32be {…}
log_f32le ¶
log_f32le :: proc "contextless" (x, base: f32le) -> f32le {…}
log_f64be ¶
log_f64be :: proc "contextless" (x, base: f64be) -> f64be {…}
log_f64le ¶
log_f64le :: proc "contextless" (x, base: f64le) -> f64le {…}
logb_f16 ¶
logb_f16 :: proc "contextless" (val: f16) -> f16 {…}
logb_f16be ¶
logb_f16be :: proc "contextless" (value: f16be) -> f16be {…}
logb_f16le ¶
logb_f16le :: proc "contextless" (value: f16le) -> f16le {…}
logb_f32 ¶
logb_f32 :: proc "contextless" (val: f32) -> f32 {…}
logb_f32be ¶
logb_f32be :: proc "contextless" (value: f32be) -> f32be {…}
logb_f32le ¶
logb_f32le :: proc "contextless" (value: f32le) -> f32le {…}
logb_f64 ¶
logb_f64 :: proc "contextless" (val: f64) -> f64 {…}
logb_f64be ¶
logb_f64be :: proc "contextless" (value: f64be) -> f64be {…}
logb_f64le ¶
logb_f64le :: proc "contextless" (value: f64le) -> f64le {…}
mod_f16be ¶
mod_f16be :: proc "contextless" (x, y: f16be) -> (n: f16be) {…}
mod_f16le ¶
mod_f16le :: proc "contextless" (x, y: f16le) -> (n: f16le) {…}
mod_f32be ¶
mod_f32be :: proc "contextless" (x, y: f32be) -> (n: f32be) {…}
mod_f32le ¶
mod_f32le :: proc "contextless" (x, y: f32le) -> (n: f32le) {…}
mod_f64be ¶
mod_f64be :: proc "contextless" (x, y: f64be) -> (n: f64be) {…}
mod_f64le ¶
mod_f64le :: proc "contextless" (x, y: f64le) -> (n: f64le) {…}
modf_f16 ¶
modf_f16 :: proc "contextless" (x: f16) -> (int: f16, frac: f16) {…}
modf_f16be ¶
modf_f16be :: proc "contextless" (x: f16be) -> (int: f16be, frac: f16be) {…}
modf_f16le ¶
modf_f16le :: proc "contextless" (x: f16le) -> (int: f16le, frac: f16le) {…}
modf_f32 ¶
modf_f32 :: proc "contextless" (x: f32) -> (int: f32, frac: f32) {…}
modf_f32be ¶
modf_f32be :: proc "contextless" (x: f32be) -> (int: f32be, frac: f32be) {…}
modf_f32le ¶
modf_f32le :: proc "contextless" (x: f32le) -> (int: f32le, frac: f32le) {…}
modf_f64 ¶
modf_f64 :: proc "contextless" (x: f64) -> (int: f64, frac: f64) {…}
modf_f64be ¶
modf_f64be :: proc "contextless" (x: f64be) -> (int: f64be, frac: f64be) {…}
modf_f64le ¶
modf_f64le :: proc "contextless" (x: f64le) -> (int: f64le, frac: f64le) {…}
nan_f16be ¶
nan_f16be :: proc "contextless" () -> f16be {…}
nan_f16le ¶
nan_f16le :: proc "contextless" () -> f16le {…}
nan_f32be ¶
nan_f32be :: proc "contextless" () -> f32be {…}
nan_f32le ¶
nan_f32le :: proc "contextless" () -> f32le {…}
nan_f64be ¶
nan_f64be :: proc "contextless" () -> f64be {…}
nan_f64le ¶
nan_f64le :: proc "contextless" () -> f64le {…}
next_power_of_two ¶
next_power_of_two :: proc "contextless" (x: int) -> int {…}
nextafter_f16 ¶
nextafter_f16 :: proc "contextless" (x, y: f16) -> (r: f16) {…}
nextafter_f16be ¶
nextafter_f16be :: proc "contextless" (x, y: f16be) -> (r: f16be) {…}
nextafter_f16le ¶
nextafter_f16le :: proc "contextless" (x, y: f16le) -> (r: f16le) {…}
nextafter_f32 ¶
nextafter_f32 :: proc "contextless" (x, y: f32) -> (r: f32) {…}
nextafter_f32be ¶
nextafter_f32be :: proc "contextless" (x, y: f32be) -> (r: f32be) {…}
nextafter_f32le ¶
nextafter_f32le :: proc "contextless" (x, y: f32le) -> (r: f32le) {…}
nextafter_f64 ¶
nextafter_f64 :: proc "contextless" (x, y: f64) -> (r: f64) {…}
nextafter_f64be ¶
nextafter_f64be :: proc "contextless" (x, y: f64be) -> (r: f64be) {…}
nextafter_f64le ¶
nextafter_f64le :: proc "contextless" (x, y: f64le) -> (r: f64le) {…}
normalize_f16 ¶
normalize_f16 :: proc "contextless" (x: f16) -> (y: f16, exponent: int) {…}
normalize_f16be ¶
normalize_f16be :: proc "contextless" (x: f16be) -> (y: f16be, exponent: int) {…}
normalize_f16le ¶
normalize_f16le :: proc "contextless" (x: f16le) -> (y: f16le, exponent: int) {…}
normalize_f32 ¶
normalize_f32 :: proc "contextless" (x: f32) -> (y: f32, exponent: int) {…}
normalize_f32be ¶
normalize_f32be :: proc "contextless" (x: f32be) -> (y: f32be, exponent: int) {…}
normalize_f32le ¶
normalize_f32le :: proc "contextless" (x: f32le) -> (y: f32le, exponent: int) {…}
normalize_f64 ¶
normalize_f64 :: proc "contextless" (x: f64) -> (y: f64, exponent: int) {…}
normalize_f64be ¶
normalize_f64be :: proc "contextless" (x: f64be) -> (y: f64be, exponent: int) {…}
normalize_f64le ¶
normalize_f64le :: proc "contextless" (x: f64le) -> (y: f64le, exponent: int) {…}
pow10_f16 ¶
pow10_f16 :: proc "contextless" (n: f16) -> f16 {…}
pow10_f16be ¶
pow10_f16be :: proc "contextless" (x: f16be) -> f16be {…}
pow10_f16le ¶
pow10_f16le :: proc "contextless" (x: f16le) -> f16le {…}
pow10_f32 ¶
pow10_f32 :: proc "contextless" (n: f32) -> f32 {…}
pow10_f32be ¶
pow10_f32be :: proc "contextless" (x: f32be) -> f32be {…}
pow10_f32le ¶
pow10_f32le :: proc "contextless" (x: f32le) -> f32le {…}
pow10_f64 ¶
pow10_f64 :: proc "contextless" (n: f64) -> f64 {…}
pow10_f64be ¶
pow10_f64be :: proc "contextless" (x: f64be) -> f64be {…}
pow10_f64le ¶
pow10_f64le :: proc "contextless" (x: f64le) -> f64le {…}
pow_f16be ¶
pow_f16be :: proc "contextless" (x, power: f16be) -> f16be {…}
pow_f16le ¶
pow_f16le :: proc "contextless" (x, power: f16le) -> f16le {…}
pow_f32be ¶
pow_f32be :: proc "contextless" (x, power: f32be) -> f32be {…}
pow_f32le ¶
pow_f32le :: proc "contextless" (x, power: f32le) -> f32le {…}
pow_f64be ¶
pow_f64be :: proc "contextless" (x, power: f64be) -> f64be {…}
pow_f64le ¶
pow_f64le :: proc "contextless" (x, power: f64le) -> f64le {…}
remainder_f16 ¶
remainder_f16 :: proc "contextless" (x, y: f16) -> f16 {…}
remainder_f16be ¶
remainder_f16be :: proc "contextless" (x, y: f16be) -> f16be {…}
remainder_f16le ¶
remainder_f16le :: proc "contextless" (x, y: f16le) -> f16le {…}
remainder_f32 ¶
remainder_f32 :: proc "contextless" (x, y: f32) -> f32 {…}
remainder_f32be ¶
remainder_f32be :: proc "contextless" (x, y: f32be) -> f32be {…}
remainder_f32le ¶
remainder_f32le :: proc "contextless" (x, y: f32le) -> f32le {…}
remainder_f64 ¶
remainder_f64 :: proc "contextless" (x, y: f64) -> f64 {…}
remainder_f64be ¶
remainder_f64be :: proc "contextless" (x, y: f64be) -> f64be {…}
remainder_f64le ¶
remainder_f64le :: proc "contextless" (x, y: f64le) -> f64le {…}
remap ¶
remap :: proc "contextless" (old_value, old_min, old_max, new_min, new_max: $T) -> (x: $T) {…}
round_f16 ¶
round_f16 :: proc "contextless" (x: f16) -> f16 {…}
round_f16be ¶
round_f16be :: proc "contextless" (x: f16be) -> f16be {…}
round_f16le ¶
round_f16le :: proc "contextless" (x: f16le) -> f16le {…}
round_f32 ¶
round_f32 :: proc "contextless" (x: f32) -> f32 {…}
round_f32be ¶
round_f32be :: proc "contextless" (x: f32be) -> f32be {…}
round_f32le ¶
round_f32le :: proc "contextless" (x: f32le) -> f32le {…}
round_f64 ¶
round_f64 :: proc "contextless" (x: f64) -> f64 {…}
round_f64be ¶
round_f64be :: proc "contextless" (x: f64be) -> f64be {…}
round_f64le ¶
round_f64le :: proc "contextless" (x: f64le) -> f64le {…}
saturate ¶
saturate :: proc "contextless" (a: $T) -> (x: $T) {…}
sign_bit_f16 ¶
sign_bit_f16 :: proc "contextless" (x: f16) -> bool {…}
sign_bit_f16be ¶
sign_bit_f16be :: proc "contextless" (x: f16be) -> bool {…}
sign_bit_f16le ¶
sign_bit_f16le :: proc "contextless" (x: f16le) -> bool {…}
sign_bit_f32 ¶
sign_bit_f32 :: proc "contextless" (x: f32) -> bool {…}
sign_bit_f32be ¶
sign_bit_f32be :: proc "contextless" (x: f32be) -> bool {…}
sign_bit_f32le ¶
sign_bit_f32le :: proc "contextless" (x: f32le) -> bool {…}
sign_bit_f64 ¶
sign_bit_f64 :: proc "contextless" (x: f64) -> bool {…}
sign_bit_f64be ¶
sign_bit_f64be :: proc "contextless" (x: f64be) -> bool {…}
sign_bit_f64le ¶
sign_bit_f64le :: proc "contextless" (x: f64le) -> bool {…}
sign_f16 ¶
sign_f16 :: proc "contextless" (x: f16) -> f16 {…}
sign_f16be ¶
sign_f16be :: proc "contextless" (x: f16be) -> f16be {…}
sign_f16le ¶
sign_f16le :: proc "contextless" (x: f16le) -> f16le {…}
sign_f32 ¶
sign_f32 :: proc "contextless" (x: f32) -> f32 {…}
sign_f32be ¶
sign_f32be :: proc "contextless" (x: f32be) -> f32be {…}
sign_f32le ¶
sign_f32le :: proc "contextless" (x: f32le) -> f32le {…}
sign_f64 ¶
sign_f64 :: proc "contextless" (x: f64) -> f64 {…}
sign_f64be ¶
sign_f64be :: proc "contextless" (x: f64be) -> f64be {…}
sign_f64le ¶
sign_f64le :: proc "contextless" (x: f64le) -> f64le {…}
signbit_f16 ¶
signbit_f16 :: proc "contextless" (x: f16) -> bool {…}
signbit_f16be ¶
signbit_f16be :: proc "contextless" (x: f16be) -> bool {…}
signbit_f16le ¶
signbit_f16le :: proc "contextless" (x: f16le) -> bool {…}
signbit_f32 ¶
signbit_f32 :: proc "contextless" (x: f32) -> bool {…}
signbit_f32be ¶
signbit_f32be :: proc "contextless" (x: f32be) -> bool {…}
signbit_f32le ¶
signbit_f32le :: proc "contextless" (x: f32le) -> bool {…}
signbit_f64 ¶
signbit_f64 :: proc "contextless" (x: f64) -> bool {…}
signbit_f64be ¶
signbit_f64be :: proc "contextless" (x: f64be) -> bool {…}
signbit_f64le ¶
signbit_f64le :: proc "contextless" (x: f64le) -> bool {…}
sin_f16be ¶
sin_f16be :: proc "contextless" (θ: f16be) -> f16be {…}
sin_f16le ¶
sin_f16le :: proc "contextless" (θ: f16le) -> f16le {…}
sin_f32be ¶
sin_f32be :: proc "contextless" (θ: f32be) -> f32be {…}
sin_f32le ¶
sin_f32le :: proc "contextless" (θ: f32le) -> f32le {…}
sin_f64be ¶
sin_f64be :: proc "contextless" (θ: f64be) -> f64be {…}
sin_f64le ¶
sin_f64le :: proc "contextless" (θ: f64le) -> f64le {…}
smoothstep ¶
smoothstep :: proc "contextless" (edge0, edge1, x: $T) -> $T {…}
sqrt_f16 ¶
sqrt_f16 :: proc "contextless" (x: f16) -> f16 {…}
sqrt_f16be ¶
sqrt_f16be :: proc "contextless" (x: f16be) -> f16be {…}
sqrt_f16le ¶
sqrt_f16le :: proc "contextless" (x: f16le) -> f16le {…}
sqrt_f32 ¶
sqrt_f32 :: proc "contextless" (x: f32) -> f32 {…}
sqrt_f32be ¶
sqrt_f32be :: proc "contextless" (x: f32be) -> f32be {…}
sqrt_f32le ¶
sqrt_f32le :: proc "contextless" (x: f32le) -> f32le {…}
sqrt_f64 ¶
sqrt_f64 :: proc "contextless" (x: f64) -> f64 {…}
sqrt_f64be ¶
sqrt_f64be :: proc "contextless" (x: f64be) -> f64be {…}
sqrt_f64le ¶
sqrt_f64le :: proc "contextless" (x: f64le) -> f64le {…}
tan_f16be ¶
tan_f16be :: proc "contextless" (θ: f16be) -> f16be {…}
tan_f16le ¶
tan_f16le :: proc "contextless" (θ: f16le) -> f16le {…}
tan_f32be ¶
tan_f32be :: proc "contextless" (θ: f32be) -> f32be {…}
tan_f32le ¶
tan_f32le :: proc "contextless" (θ: f32le) -> f32le {…}
tan_f64be ¶
tan_f64be :: proc "contextless" (θ: f64be) -> f64be {…}
tan_f64le ¶
tan_f64le :: proc "contextless" (θ: f64le) -> f64le {…}
to_degrees_f16 ¶
to_degrees_f16 :: proc "contextless" (radians: f16) -> f16 {…}
to_degrees_f16be ¶
to_degrees_f16be :: proc "contextless" (radians: f16be) -> f16be {…}
to_degrees_f16le ¶
to_degrees_f16le :: proc "contextless" (radians: f16le) -> f16le {…}
to_degrees_f32 ¶
to_degrees_f32 :: proc "contextless" (radians: f32) -> f32 {…}
to_degrees_f32be ¶
to_degrees_f32be :: proc "contextless" (radians: f32be) -> f32be {…}
to_degrees_f32le ¶
to_degrees_f32le :: proc "contextless" (radians: f32le) -> f32le {…}
to_degrees_f64 ¶
to_degrees_f64 :: proc "contextless" (radians: f64) -> f64 {…}
to_degrees_f64be ¶
to_degrees_f64be :: proc "contextless" (radians: f64be) -> f64be {…}
to_degrees_f64le ¶
to_degrees_f64le :: proc "contextless" (radians: f64le) -> f64le {…}
to_radians_f16 ¶
to_radians_f16 :: proc "contextless" (degrees: f16) -> f16 {…}
to_radians_f16be ¶
to_radians_f16be :: proc "contextless" (degrees: f16be) -> f16be {…}
to_radians_f16le ¶
to_radians_f16le :: proc "contextless" (degrees: f16le) -> f16le {…}
to_radians_f32 ¶
to_radians_f32 :: proc "contextless" (degrees: f32) -> f32 {…}
to_radians_f32be ¶
to_radians_f32be :: proc "contextless" (degrees: f32be) -> f32be {…}
to_radians_f32le ¶
to_radians_f32le :: proc "contextless" (degrees: f32le) -> f32le {…}
to_radians_f64 ¶
to_radians_f64 :: proc "contextless" (degrees: f64) -> f64 {…}
to_radians_f64be ¶
to_radians_f64be :: proc "contextless" (degrees: f64be) -> f64be {…}
to_radians_f64le ¶
to_radians_f64le :: proc "contextless" (degrees: f64le) -> f64le {…}
trunc_f16 ¶
trunc_f16 :: proc "contextless" (x: f16) -> f16 {…}
trunc_f16be ¶
trunc_f16be :: proc "contextless" (x: f16be) -> f16be {…}
trunc_f16le ¶
trunc_f16le :: proc "contextless" (x: f16le) -> f16le {…}
trunc_f32 ¶
trunc_f32 :: proc "contextless" (x: f32) -> f32 {…}
trunc_f32be ¶
trunc_f32be :: proc "contextless" (x: f32be) -> f32be {…}
trunc_f32le ¶
trunc_f32le :: proc "contextless" (x: f32le) -> f32le {…}
trunc_f64 ¶
trunc_f64 :: proc "contextless" (x: f64) -> f64 {…}
trunc_f64be ¶
trunc_f64be :: proc "contextless" (x: f64be) -> f64be {…}
trunc_f64le ¶
trunc_f64le :: proc "contextless" (x: f64le) -> f64le {…}
Procedure Groups
acos ¶
acos :: proc{ acos_f64, acos_f32, acos_f16, acos_f64le, acos_f64be, acos_f32le, acos_f32be, acos_f16le, acos_f16be, }
asin ¶
asin :: proc{ asin_f64, asin_f32, asin_f16, asin_f64le, asin_f64be, asin_f32le, asin_f32be, asin_f16le, asin_f16be, }
atan2 ¶
atan2 :: proc{ atan2_f64, atan2_f32, atan2_f16, atan2_f64le, atan2_f64be, atan2_f32le, atan2_f32be, atan2_f16le, atan2_f16be, }
ceil ¶
ceil :: proc{ ceil_f16, ceil_f16le, ceil_f16be, ceil_f32, ceil_f32le, ceil_f32be, ceil_f64, ceil_f64le, ceil_f64be, }
classify ¶
classify :: proc{ classify_f16, classify_f16le, classify_f16be, classify_f32, classify_f32le, classify_f32be, classify_f64, classify_f64le, classify_f64be, }
Returns the Float_Class
of the value, i.e. whether normal, subnormal, zero, negative zero, NaN, infinity or
negative infinity.
copy_sign ¶
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, }
erfc ¶
erfc :: proc{ erfc_f16, erfc_f16le, erfc_f16be, erfc_f32, erfc_f32le, erfc_f32be, erfc_f64, }
floor ¶
floor :: proc{ floor_f16, floor_f16le, floor_f16be, floor_f32, floor_f32le, floor_f32be, floor_f64, floor_f64le, floor_f64be, }
fmuladd ¶
fmuladd :: proc{ fmuladd_f16, fmuladd_f16le, fmuladd_f16be, fmuladd_f32, fmuladd_f32le, fmuladd_f32be, fmuladd_f64, fmuladd_f64le, fmuladd_f64be, }
frexp ¶
frexp :: proc{ frexp_f16, frexp_f16le, frexp_f16be, frexp_f32, frexp_f32le, frexp_f32be, frexp_f64, frexp_f64le, frexp_f64be, }
frexp breaks the value into a normalized fraction, and an integral power of two It returns a significand and exponent satisfying x == significand 2*exponent with the absolute value of significand in the intervalue of [0.5, 1).
Special cases:
frexp(+0) = +0, 0 frexp(-0) = -0, 0 frexp(+inf) = +inf, 0 frexp(-inf) = -inf, 0 frexp(NaN) = NaN, 0
gamma ¶
gamma :: proc{ gamma_f16, gamma_f16le, gamma_f16be, gamma_f32, gamma_f32le, gamma_f32be, gamma_f64, gamma_f64le, gamma_f64be, }
ilogb ¶
ilogb :: proc{ ilogb_f16, ilogb_f32, ilogb_f64, ilogb_f16le, ilogb_f16be, ilogb_f32le, ilogb_f32be, ilogb_f64le, ilogb_f64be, }
is_inf ¶
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 ¶
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 ¶
ldexp :: proc{ ldexp_f16, ldexp_f16le, ldexp_f16be, ldexp_f32, ldexp_f32le, ldexp_f32be, ldexp_f64, ldexp_f64le, ldexp_f64be, }
ldexp is the inverse of frexp it returns val 2*exp.
Special cases:
ldexp(+0, exp) = +0 ldexp(-0, exp) = -0 ldexp(+inf, exp) = +inf ldexp(-inf, exp) = -inf ldexp(NaN, exp) = NaN
lgamma ¶
lgamma :: proc{ lgamma_f16, lgamma_f16le, lgamma_f16be, lgamma_f32, lgamma_f32le, lgamma_f32be, lgamma_f64, lgamma_f64le, lgamma_f64be, }
log10 ¶
log10 :: proc{ log10_f16, log10_f16le, log10_f16be, log10_f32, log10_f32le, log10_f32be, log10_f64, log10_f64le, log10_f64be, }
log1p ¶
log1p :: proc{ log1p_f16, log1p_f32, log1p_f64, log1p_f16le, log1p_f16be, log1p_f32le, log1p_f32be, log1p_f64le, log1p_f64be, }
log2 ¶
log2 :: proc{ log2_f16, log2_f16le, log2_f16be, log2_f32, log2_f32le, log2_f32be, log2_f64, log2_f64le, log2_f64be, }
logb ¶
logb :: proc{ logb_f16, logb_f32, logb_f64, logb_f16le, logb_f16be, logb_f32le, logb_f32be, logb_f64le, logb_f64be, }
modf ¶
modf :: proc{ modf_f16, modf_f16le, modf_f16be, modf_f32, modf_f32le, modf_f32be, modf_f64, modf_f64le, modf_f64be, }
nextafter ¶
nextafter :: proc{ nextafter_f16, nextafter_f16le, nextafter_f16be, nextafter_f32, nextafter_f32le, nextafter_f32be, nextafter_f64, nextafter_f64le, nextafter_f64be, }
normalize ¶
normalize :: proc{ normalize_f16, normalize_f32, normalize_f64, normalize_f16le, normalize_f16be, normalize_f32le, normalize_f32be, normalize_f64le, normalize_f64be, }
pow10 ¶
pow10 :: proc{ pow10_f16, pow10_f16le, pow10_f16be, pow10_f32, pow10_f32le, pow10_f32be, pow10_f64, pow10_f64le, pow10_f64be, }
remainder ¶
remainder :: proc{ remainder_f16, remainder_f16le, remainder_f16be, remainder_f32, remainder_f32le, remainder_f32be, remainder_f64, remainder_f64le, remainder_f64be, }
round ¶
round :: proc{ round_f16, round_f16le, round_f16be, round_f32, round_f32le, round_f32be, round_f64, round_f64le, round_f64be, }
sign ¶
sign :: proc{ sign_f16, sign_f16le, sign_f16be, sign_f32, sign_f32le, sign_f32be, sign_f64, sign_f64le, sign_f64be, }
sign_bit ¶
sign_bit :: proc{ sign_bit_f16, sign_bit_f16le, sign_bit_f16be, sign_bit_f32, sign_bit_f32le, sign_bit_f32be, sign_bit_f64, sign_bit_f64le, sign_bit_f64be, }
signbit ¶
signbit :: proc{ signbit_f16, signbit_f16le, signbit_f16be, signbit_f32, signbit_f32le, signbit_f32be, signbit_f64, signbit_f64le, signbit_f64be, }
split_decimal ¶
split_decimal :: proc{ modf_f16, modf_f16le, modf_f16be, modf_f32, modf_f32le, modf_f32be, modf_f64, modf_f64le, modf_f64be, }
sqrt ¶
sqrt :: proc{ sqrt_f16, sqrt_f16le, sqrt_f16be, sqrt_f32, sqrt_f32le, sqrt_f32be, sqrt_f64, sqrt_f64le, sqrt_f64be, }
to_degrees ¶
to_degrees :: proc{ to_degrees_f16, to_degrees_f16le, to_degrees_f16be, to_degrees_f32, to_degrees_f32le, to_degrees_f32be, to_degrees_f64, to_degrees_f64le, to_degrees_f64be, }
to_radians ¶
to_radians :: proc{ to_radians_f16, to_radians_f16le, to_radians_f16be, to_radians_f32, to_radians_f32le, to_radians_f32be, to_radians_f64, to_radians_f64le, to_radians_f64be, }
trunc ¶
trunc :: proc{ trunc_f16, trunc_f16le, trunc_f16be, trunc_f32, trunc_f32le, trunc_f32be, trunc_f64, trunc_f64le, trunc_f64be, }
Removes the fractional part of the value, i.e. rounds towards zero.
Source Files
Generation Information
Generated with odin version dev-2023-06 (vendor "odin") Windows_amd64 @ 2023-06-02 21:08:32.556682900 +0000 UTC