package core:math

Index

Types (1)
Variables (0)

This section is empty.

Procedures (403)

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

E ¶

E :: 2.71828182845904523536

F16_BIAS ¶

F16_BIAS :: 0xf

F16_DIG ¶

F16_DIG :: 3

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 ¶

F16_MAX :: 65504.0

F16_MAX_10_EXP ¶

F16_MAX_10_EXP :: 4

F16_MAX_EXP ¶

F16_MAX_EXP :: 15

F16_MIN ¶

F16_MIN :: 6.10351562e-5

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_DIG ¶

F32_DIG :: 6

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 ¶

F32_MAX :: 3.402823466e+38

F32_MAX_10_EXP ¶

F32_MAX_10_EXP :: 38

F32_MAX_EXP ¶

F32_MAX_EXP :: 128

F32_MIN ¶

F32_MIN :: 1.175494351e-38

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_DIG ¶

F64_DIG :: 15

F64_EPSILON ¶

F64_EPSILON :: 2.2204460492503131e-016

F64_MANT_DIG ¶

F64_MANT_DIG :: 53

F64_MASK ¶

F64_MASK :: 0x7ff

F64_MAX ¶

F64_MAX :: 1.7976931348623158e+308

F64_MAX_10_EXP ¶

F64_MAX_10_EXP :: 308

F64_MAX_EXP ¶

F64_MAX_EXP :: 1024

F64_MIN ¶

F64_MIN :: 2.2250738585072014e-308

F64_MIN_10_EXP ¶

F64_MIN_10_EXP :: -307

F64_MIN_EXP ¶

F64_MIN_EXP :: -1021

F64_RADIX ¶

F64_RADIX :: 2

F64_ROUNDS ¶

F64_ROUNDS :: 1

F64_SHIFT ¶

F64_SHIFT :: 64 - 12

INF_F16 ¶

INF_F16: f16 : 0h7C00

INF_F32 ¶

INF_F32: f32 : 0h7F80_0000

INF_F64 ¶

INF_F64: f64 : 0h7FF0_0000_0000_0000

LN10 ¶

LN10 :: 2.30258509299404568401799145468436421

LN2 ¶

LN2 :: 0.693147180559945309417232121458176568

MAX_F16_PRECISION ¶

MAX_F16_PRECISION :: 4

MAX_F32_PRECISION ¶

MAX_F32_PRECISION :: 8

MAX_F64_PRECISION ¶

MAX_F64_PRECISION :: 16

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

PI ¶

PI :: 3.14159265358979323846264338327950288

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

TAU ¶

TAU :: 6.28318530717958647692528676655900576

e ¶

e :: E

π ¶

π :: PI

τ ¶

τ :: TAU

Variables

This section is empty.

Procedures

abs ¶

abs :: builtin.abs

acos ¶

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

acosh ¶

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

angle_diff ¶

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

angle_lerp ¶

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

asin ¶

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

asinh ¶

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

atan ¶

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

atan2_f16 ¶

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

atan2_f16be ¶

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

atan2_f16le ¶

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

atan2_f32 ¶

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

atan2_f32be ¶

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

atan2_f32le ¶

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

atan2_f64 ¶

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

atan2_f64be ¶

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

atan2_f64le ¶

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

atanh ¶

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

bias ¶

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

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

clamp ¶

clamp :: builtin.clamp

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, base: f16) -> f16 {…}

copy_sign_f16be ¶

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

copy_sign_f16le ¶

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

copy_sign_f32 ¶

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

copy_sign_f32be ¶

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

copy_sign_f32le ¶

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

copy_sign_f64 ¶

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

copy_sign_f64be ¶

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

copy_sign_f64le ¶

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

cos_f16 ¶

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

cos_f16be ¶

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

cos_f16le ¶

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

cos_f32 ¶

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

cos_f32be ¶

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

cos_f32le ¶

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

cos_f64 ¶

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

cos_f64be ¶

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

cos_f64le ¶

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

cosh ¶

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

cumsum ¶

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

cumsum_inplace ¶

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

divmod ¶

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

erf_f16 ¶

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

erf_f16be ¶

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

erf_f16le ¶

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

erf_f32 ¶

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

erf_f32be ¶

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

erf_f32le ¶

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

erf_f64 ¶

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

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_f16 ¶

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

exp_f16be ¶

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

exp_f16le ¶

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

exp_f32 ¶

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

exp_f32be ¶

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

exp_f32le ¶

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

exp_f64 ¶

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

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: $) -> $ {…}

floor_divmod ¶

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

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: $) -> $ {…}

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) -> (y: f16, exponent: int) {…}

frexp_f16be ¶

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

frexp_f16le ¶

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

frexp_f32 ¶

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

frexp_f32be ¶

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

frexp_f32le ¶

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

frexp_f64 ¶

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

frexp_f64be ¶

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

frexp_f64le ¶

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

gain ¶

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

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

gcd ¶

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

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_f16 ¶

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

inf_f16be ¶

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

