package core:math
Source

⌘K
Ctrl+K
or
/

    Index

    Types (1)
    Variables (0)

    This section is empty.

    Procedures (451)

    Types

    Float_Class ¶
    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
}
    Related Procedures With Returns

    Constants

    DEG_PER_RAD ¶
    Source

    DEG_PER_RAD :: 360.0 / TAU

    E ¶
    Source

    E :: 2.71828182845904523536

    F16_BIAS ¶
    Source

    F16_BIAS :: 0xf

    F16_DIG ¶
    Source

    F16_DIG :: 3

    F16_EPSILON ¶
    Source

    F16_EPSILON :: 0.00097656

    F16_GUARD ¶
    Source

    F16_GUARD :: 0

    F16_MANT_DIG ¶
    Source

    F16_MANT_DIG :: 11

    F16_MASK ¶
    Source

    F16_MASK :: 0x1f

    F16_MAX ¶
    Source

    F16_MAX :: 65504.0

    F16_MAX_10_EXP ¶
    Source

    F16_MAX_10_EXP :: 4

    F16_MAX_EXP ¶
    Source

    F16_MAX_EXP :: 15

    F16_MIN ¶
    Source

    F16_MIN :: 6.10351562e-5

    F16_MIN_10_EXP ¶
    Source

    F16_MIN_10_EXP :: -4

    F16_MIN_EXP ¶
    Source

    F16_MIN_EXP :: -14

    F16_NORMALIZE ¶
    Source

    F16_NORMALIZE :: 0

    F16_RADIX ¶
    Source

    F16_RADIX :: 2

    F16_ROUNDS ¶
    Source

    F16_ROUNDS :: 1

    F16_SHIFT ¶
    Source

    F16_SHIFT :: 16 - 6

    F32_BIAS ¶
    Source

    F32_BIAS :: 0x7f

    F32_DIG ¶
    Source

    F32_DIG :: 6

    F32_EPSILON ¶
    Source

    F32_EPSILON :: 1.192092896e-07

    F32_GUARD ¶
    Source

    F32_GUARD :: 0

    F32_MANT_DIG ¶
    Source

    F32_MANT_DIG :: 24

    F32_MASK ¶
    Source

    F32_MASK :: 0xff

    F32_MAX ¶
    Source

    F32_MAX :: 3.402823466e+38

    F32_MAX_10_EXP ¶
    Source

    F32_MAX_10_EXP :: 38

    F32_MAX_EXP ¶
    Source

    F32_MAX_EXP :: 128

    F32_MIN ¶
    Source

    F32_MIN :: 1.175494351e-38

    F32_MIN_10_EXP ¶
    Source

    F32_MIN_10_EXP :: -37

    F32_MIN_EXP ¶
    Source

    F32_MIN_EXP :: -125

    F32_NORMALIZE ¶
    Source

    F32_NORMALIZE :: 0

    F32_RADIX ¶
    Source

    F32_RADIX :: 2

    F32_ROUNDS ¶
    Source

    F32_ROUNDS :: 1

    F32_SHIFT ¶
    Source

    F32_SHIFT :: 32 - 9

    F64_BIAS ¶
    Source

    F64_BIAS :: 0x3ff

    F64_DIG ¶
    Source

    F64_DIG :: 15
     

    Number of representable decimal digits.

    F64_EPSILON ¶
    Source

    F64_EPSILON :: 2.2204460492503131e-016
     

    Smallest number such that 1.0 + F64_EPSILON != 1.0.

    F64_MANT_DIG ¶
    Source

    F64_MANT_DIG :: 53
     

    Number of bits in the mantissa.

    F64_MASK ¶
    Source

    F64_MASK :: 0x7ff

    F64_MAX ¶
    Source

    F64_MAX :: 1.7976931348623158e+308
     

    Maximum representable value.

    F64_MAX_10_EXP ¶
    Source

    F64_MAX_10_EXP :: 308
     

    Maximum base-10 exponent yielding normalized value.

    F64_MAX_EXP ¶
    Source

    F64_MAX_EXP :: 1024
     

    One greater than the maximum possible base-2 exponent yielding normalized value.

    F64_MIN ¶
    Source

    F64_MIN :: 2.2250738585072014e-308
     

    Minimum positive normalized value.

    F64_MIN_10_EXP ¶
    Source

    F64_MIN_10_EXP :: -307
     

    Minimum base-10 exponent yielding normalized value.

    F64_MIN_EXP ¶
    Source

    F64_MIN_EXP :: -1021
     

    One greater than the minimum possible base-2 exponent yielding normalized value.

    F64_RADIX ¶
    Source

    F64_RADIX :: 2
     

    Exponent radix.

    F64_ROUNDS ¶
    Source

    F64_ROUNDS :: 1
     

    Addition rounding: near.

    F64_SHIFT ¶
    Source

    F64_SHIFT :: 64 - 12

    INF_F16 ¶
    Source

    INF_F16 :: f16(0h7C00)

    INF_F32 ¶
    Source

    INF_F32 :: f32(0h7F80_0000)

    INF_F64 ¶
    Source

    INF_F64 :: f64(0h7FF0_0000_0000_0000)

    LN10 ¶
    Source

    LN10 :: 2.30258509299404568401799145468436421

    LN2 ¶
    Source

    LN2 :: 0.693147180559945309417232121458176568

    MAX_F16_PRECISION ¶
    Source

    MAX_F16_PRECISION :: 4
     

    Maximum number of meaningful digits after the decimal point for 'f16'

    MAX_F32_PRECISION ¶
    Source

    MAX_F32_PRECISION :: 8
     

    Maximum number of meaningful digits after the decimal point for 'f32'

    MAX_F64_PRECISION ¶
    Source

    MAX_F64_PRECISION :: 16
     

    Maximum number of meaningful digits after the decimal point for 'f64'

    NEG_INF_F16 ¶
    Source

    NEG_INF_F16 :: f16(0hFC00)

    NEG_INF_F32 ¶
    Source

    NEG_INF_F32 :: f32(0hFF80_0000)

    NEG_INF_F64 ¶
    Source

    NEG_INF_F64 :: f64(0hFFF0_0000_0000_0000)

    PI ¶
    Source

    PI :: 3.14159265358979323846264338327950288

    QNAN_F16 ¶
    Source

    QNAN_F16 :: f16(0h7E01)

    QNAN_F32 ¶
    Source

    QNAN_F32 :: f32(0hFFC0_0001)

    QNAN_F64 ¶
    Source

    QNAN_F64 :: f64(0h7FF8_0000_0000_0001)

    RAD_PER_DEG ¶
    Source

    RAD_PER_DEG :: TAU / 360.0

    SNAN_F16 ¶
    Source

    SNAN_F16 :: f16(0h7C01)

    SNAN_F32 ¶
    Source

    SNAN_F32 :: f32(0hFF80_0001)

    SNAN_F64 ¶
    Source

    SNAN_F64 :: f64(0h7FF0_0000_0000_0001)

    SQRT_FIVE ¶
    Source

    SQRT_FIVE :: 2.23606797749978969640917366873127623

    SQRT_THREE ¶
    Source

    SQRT_THREE :: 1.73205080756887729352744634150587236

    SQRT_TWO ¶
    Source

    SQRT_TWO :: 1.41421356237309504880168872420969808

    TAU ¶
    Source

    TAU :: 6.28318530717958647692528676655900576

    e ¶
    Source

    e :: E

    π ¶
    Source

    π :: PI

    τ ¶
    Source

    τ :: TAU

    Variables

    This section is empty.

    Procedures

    abs ¶

    abs :: builtin.abs

    acos_f16 ¶
    Source

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

    acos_f16be ¶
    Source

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

    acos_f16le ¶
    Source

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

    acos_f32 ¶
    Source

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

    acos_f32be ¶
    Source

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

    acos_f32le ¶
    Source

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

    acos_f64 ¶
    Source

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

    acos_f64be ¶
    Source

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

    acos_f64le ¶
    Source

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

    acosh ¶
    Source

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

    angle_diff ¶
    Source

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

    angle_lerp ¶
    Source

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

    asin_f16 ¶
    Source

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

    asin_f16be ¶
    Source

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

    asin_f16le ¶
    Source

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

    asin_f32 ¶
    Source

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

    asin_f32be ¶
    Source

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

    asin_f32le ¶
    Source

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

    asin_f64 ¶
    Source

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

    asin_f64be ¶
    Source

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

    asin_f64le ¶
    Source

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

    asinh ¶
    Source

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

    atan ¶
    Source

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

    Return the arc tangent of x, in radians. Defined on the domain of [-∞, ∞] with a range of [-π/2, π/2]

    atan2_f16 ¶
    Source

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

    atan2_f16be ¶
    Source

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

    atan2_f16le ¶
    Source

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

    atan2_f32 ¶
    Source

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

    atan2_f32be ¶
    Source

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

    atan2_f32le ¶
    Source

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

    atan2_f64 ¶
    Source

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

    atan2_f64be ¶
    Source

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

    atan2_f64le ¶
    Source

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

    atanh ¶
    Source

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

    bias ¶
    Source

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

    binomial ¶
    Source

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

    ceil_f16 ¶
    Source

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

    ceil_f16be ¶
    Source

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

    ceil_f16le ¶
    Source

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

    ceil_f32 ¶
    Source

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

    ceil_f32be ¶
    Source

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

    ceil_f32le ¶
    Source

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

    ceil_f64 ¶
    Source

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

    ceil_f64be ¶
    Source

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

    ceil_f64le ¶
    Source

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

    clamp ¶

    clamp :: builtin.clamp

    classify_f16 ¶
    Source

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

    classify_f16be ¶
    Source

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

    classify_f16le ¶
    Source

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

    classify_f32 ¶
    Source

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

    classify_f32be ¶
    Source

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

    classify_f32le ¶
    Source

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

    classify_f64 ¶
    Source

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

    classify_f64be ¶
    Source

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

    classify_f64le ¶
    Source

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

    copy_sign_f16 ¶
    Source

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

    copy_sign_f16be ¶
    Source

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

    copy_sign_f16le ¶
    Source

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

    copy_sign_f32 ¶
    Source

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

    copy_sign_f32be ¶
    Source

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

    copy_sign_f32le ¶
    Source

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

    copy_sign_f64 ¶
    Source

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

    copy_sign_f64be ¶
    Source

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

    copy_sign_f64le ¶
    Source

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

    cos_f16 ¶
    Source

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

    cos_f16be ¶
    Source

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

    cos_f16le ¶
    Source

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

    cos_f32 ¶
    Source

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

    cos_f32be ¶
    Source

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

    cos_f32le ¶
    Source

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

    cos_f64 ¶
    Source

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

    cos_f64be ¶
    Source

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

    cos_f64le ¶
    Source

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

    cosh ¶
    Source

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

    count_digits_of_base ¶
    Source

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

    cumsum ¶
    Source

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

    cumsum_inplace ¶
    Source

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

    divmod ¶
    Source

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

    erf_f16 ¶
    Source

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

    erf_f16be ¶
    Source

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

    erf_f16le ¶
    Source

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

    erf_f32 ¶
    Source

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

    erf_f32be ¶
    Source

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

    erf_f32le ¶
    Source

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

    erf_f64 ¶
    Source

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

    erfc_f16 ¶
    Source

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

    erfc_f16be ¶
    Source

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

    erfc_f16le ¶
    Source

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

    erfc_f32 ¶
    Source

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

    erfc_f32be ¶
    Source

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

    erfc_f32le ¶
    Source

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

    erfc_f64 ¶
    Source

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

    exp_f16 ¶
    Source

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

    exp_f16be ¶
    Source

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

    exp_f16le ¶
    Source

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

    exp_f32 ¶
    Source

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

    exp_f32be ¶
    Source

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

    exp_f32le ¶
    Source

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

    exp_f64 ¶
    Source

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

    exp_f64be ¶
    Source

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

    exp_f64le ¶
    Source

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

    factorial ¶
    Source

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

    floor_div ¶
    Source

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

    floor_divmod ¶
    Source

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

    floor_f16 ¶
    Source

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

    floor_f16be ¶
    Source

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

    floor_f16le ¶
    Source

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

    floor_f32 ¶
    Source

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

    floor_f32be ¶
    Source

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

    floor_f32le ¶
    Source

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

    floor_f64 ¶
    Source

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

    floor_f64be ¶
    Source

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

    floor_f64le ¶
    Source

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

    floor_mod ¶
    Source

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

    fmuladd_f16 ¶
    Source

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

    fmuladd_f16be ¶
    Source

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

    fmuladd_f16le ¶
    Source

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

    fmuladd_f32 ¶
    Source

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

    fmuladd_f32be ¶
    Source

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

    fmuladd_f32le ¶
    Source

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

    fmuladd_f64 ¶
    Source

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

    fmuladd_f64be ¶
    Source

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

    fmuladd_f64le ¶
    Source

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

    frexp_f16 ¶
    Source

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

    frexp_f16be ¶
    Source

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

    frexp_f16le ¶
    Source

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

    frexp_f32 ¶
    Source

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

    frexp_f32be ¶
    Source

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

    frexp_f32le ¶
    Source

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

    frexp_f64 ¶
    Source

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

    frexp_f64be ¶
    Source

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

    frexp_f64le ¶
    Source

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

    gain ¶
    Source

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

    gamma_f16 ¶
    Source

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

    gamma_f16be ¶
    Source

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

    gamma_f16le ¶
    Source

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

    gamma_f32 ¶
    Source

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

    gamma_f32be ¶
    Source

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

    gamma_f32le ¶
    Source

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

    gamma_f64 ¶
    Source

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

    gamma_f64be ¶
    Source

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

    gamma_f64le ¶
    Source

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

    gcd ¶
    Source

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

    hypot_f16 ¶
    Source

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

    hypot_f16be ¶
    Source

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

    hypot_f16le ¶
    Source

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

    hypot_f32 ¶
    Source

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

    hypot_f32be ¶
    Source

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

    hypot_f32le ¶
    Source

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

    hypot_f64 ¶
    Source

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

    hypot_f64be ¶
    Source

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

    hypot_f64le ¶
    Source

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

    ilogb_f16 ¶
    Source

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

    ilogb_f16be ¶
    Source

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

    ilogb_f16le ¶
    Source

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

    ilogb_f32 ¶
    Source

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

    ilogb_f32be ¶
    Source

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

    ilogb_f32le ¶
    Source

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

    ilogb_f64 ¶
    Source

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

    ilogb_f64be ¶
    Source

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

    ilogb_f64le ¶
    Source

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

    inf_f16 ¶
    Source

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

    inf_f16be ¶
    Source

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

    inf_f16le ¶
    Source

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

    inf_f32 ¶
    Source

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

    inf_f32be ¶
    Source

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

    inf_f32le ¶
    Source

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

    inf_f64 ¶
    Source

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

    inf_f64be ¶
    Source

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

    inf_f64le ¶
    Source

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

    is_inf_f16 ¶
    Source

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

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

    is_inf_f16le ¶
    Source

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

    is_inf_f32 ¶
    Source

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

    is_inf_f32be ¶
    Source

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

    is_inf_f32le ¶
    Source

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

    is_inf_f64 ¶
    Source

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

    is_inf_f64be ¶
    Source

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

    is_inf_f64le ¶
    Source

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

    is_nan_f16 ¶
    Source

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

    is_nan_f16be ¶
    Source

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

    is_nan_f16le ¶
    Source

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

    is_nan_f32 ¶
    Source

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

    is_nan_f32be ¶
    Source

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

    is_nan_f32le ¶
    Source

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

    is_nan_f64 ¶
    Source

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

    is_nan_f64be ¶
    Source

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

    is_nan_f64le ¶
    Source

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

    is_power_of_two ¶
    Source

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

    lcm ¶
    Source

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

    ldexp_f16 ¶
    Source

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

    ldexp_f16be ¶
    Source

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

    ldexp_f16le ¶
    Source

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

    ldexp_f32 ¶
    Source

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

    ldexp_f32be ¶
    Source

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

    ldexp_f32le ¶
    Source

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

    ldexp_f64 ¶
    Source

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

    ldexp_f64be ¶
    Source

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

    ldexp_f64le ¶
    Source

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

    lerp ¶
    Source

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

    lgamma_f16 ¶
    Source

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

    lgamma_f16be ¶
    Source

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

    lgamma_f16le ¶
    Source

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

    lgamma_f32 ¶
    Source

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

    lgamma_f32be ¶
    Source

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

    lgamma_f32le ¶
    Source

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

    lgamma_f64 ¶
    Source

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

    lgamma_f64be ¶
    Source

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

    lgamma_f64le ¶
    Source

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

    ln_f16 ¶
    Source

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

    ln_f16be ¶
    Source

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

    ln_f16le ¶
    Source

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

    ln_f32 ¶
    Source

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

    ln_f32be ¶
    Source

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

    ln_f32le ¶
    Source

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

    ln_f64 ¶
    Source

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

    ln_f64be ¶
    Source

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

    ln_f64le ¶
    Source

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

    log10_f16 ¶
    Source

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

    log10_f16be ¶
    Source

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

    log10_f16le ¶
    Source

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

    log10_f32 ¶
    Source

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

    log10_f32be ¶
    Source

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

    log10_f32le ¶
    Source

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

    log10_f64 ¶
    Source

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

    log10_f64be ¶
    Source

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

    log10_f64le ¶
    Source

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

    log1p_f16 ¶
    Source

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

    log1p_f16be ¶
    Source

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

    log1p_f16le ¶
    Source

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

    log1p_f32 ¶
    Source

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

    log1p_f32be ¶
    Source

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

    log1p_f32le ¶
    Source

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

    log1p_f64 ¶
    Source

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

    log1p_f64be ¶
    Source

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

    log1p_f64le ¶
    Source

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

    log2_f16 ¶
    Source

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

    log2_f16be ¶
    Source

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

    log2_f16le ¶
    Source

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

    log2_f32 ¶
    Source

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

    log2_f32be ¶
    Source

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

    log2_f32le ¶
    Source

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

    log2_f64 ¶
    Source

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

    log2_f64be ¶
    Source

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

    log2_f64le ¶
    Source

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

    log_f16 ¶
    Source

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

    log_f16be ¶
    Source

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

    log_f16le ¶
    Source

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

    log_f32 ¶
    Source

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

    log_f32be ¶
    Source

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

    log_f32le ¶
    Source

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

    log_f64 ¶
    Source

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

    log_f64be ¶
    Source

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

    log_f64le ¶
    Source

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

    logb_f16 ¶
    Source

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

    logb_f16be ¶
    Source

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

    logb_f16le ¶
    Source

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

    logb_f32 ¶
    Source

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

    logb_f32be ¶
    Source

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

    logb_f32le ¶
    Source

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

    logb_f64 ¶
    Source

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

    logb_f64be ¶
    Source

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

    logb_f64le ¶
    Source

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

    max ¶

    max :: builtin.max

    min ¶

    min :: builtin.min

    mod_f16 ¶
    Source

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

    mod_f16be ¶
    Source

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

    mod_f16le ¶
    Source

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

    mod_f32 ¶
    Source

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

    mod_f32be ¶
    Source

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

    mod_f32le ¶
    Source

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

    mod_f64 ¶
    Source

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

    mod_f64be ¶
    Source

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

    mod_f64le ¶
    Source

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

    modf_f16 ¶
    Source

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

    modf_f16be ¶
    Source

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

    modf_f16le ¶
    Source

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

    modf_f32 ¶
    Source

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

    modf_f32be ¶
    Source

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

    modf_f32le ¶
    Source

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

    modf_f64 ¶
    Source

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

    modf_f64be ¶
    Source

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

    modf_f64le ¶
    Source

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

    nan_f16 ¶
    Source

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

    nan_f16be ¶
    Source

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

    nan_f16le ¶
    Source

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

    nan_f32 ¶
    Source

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

    nan_f32be ¶
    Source

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

    nan_f32le ¶
    Source

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

    nan_f64 ¶
    Source

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

    nan_f64be ¶
    Source

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

    nan_f64le ¶
    Source

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

    next_power_of_two ¶
    Source

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

    nextafter_f16 ¶
    Source

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

    nextafter_f16be ¶
    Source

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

    nextafter_f16le ¶
    Source

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

    nextafter_f32 ¶
    Source

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

    nextafter_f32be ¶
    Source

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

    nextafter_f32le ¶
    Source

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

    nextafter_f64 ¶
    Source

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

    nextafter_f64be ¶
    Source

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

    nextafter_f64le ¶
    Source

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

    normalize_f16 ¶
    Source

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

    normalize_f16be ¶
    Source

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

    normalize_f16le ¶
    Source

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

    normalize_f32 ¶
    Source

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

    normalize_f32be ¶
    Source

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

    normalize_f32le ¶
    Source

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

    normalize_f64 ¶
    Source

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

    normalize_f64be ¶
    Source

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

    normalize_f64le ¶
    Source

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

    pow10_f16 ¶
    Source

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

    pow10_f16be ¶
    Source

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

    pow10_f16le ¶
    Source

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

    pow10_f32 ¶
    Source

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

    pow10_f32be ¶
    Source

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

    pow10_f32le ¶
    Source

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

    pow10_f64 ¶
    Source

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

    pow10_f64be ¶
    Source

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

    pow10_f64le ¶
    Source

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

    pow2_f16 ¶
    Source

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

    pow2_f32 ¶
    Source

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

    pow2_f64 ¶
    Source

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

    pow_f16 ¶
    Source

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

    pow_f16be ¶
    Source

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

    pow_f16le ¶
    Source

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

    pow_f32 ¶
    Source

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

    pow_f32be ¶
    Source

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

    pow_f32le ¶
    Source

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

    pow_f64 ¶
    Source

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

    pow_f64be ¶
    Source

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

    pow_f64le ¶
    Source

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

    prod ¶
    Source

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

    remainder_f16 ¶
    Source

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

    remainder_f16be ¶
    Source

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

    remainder_f16le ¶
    Source

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

    remainder_f32 ¶
    Source

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

    remainder_f32be ¶
    Source

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

    remainder_f32le ¶
    Source

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

    remainder_f64 ¶
    Source

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

    remainder_f64be ¶
    Source

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

    remainder_f64le ¶
    Source

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

    remap ¶
    Source

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

    remap_clamped ¶
    Source

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

    round_f16 ¶
    Source

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

    round_f16be ¶
    Source

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

    round_f16le ¶
    Source

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

    round_f32 ¶
    Source

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

    round_f32be ¶
    Source

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

    round_f32le ¶
    Source

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

    round_f64 ¶
    Source

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

    round_f64be ¶
    Source

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

    round_f64le ¶
    Source

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

    saturate ¶
    Source

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

    sign_bit_f16 ¶
    Source

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

    sign_bit_f16be ¶
    Source

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

    sign_bit_f16le ¶
    Source

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

    sign_bit_f32 ¶
    Source

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

    sign_bit_f32be ¶
    Source

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

    sign_bit_f32le ¶
    Source

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

    sign_bit_f64 ¶
    Source

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

    sign_bit_f64be ¶
    Source

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

    sign_bit_f64le ¶
    Source

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

    sign_f16 ¶
    Source

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

    sign_f16be ¶
    Source

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

    sign_f16le ¶
    Source

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

    sign_f32 ¶
    Source

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

    sign_f32be ¶
    Source

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

    sign_f32le ¶
    Source

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

    sign_f64 ¶
    Source

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

    sign_f64be ¶
    Source

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

    sign_f64le ¶
    Source

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

    signbit_f16 ¶
    Source

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

    signbit_f16be ¶
    Source

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

    signbit_f16le ¶
    Source

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

    signbit_f32 ¶
    Source

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

    signbit_f32be ¶
    Source

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

    signbit_f32le ¶
    Source

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

    signbit_f64 ¶
    Source

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

    signbit_f64be ¶
    Source

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

    signbit_f64le ¶
    Source

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

    sin_f16 ¶
    Source

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

    sin_f16be ¶
    Source

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

    sin_f16le ¶
    Source

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

    sin_f32 ¶
    Source

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

    sin_f32be ¶
    Source

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

    sin_f32le ¶
    Source

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

    sin_f64 ¶
    Source

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

    sin_f64be ¶
    Source

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

    sin_f64le ¶
    Source

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

    sincos_f16 ¶
    Source

    sincos_f16 :: proc "contextless" (x: f16) -> (sin, cos: f16) {…}

    sincos_f16be ¶
    Source

    sincos_f16be :: proc "contextless" (x: f16be) -> (sin, cos: f16be) {…}

    sincos_f16le ¶
    Source

    sincos_f16le :: proc "contextless" (x: f16le) -> (sin, cos: f16le) {…}

    sincos_f32 ¶
    Source

    sincos_f32 :: proc "contextless" (x: f32) -> (sin, cos: f32) {…}

    sincos_f32be ¶
    Source

    sincos_f32be :: proc "contextless" (x: f32be) -> (sin, cos: f32be) {…}

    sincos_f32le ¶
    Source

    sincos_f32le :: proc "contextless" (x: f32le) -> (sin, cos: f32le) {…}

    sincos_f64 ¶
    Source

    sincos_f64 :: proc "contextless" (x: f64) -> (sin, cos: f64) {…}

    sincos_f64be ¶
    Source

    sincos_f64be :: proc "contextless" (x: f64be) -> (sin, cos: f64be) {…}

    sincos_f64le ¶
    Source

    sincos_f64le :: proc "contextless" (x: f64le) -> (sin, cos: f64le) {…}

    sinh ¶
    Source

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

    smoothstep ¶
    Source

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

    sqrt_f16 ¶
    Source

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

    sqrt_f16be ¶
    Source

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

    sqrt_f16le ¶
    Source

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

    sqrt_f32 ¶
    Source

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

    sqrt_f32be ¶
    Source

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

    sqrt_f32le ¶
    Source

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

    sqrt_f64 ¶
    Source

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

    sqrt_f64be ¶
    Source

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

    sqrt_f64le ¶
    Source

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

    step ¶
    Source

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

    sum ¶
    Source

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

    tan_f16 ¶
    Source

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

    tan_f16be ¶
    Source

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

    tan_f16le ¶
    Source

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

    tan_f32 ¶
    Source

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

    tan_f32be ¶
    Source

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

    tan_f32le ¶
    Source

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

    tan_f64 ¶
    Source

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

    tan_f64be ¶
    Source

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

    tan_f64le ¶
    Source

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

    tanh ¶
    Source

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

    to_degrees_f16 ¶
    Source

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

    to_degrees_f16be ¶
    Source

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

    to_degrees_f16le ¶
    Source

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

    to_degrees_f32 ¶
    Source

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

    to_degrees_f32be ¶
    Source

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

    to_degrees_f32le ¶
    Source

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

    to_degrees_f64 ¶
    Source

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

    to_degrees_f64be ¶
    Source

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

    to_degrees_f64le ¶
    Source

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

    to_radians_f16 ¶
    Source

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

    to_radians_f16be ¶
    Source

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

    to_radians_f16le ¶
    Source

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

    to_radians_f32 ¶
    Source

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

    to_radians_f32be ¶
    Source

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

    to_radians_f32le ¶
    Source

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

    to_radians_f64 ¶
    Source

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

    to_radians_f64be ¶
    Source

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

    to_radians_f64le ¶
    Source

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

    trunc_f16 ¶
    Source

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

    trunc_f16be ¶
    Source

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

    trunc_f16le ¶
    Source

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

    trunc_f32 ¶
    Source

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

    trunc_f32be ¶
    Source

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

    trunc_f32le ¶
    Source

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

    trunc_f64 ¶
    Source

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

    trunc_f64be ¶
    Source

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

    trunc_f64le ¶
    Source

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

    unlerp ¶
    Source

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

    wrap ¶
    Source

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

    Procedure Groups

    acos ¶
    Source

     

    Return the arc cosine of x, in radians. Defined on the domain of [-1, 1] with a range of [0, π].

    asin ¶
    Source

     

    Return the arc sine of x, in radians. Defined on the domain of [-1, 1] with a range of [-π/2, π/2]

    atan2 ¶
    Source

     

    Return the arc tangent of y/x in radians. Defined on the domain [-∞, ∞] for x and y with a range of [-π, π]

    Special cases:

    atan2(y, NaN)     = NaN