inf_f16le ¶

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

inf_f32 ¶

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

inf_f32be ¶

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

inf_f32le ¶

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

inf_f64 ¶

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

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

lcm ¶

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

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

lerp ¶

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

lgamma_f16 ¶

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

lgamma_f16be ¶

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

lgamma_f16le ¶

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

lgamma_f32 ¶

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

lgamma_f32be ¶

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

lgamma_f32le ¶

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

lgamma_f64 ¶

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

lgamma_f64be ¶

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

lgamma_f64le ¶

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

ln_f16 ¶

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

ln_f16be ¶

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

ln_f16le ¶

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

ln_f32 ¶

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

ln_f32be ¶

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

ln_f32le ¶

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

ln_f64 ¶

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

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_f16 ¶

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

log_f16be ¶

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

log_f16le ¶

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

log_f32 ¶

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

log_f32be ¶

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

log_f32le ¶

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

log_f64 ¶

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

log_f64be ¶

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

log_f64le ¶

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

logb_f16 ¶

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

logb_f16be ¶

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

logb_f16le ¶

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

logb_f32 ¶

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

logb_f32be ¶

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

logb_f32le ¶

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

logb_f64 ¶

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

logb_f64be ¶

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

logb_f64le ¶

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

max ¶

max :: builtin.max

min ¶

min :: builtin.min

mod_f16 ¶

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

mod_f16be ¶

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

mod_f16le ¶

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

mod_f32 ¶

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

mod_f32be ¶

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

mod_f32le ¶

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

mod_f64 ¶

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

mod_f64be ¶

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

mod_f64le ¶

mod_f64le :: proc "contextless" (x, power: f64le) -> 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_f16 ¶

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

nan_f16be ¶

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

nan_f16le ¶

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

nan_f32 ¶

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

nan_f32be ¶

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

nan_f32le ¶

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

nan_f64 ¶

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

nan_f64be ¶

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

nan_f64le ¶

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

next_power_of_two ¶

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

nextafter_f16 ¶

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

nextafter_f16be ¶

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

nextafter_f16le ¶

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

nextafter_f32 ¶

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

nextafter_f32be ¶

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

nextafter_f32le ¶

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

nextafter_f64 ¶

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

nextafter_f64be ¶

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

nextafter_f64le ¶

nextafter_f64le :: proc "contextless" (x, power: f64le) -> 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) {…}

pow_f16 ¶

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

pow_f16be ¶

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

pow_f16le ¶

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

pow_f32 ¶

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

pow_f32be ¶

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

pow_f32le ¶

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

pow_f64 ¶

pow_f64 :: proc "none" (x, power: f64) -> f64 ---

pow_f64be ¶

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

pow_f64le ¶

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

prod ¶

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

remainder_f16 ¶

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

remainder_f16be ¶

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

remainder_f16le ¶

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

remainder_f32 ¶

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

remainder_f32be ¶

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

remainder_f32le ¶

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

remainder_f64 ¶

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

remainder_f64be ¶

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

remainder_f64le ¶

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

remap ¶

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

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: $) -> (x: $) {…}

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_f16 ¶

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

sin_f16be ¶

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

sin_f16le ¶

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

sin_f32 ¶

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

sin_f32be ¶

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

sin_f32le ¶

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

sin_f64 ¶

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

sin_f64be ¶

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

sin_f64le ¶

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

sinh ¶

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

smoothstep ¶

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

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

step ¶

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

sum ¶

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

tan_f16 ¶

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

tan_f16be ¶

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

tan_f16le ¶

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

tan_f32 ¶

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

tan_f32be ¶

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

tan_f32le ¶

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

tan_f64 ¶

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

tan_f64be ¶

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

tan_f64le ¶

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

tanh ¶

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

to_degrees_f16 ¶

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

to_degrees_f16be ¶

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

to_degrees_f16le ¶

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

to_degrees_f32 ¶

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

to_degrees_f32be ¶

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

to_degrees_f32le ¶

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

to_degrees_f64 ¶

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

to_degrees_f64be ¶

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

to_degrees_f64le ¶

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

to_radians_f16 ¶

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

to_radians_f16be ¶

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

to_radians_f16le ¶

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

to_radians_f32 ¶

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

to_radians_f32be ¶

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

to_radians_f32le ¶

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

to_radians_f64 ¶

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

to_radians_f64be ¶

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

to_radians_f64le ¶

to_radians_f64le :: proc "contextless" (x: 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 {…}

unlerp ¶

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

wrap ¶

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

Procedure Groups

classify ¶

 

Returns the Float_Class of the value, i.e. whether normal, subnormal, zero, negative zero, NaN, infinity or negative infinity.

frexp ¶

 

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

ldexp ¶

 

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

trunc ¶

 

Removes the fractional part of the value, i.e. rounds towards zero.

Source Files

Generation Information

Generated with odin version dev-2022-10 (vendor "odin") Windows_amd64 @ 2022-10-05 21:11:47.398670600 +0000 UTC