atan2(NaN, x)     = NaN
atan2(+0, x>=0)   = + 0
atan2(-0, x>=0)   = - 0
atan2(+0, x<=-0)  = + π
atan2(-0, x<=-0)  = - π
atan2(y>0, 0)     = + π/2
atan2(y<0, 0)     = - π/2
atan2(+∞, +∞)     = + π/4
atan2(-∞, +∞)     = - π/4
atan2(+∞, -∞)     =   3π/4
atan2(-∞, -∞)     = - 3π/4
atan2(y, +∞)      =   0
atan2(y>0, -∞)    = + π
atan2(y<0, -∞)    = - π
atan2(+∞, x)      = + π/2
atan2(-∞, x)      = - π/2

    ceil ¶
    Source

    classify ¶
    Source

     

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

    copy_sign ¶
    Source

    cos ¶
    Source

     

    Return the cosine of θ in radians.

    erf ¶
    Source

    erfc ¶
    Source

    exp ¶
    Source

    floor ¶
    Source

    fmuladd ¶
    Source

    frexp ¶
    Source

     

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

    hypot ¶
    Source

     

    hypot returns Sqrt(pp + qq), taking care to avoid unnecessary overflow and underflow.

    Special cases:

    hypot(±Inf, q) = +Inf
hypot(p, ±Inf) = +Inf
hypot(NaN, q) = NaN
hypot(p, NaN) = NaN

    ilogb ¶
    Source

    is_inf ¶
    Source

    is_nan ¶
    Source

    ldexp ¶
    Source

     

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

    ln ¶
    Source

    log ¶
    Source

    log10 ¶
    Source

    log1p ¶
    Source

    log2 ¶
    Source

    logb ¶
    Source

    mod ¶
    Source

    modf ¶
    Source

    nextafter ¶
    Source

    normalize ¶
    Source

    pow ¶
    Source

    pow10 ¶
    Source

    remainder ¶
    Source

    round ¶
    Source

    sign ¶
    Source

    sign_bit ¶
    Source

    signbit ¶
    Source

    sin ¶
    Source

     

    Return the sine of θ in radians.

    sincos ¶
    Source

    split_decimal ¶
    Source

    sqrt ¶
    Source

    tan ¶
    Source

     

    Return the tangent of θ in radians.

    to_degrees ¶
    Source

    to_radians ¶
    Source

    trunc ¶
    Source

     

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

    Source Files

    Generation Information

    Generated with odin version dev-2024-12 (vendor "odin") Windows_amd64 @ 2024-12-21 21:10:06.223711200 +0000 UTC