core/math package | Odin Programming Language

Typical trignometric and other basic math routines.

Collection Info

Collection: core
Path: math
Entries: 581

Constants 74

DEG_PER_RAD e 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 +58 more

Types 1

Jump to Types

Float_Class

Procedures 462

Jump to Procedures

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 +446 more

Procedure Groups 44

Jump to Procedure Groups

acos asin atan2 ceil classify copy_sign cos erf erfc exp floor fmuladd frexp gamma hypot ilogb +28 more

Variables 0

Source Files

Constants

DEG_PER_RAD #

Source

DEG_PER_RAD :: 360.0 / TAU

e #

Source

e :: E

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

π #

Source

π :: PI

τ #

Source

τ :: TAU

Types

Float_Class #

Source

Float_Class :: Float_Class

Procedures

462

abs #

Source

abs :: invalid type {…}

acos_f16 #

Source

@(require_results)

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

acos_f16be #

Source

@(require_results)

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

acos_f16le #

Source

@(require_results)

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

acos_f32 #

Source

@(require_results)

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

acos_f32be #

Source

@(require_results)

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

acos_f32le #

Source

@(require_results)

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

acos_f64 #

Source

@(require_results)

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

acos_f64be #

Source

@(require_results)

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

acos_f64le #

Source

@(require_results)

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

acosh #

Source

@(require_results)

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

angle_diff #

Source

@(require_results)

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

angle_lerp #

Source

@(require_results)

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

asin_f16 #

Source

@(require_results)

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

asin_f16be #

Source

@(require_results)

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

asin_f16le #

Source

@(require_results)

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

asin_f32 #

Source

@(require_results)

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

asin_f32be #

Source

@(require_results)

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

asin_f32le #

Source

@(require_results)

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

asin_f64 #

Source

@(require_results)

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

asin_f64be #

Source

@(require_results)

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

asin_f64le #

Source

@(require_results)

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

asinh #

Source

@(require_results)

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

atan #

Source

@(require_results)

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

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

atan2_f16 #

Source

@(require_results)

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

atan2_f16be #

Source

@(require_results)

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

atan2_f16le #

Source

@(require_results)

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

atan2_f32 #

Source

@(require_results)

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

atan2_f32be #

Source

@(require_results)

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

atan2_f32le #

Source

@(require_results)

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

atan2_f64 #

Source

@(require_results)

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

atan2_f64be #

Source

@(require_results)

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

atan2_f64le #

Source

@(require_results)

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

atanh #

Source

@(require_results)

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

bias #

Source

@(require_results)

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

binomial #

Source

@(require_results)

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

ceil_f16 #

Source

@(require_results)

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

ceil_f16be #

Source

@(require_results)

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

ceil_f16le #

Source

@(require_results)

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

ceil_f32 #

Source

@(require_results)

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

ceil_f32be #

Source

@(require_results)

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

ceil_f32le #

Source

@(require_results)

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

ceil_f64 #

Source

@(require_results)

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

ceil_f64be #

Source

@(require_results)

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

ceil_f64le #

Source

@(require_results)

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

clamp #

Source

clamp :: invalid type {…}

classify_f16 #

Source

@(require_results)

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

classify_f16be #

Source

@(require_results)

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

classify_f16le #

Source

@(require_results)

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

classify_f32 #

Source

@(require_results)

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

classify_f32be #

Source

@(require_results)

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

classify_f32le #

Source

@(require_results)

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

classify_f64 #

Source

@(require_results)

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

classify_f64be #

Source

@(require_results)

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

classify_f64le #

Source

@(require_results)

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

copy_sign_f16 #

Source

@(require_results)

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

copy_sign_f16be #

Source

@(require_results)

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

copy_sign_f16le #

Source

@(require_results)

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

copy_sign_f32 #

Source

@(require_results)

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

copy_sign_f32be #

Source

@(require_results)

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

copy_sign_f32le #

Source

@(require_results)

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

copy_sign_f64 #

Source

@(require_results)

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

copy_sign_f64be #

Source

@(require_results)

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

copy_sign_f64le #

Source

@(require_results)

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

cos_f16 #

Source

@(require_results)

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

cos_f16be #

Source

@(require_results)

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

cos_f16le #

Source

@(require_results)

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

cos_f32 #

Source

@(require_results)

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

cos_f32be #

Source

@(require_results)

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

cos_f32le #

Source

@(require_results)

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

cos_f64 #

Source

@(require_results)

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

cos_f64be #

Source

@(require_results)

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

cos_f64le #

Source

@(require_results)

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

cosh #

Source

@(require_results)

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

count_digits_of_base #

Source

@(require_results)

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

cumsum #

Source

@(require_results)

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

cumsum_inplace #

Source

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

divmod #

Source

@(require_results)

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

erf_f16 #

Source

@(require_results)

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

erf_f16be #

Source

@(require_results)

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

erf_f16le #

Source

@(require_results)

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

erf_f32 #

Source

@(require_results)

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

erf_f32be #

Source

@(require_results)

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

erf_f32le #

Source

@(require_results)

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

erf_f64 #

Source

@(require_results)

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

erfc_f16 #

Source

@(require_results)

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

erfc_f16be #

Source

@(require_results)

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

erfc_f16le #

Source

@(require_results)

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

erfc_f32 #

Source

@(require_results)

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

erfc_f32be #

Source

@(require_results)

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

erfc_f32le #

Source

@(require_results)

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

erfc_f64 #

Source

@(require_results)

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

exp_f16 #

Source

@(require_results)

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

exp_f16be #

Source

@(require_results)

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

exp_f16le #

Source

@(require_results)

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

exp_f32 #

Source

@(require_results)

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

exp_f32be #

Source

@(require_results)

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

exp_f32le #

Source

@(require_results)

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

exp_f64 #

Source

@(require_results)

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

exp_f64be #

Source

@(require_results)

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

exp_f64le #

Source

@(require_results)

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

factorial #

Source

@(require_results)

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

floor_div #

Source

@(require_results)

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

floor_divmod #

Source

@(require_results)

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

floor_f16 #

Source

@(require_results)

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

floor_f16be #

Source

@(require_results)

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

floor_f16le #

Source

@(require_results)

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

floor_f32 #

Source

@(require_results)

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

floor_f32be #

Source

@(require_results)

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

floor_f32le #

Source

@(require_results)

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

floor_f64 #

Source

@(require_results)

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

floor_f64be #

Source

@(require_results)

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

floor_f64le #

Source

@(require_results)

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

floor_mod #

Source

@(require_results)

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

fmuladd_f16 #

Source

@(require_results)

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

fmuladd_f16be #

Source

@(require_results)

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

fmuladd_f16le #

Source

@(require_results)

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

fmuladd_f32 #

Source

@(require_results)

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

fmuladd_f32be #

Source

@(require_results)

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

fmuladd_f32le #

Source

@(require_results)

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

fmuladd_f64 #

Source

@(require_results)

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

fmuladd_f64be #

Source

@(require_results)

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

fmuladd_f64le #

Source

@(require_results)

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

frexp_f16 #

Source

@(require_results)

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

frexp_f16be #

Source

@(require_results)

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

frexp_f16le #

Source

@(require_results)

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

frexp_f32 #

Source

@(require_results)

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

frexp_f32be #

Source

@(require_results)

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

frexp_f32le #

Source

@(require_results)

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

frexp_f64 #

Source

@(require_results)

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

frexp_f64be #

Source

@(require_results)

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

frexp_f64le #

Source

@(require_results)

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

gain #

Source

@(require_results)

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

gamma_f16 #

Source

@(require_results)

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

gamma_f16be #

Source

@(require_results)

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

gamma_f16le #

Source

@(require_results)

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

gamma_f32 #

Source

@(require_results)

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

gamma_f32be #

Source

@(require_results)

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

gamma_f32le #

Source

@(require_results)

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

gamma_f64 #

Source

@(require_results)

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

gamma_f64be #

Source

@(require_results)

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

gamma_f64le #

Source

@(require_results)

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

gcd #

Source

@(require_results)

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

hypot_f16 #

Source

@(require_results)

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

hypot_f16be #

Source

@(require_results)

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

hypot_f16le #

Source

@(require_results)

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

hypot_f32 #

Source

@(require_results)

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

hypot_f32be #

Source

@(require_results)

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

hypot_f32le #

Source

@(require_results)

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

hypot_f64 #

Source

@(require_results)

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

hypot_f64be #

Source

@(require_results)

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

hypot_f64le #

Source

@(require_results)

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

ilogb_f16 #

Source

@(require_results)

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

ilogb_f16be #

Source

@(require_results)

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

ilogb_f16le #

Source

@(require_results)

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

ilogb_f32 #

Source

@(require_results)

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

ilogb_f32be #

Source

@(require_results)

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

ilogb_f32le #

Source

@(require_results)

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

ilogb_f64 #

Source

@(require_results)

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

ilogb_f64be #

Source

@(require_results)

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

ilogb_f64le #

Source

@(require_results)

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

inf_f16 #

Source

@(require_results)

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

inf_f16be #

Source

@(require_results)

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

inf_f16le #

Source

@(require_results)

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

inf_f32 #

Source

@(require_results)

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

inf_f32be #

Source

@(require_results)

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

inf_f32le #

Source

@(require_results)

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

inf_f64 #

Source

@(require_results)

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

inf_f64be #

Source

@(require_results)

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

inf_f64le #

Source

@(require_results)

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

is_inf_f16 #

Source

@(require_results)

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

@(require_results)

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

is_inf_f16le #

Source

@(require_results)

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

is_inf_f32 #

Source

@(require_results)

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

is_inf_f32be #

Source

@(require_results)

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

is_inf_f32le #

Source

@(require_results)

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

is_inf_f64 #

Source

@(require_results)

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

is_inf_f64be #

Source

@(require_results)

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

is_inf_f64le #

Source

@(require_results)

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

is_nan_f16 #

Source

@(require_results)

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

is_nan_f16be #

Source

@(require_results)

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

is_nan_f16le #

Source

@(require_results)

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

is_nan_f32 #

Source

@(require_results)

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

is_nan_f32be #

Source

@(require_results)

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

is_nan_f32le #

Source

@(require_results)

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

is_nan_f64 #

Source

@(require_results)

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

is_nan_f64be #

Source

@(require_results)

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

is_nan_f64le #

Source

@(require_results)

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

is_power_of_two #

Source

@(require_results)

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

lcm #

Source

@(require_results)

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

ldexp_f16 #

Source

@(require_results)

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

ldexp_f16be #

Source

@(require_results)

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

ldexp_f16le #

Source

@(require_results)

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

ldexp_f32 #

Source

@(require_results)

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

ldexp_f32be #

Source

@(require_results)

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

ldexp_f32le #

Source

@(require_results)

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

ldexp_f64 #

Source

@(require_results)

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

ldexp_f64be #

Source

@(require_results)

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

ldexp_f64le #

Source

@(require_results)

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

lerp #

Source

@(require_results)

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

lgamma_f16 #

Source

@(require_results)

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

lgamma_f16be #

Source

@(require_results)

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

lgamma_f16le #

Source

@(require_results)

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

lgamma_f32 #

Source

@(require_results)

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

lgamma_f32be #

Source

@(require_results)

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

lgamma_f32le #

Source

@(require_results)

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

lgamma_f64 #

Source

@(require_results)

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

lgamma_f64be #

Source

@(require_results)

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

lgamma_f64le #

Source

@(require_results)

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

ln_f16 #

Source

@(require_results)

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

ln_f16be #

Source

@(require_results)

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

ln_f16le #

Source

@(require_results)

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

ln_f32 #

Source

@(require_results)

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

ln_f32be #

Source

@(require_results)

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

ln_f32le #

Source

@(require_results)

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

ln_f64 #

Source

@(require_results)

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

ln_f64be #

Source

@(require_results)

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

ln_f64le #

Source

@(require_results)

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

log_f16 #

Source

@(require_results)

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

log_f16be #

Source

@(require_results)

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

log_f16le #

Source

@(require_results)

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

log_f32 #

Source

@(require_results)

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

log_f32be #

Source

@(require_results)

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

log_f32le #

Source

@(require_results)

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

log_f64 #

Source

@(require_results)

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

log_f64be #

Source

@(require_results)

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

log_f64le #

Source

@(require_results)

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

log10_f16 #

Source

@(require_results)

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

log10_f16be #

Source

@(require_results)

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

log10_f16le #

Source

@(require_results)

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

log10_f32 #

Source

@(require_results)

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

log10_f32be #

Source

@(require_results)

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

log10_f32le #

Source

@(require_results)

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

log10_f64 #

Source

@(require_results)

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

log10_f64be #

Source

@(require_results)

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

log10_f64le #

Source

@(require_results)

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

log1p_f16 #

Source

@(require_results)

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

log1p_f16be #

Source

@(require_results)

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

log1p_f16le #

Source

@(require_results)

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

log1p_f32 #

Source

@(require_results)

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

log1p_f32be #

Source

@(require_results)

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

log1p_f32le #

Source

@(require_results)

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

log1p_f64 #

Source

@(require_results)

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

log1p_f64be #

Source

@(require_results)

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

log1p_f64le #

Source

@(require_results)

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

log2_f16 #

Source

@(require_results)

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

log2_f16be #

Source

@(require_results)

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

log2_f16le #

Source

@(require_results)

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

log2_f32 #

Source

@(require_results)

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

log2_f32be #

Source

@(require_results)

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

log2_f32le #

Source

@(require_results)

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

log2_f64 #

Source

@(require_results)

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

log2_f64be #

Source

@(require_results)

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

log2_f64le #

Source

@(require_results)

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

logb_f16 #

Source

@(require_results)

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

logb_f16be #

Source

@(require_results)

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

logb_f16le #

Source

@(require_results)

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

logb_f32 #

Source

@(require_results)

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

logb_f32be #

Source

@(require_results)

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

logb_f32le #

Source

@(require_results)

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

logb_f64 #

Source

@(require_results)

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

logb_f64be #

Source

@(require_results)

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

logb_f64le #

Source

@(require_results)

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

max #

Source

max :: invalid type {…}

min #

Source

min :: invalid type {…}

mod_f16 #

Source

@(require_results)

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

mod_f16be #

Source

@(require_results)

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

mod_f16le #

Source

@(require_results)

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

mod_f32 #

Source

@(require_results)

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

mod_f32be #

Source

@(require_results)

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

mod_f32le #

Source

@(require_results)

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

mod_f64 #

Source

@(require_results)

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

mod_f64be #

Source

@(require_results)

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

mod_f64le #

Source

@(require_results)

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

modf_f16 #

Source

@(require_results)

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

modf_f16be #

Source

@(require_results)

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

modf_f16le #

Source

@(require_results)

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

modf_f32 #

Source

@(require_results)

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

modf_f32be #

Source

@(require_results)

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

modf_f32le #

Source

@(require_results)

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

modf_f64 #

Source

@(require_results)

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

modf_f64be #

Source

@(require_results)

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

modf_f64le #

Source

@(require_results)

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

nan_f16 #

Source

@(require_results)

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

nan_f16be #

Source

@(require_results)

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

nan_f16le #

Source

@(require_results)

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

nan_f32 #

Source

@(require_results)

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

nan_f32be #

Source

@(require_results)

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

nan_f32le #

Source

@(require_results)

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

nan_f64 #

Source

@(require_results)

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

nan_f64be #

Source

@(require_results)

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

nan_f64le #

Source

@(require_results)

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

next_power_of_two #

Source

@(require_results)

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

nextafter_f16 #

Source

@(require_results)

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

nextafter_f16be #

Source

@(require_results)

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

nextafter_f16le #

Source

@(require_results)

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

nextafter_f32 #

Source

@(require_results)

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

nextafter_f32be #

Source

@(require_results)

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

nextafter_f32le #

Source

@(require_results)

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

nextafter_f64 #

Source

@(require_results)

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

nextafter_f64be #

Source

@(require_results)

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

nextafter_f64le #

Source

@(require_results)

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

normalize_f16 #

Source

@(require_results)

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

normalize_f16be #

Source

@(require_results)

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

normalize_f16le #

Source

@(require_results)

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

normalize_f32 #

Source

@(require_results)

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

normalize_f32be #

Source

@(require_results)

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

normalize_f32le #

Source

@(require_results)

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

normalize_f64 #

Source

@(require_results)

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

normalize_f64be #

Source

@(require_results)

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

normalize_f64le #

Source

@(require_results)

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

pow_f16 #

Source

@(require_results)

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

pow_f16be #

Source

@(require_results)

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

pow_f16le #

Source

@(require_results)

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

pow_f32 #

Source

@(require_results)

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

pow_f32be #

Source

@(require_results)

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

pow_f32le #

Source

@(require_results)

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

pow_f64 #

Source

@(require_results)

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

pow_f64be #

Source

@(require_results)

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

pow_f64le #

Source

@(require_results)

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

pow10_f16 #

Source

@(require_results)

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

pow10_f16be #

Source

@(require_results)

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

pow10_f16le #

Source

@(require_results)

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

pow10_f32 #

Source

@(require_results)

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

pow10_f32be #

Source

@(require_results)

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

pow10_f32le #

Source

@(require_results)

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

pow10_f64 #

Source

@(require_results)

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

pow10_f64be #

Source

@(require_results)

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

pow10_f64le #

Source

@(require_results)

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

pow2_f16 #

Source

@(require_results)

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

pow2_f32 #

Source

@(require_results)

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

pow2_f64 #

Source

@(require_results)

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

prod #

Source

@(require_results)

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

remainder_f16 #

Source

@(require_results)

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

remainder_f16be #

Source

@(require_results)

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

remainder_f16le #

Source

@(require_results)

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

remainder_f32 #

Source

@(require_results)

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

remainder_f32be #

Source

@(require_results)

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

remainder_f32le #

Source

@(require_results)

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

remainder_f64 #

Source

@(require_results)

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

remainder_f64be #

Source

@(require_results)

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

remainder_f64le #

Source

@(require_results)

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

remap #

Source

@(require_results)

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

remap_clamped #

Source

@(require_results)

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

round_f16 #

Source

@(require_results)

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

round_f16be #

Source

@(require_results)

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

round_f16le #

Source

@(require_results)

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

round_f32 #

Source

@(require_results)

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

round_f32be #

Source

@(require_results)

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

round_f32le #

Source

@(require_results)

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

round_f64 #

Source

@(require_results)

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

round_f64be #

Source

@(require_results)

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

round_f64le #

Source

@(require_results)

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

saturate #

Source

@(require_results)

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

sign_bit_f16 #

Source

@(require_results)

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

sign_bit_f16be #

Source

@(require_results)

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

sign_bit_f16le #

Source

@(require_results)

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

sign_bit_f32 #

Source

@(require_results)

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

sign_bit_f32be #

Source

@(require_results)

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

sign_bit_f32le #

Source

@(require_results)

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

sign_bit_f64 #

Source

@(require_results)

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

sign_bit_f64be #

Source

@(require_results)

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

sign_bit_f64le #

Source

@(require_results)

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

sign_bit_i16 #

Source

@(require_results)

sign_bit_i16 :: proc "contextless" (x: i16) -> bool {…}

sign_bit_i16be #

Source

@(require_results)

sign_bit_i16be :: proc "contextless" (x: i16be) -> bool {…}

sign_bit_i16le #

Source

@(require_results)

sign_bit_i16le :: proc "contextless" (x: i16le) -> bool {…}

sign_bit_i32 #

Source

@(require_results)

sign_bit_i32 :: proc "contextless" (x: i32) -> bool {…}

sign_bit_i32be #

Source

@(require_results)

sign_bit_i32be :: proc "contextless" (x: i32be) -> bool {…}

sign_bit_i32le #

Source

@(require_results)

sign_bit_i32le :: proc "contextless" (x: i32le) -> bool {…}

sign_bit_i64 #

Source

@(require_results)

sign_bit_i64 :: proc "contextless" (x: i64) -> bool {…}

sign_bit_i64be #

Source

@(require_results)

sign_bit_i64be :: proc "contextless" (x: i64be) -> bool {…}

sign_bit_i64le #

Source

@(require_results)

sign_bit_i64le :: proc "contextless" (x: i64le) -> bool {…}

sign_bit_int #

Source

@(require_results)

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

sign_f16 #

Source

@(require_results)

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

sign_f16be #

Source

@(require_results)

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

sign_f16le #

Source

@(require_results)

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

sign_f32 #

Source

@(require_results)

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

sign_f32be #

Source

@(require_results)

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

sign_f32le #

Source

@(require_results)

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

sign_f64 #

Source

@(require_results)

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

sign_f64be #

Source

@(require_results)

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

sign_f64le #

Source

@(require_results)

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

sign_i16 #

Source

@(require_results)

sign_i16 :: proc "contextless" (x: i16) -> i16 {…}

sign_i16be #

Source

@(require_results)

sign_i16be :: proc "contextless" (x: i16be) -> i16be {…}

sign_i16le #

Source

@(require_results)

sign_i16le :: proc "contextless" (x: i16le) -> i16le {…}

sign_i32 #

Source

@(require_results)

sign_i32 :: proc "contextless" (x: i32) -> i32 {…}

sign_i32be #

Source

@(require_results)

sign_i32be :: proc "contextless" (x: i32be) -> i32be {…}

sign_i32le #

Source

@(require_results)

sign_i32le :: proc "contextless" (x: i32le) -> i32le {…}

sign_i64 #

Source

@(require_results)

sign_i64 :: proc "contextless" (x: i64) -> i64 {…}

sign_i64be #

Source

@(require_results)

sign_i64be :: proc "contextless" (x: i64be) -> i64be {…}

sign_i64le #

Source

@(require_results)

sign_i64le :: proc "contextless" (x: i64le) -> i64le {…}

sign_int #

Source

@(require_results)

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

sin_f16 #

Source

@(require_results)

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

sin_f16be #

Source

@(require_results)

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

sin_f16le #

Source

@(require_results)

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

sin_f32 #

Source

@(require_results)

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

sin_f32be #

Source

@(require_results)

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

sin_f32le #

Source

@(require_results)

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

sin_f64 #

Source

@(require_results)

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

sin_f64be #

Source

@(require_results)

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

sin_f64le #

Source

@(require_results)

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

@(require_results)

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

smoothstep #

Source

@(require_results)

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

sqrt_f16 #

Source

@(require_results)

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

sqrt_f16be #

Source

@(require_results)

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

sqrt_f16le #

Source

@(require_results)

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

sqrt_f32 #

Source

@(require_results)

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

sqrt_f32be #

Source

@(require_results)

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

sqrt_f32le #

Source

@(require_results)

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

sqrt_f64 #

Source

@(require_results)

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

sqrt_f64be #

Source

@(require_results)

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

sqrt_f64le #

Source

@(require_results)

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

step #

Source

@(require_results)

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

sum #

Source

@(require_results)

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

tan_f16 #

Source

@(require_results)

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

tan_f16be #

Source

@(require_results)

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

tan_f16le #

Source

@(require_results)

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

tan_f32 #

Source

@(require_results)

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

tan_f32be #

Source

@(require_results)

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

tan_f32le #

Source

@(require_results)

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

tan_f64 #

Source

@(require_results)

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

tan_f64be #

Source

@(require_results)

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

tan_f64le #

Source

@(require_results)

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

tanh #

Source

@(require_results)

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

to_degrees_f16 #

Source

@(require_results)

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

to_degrees_f16be #

Source

@(require_results)

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

to_degrees_f16le #

Source

@(require_results)

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

to_degrees_f32 #

Source

@(require_results)

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

to_degrees_f32be #

Source

@(require_results)

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

to_degrees_f32le #

Source

@(require_results)

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

to_degrees_f64 #

Source

@(require_results)

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

to_degrees_f64be #

Source

@(require_results)

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

to_degrees_f64le #

Source

@(require_results)

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

to_radians_f16 #

Source

@(require_results)

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

to_radians_f16be #

Source

@(require_results)

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

to_radians_f16le #

Source

@(require_results)

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

to_radians_f32 #

Source

@(require_results)

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

to_radians_f32be #

Source

@(require_results)

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

to_radians_f32le #

Source

@(require_results)

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

to_radians_f64 #

Source

@(require_results)

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

to_radians_f64be #

Source

@(require_results)

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

to_radians_f64le #

Source

@(require_results)

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

trunc_f16 #

Source

@(require_results)

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

trunc_f16be #

Source

@(require_results)

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

trunc_f16le #

Source

@(require_results)

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

trunc_f32 #

Source

@(require_results)

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

trunc_f32be #

Source

@(require_results)

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

trunc_f32le #

Source

@(require_results)

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

trunc_f64 #

Source

@(require_results)

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

trunc_f64be #

Source

@(require_results)

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

trunc_f64le #

Source

@(require_results)

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

unlerp #

Source

@(require_results)

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

wrap #

Source

@(require_results)

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

Procedure Groups

acos #

Source

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

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

asin #

Source

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

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

atan2 #

Source

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

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

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

classify #

Source

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 #

Source

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

cos #

Source

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

Return the cosine of θ in radians.

erf #

Source

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

erfc #

Source

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

exp #

Source

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

floor #

Source

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

fmuladd #

Source

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

frexp #

Source

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 #

Source

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

hypot #

Source

hypot :: proc{
	hypot_f16,
	hypot_f16le,
	hypot_f16be,
	hypot_f32,
	hypot_f32le,
	hypot_f32be,
	hypot_f64,
	hypot_f64le,
	hypot_f64be,
}

hypot returns Sqrt(p*p + q*q), 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

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

is_inf #

Source

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 #

Source

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 #

Source

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 #

Source

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

ln #

Source

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

log #

Source

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

log10 #

Source

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

log1p #

Source

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

log2 #

Source

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

logb #

Source

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

mod #

Source

mod :: proc{
	mod_f16,
	mod_f16le,
	mod_f16be,
	mod_f32,
	mod_f32le,
	mod_f32be,
	mod_f64,
	mod_f64le,
	mod_f64be,
}

modf #

Source

modf :: proc{
	modf_f16,
	modf_f16le,
	modf_f16be,
	modf_f32,
	modf_f32le,
	modf_f32be,
	modf_f64,
	modf_f64le,
	modf_f64be,
}

nextafter #

Source

nextafter :: proc{
	nextafter_f16,
	nextafter_f16le,
	nextafter_f16be,
	nextafter_f32,
	nextafter_f32le,
	nextafter_f32be,
	nextafter_f64,
	nextafter_f64le,
	nextafter_f64be,
}

normalize #

Source

normalize :: proc{
	normalize_f16,
	normalize_f32,
	normalize_f64,
	normalize_f16le,
	normalize_f16be,
	normalize_f32le,
	normalize_f32be,
	normalize_f64le,
	normalize_f64be,
}

pow #

Source

pow :: proc{
	pow_f16,
	pow_f16le,
	pow_f16be,
	pow_f32,
	pow_f32le,
	pow_f32be,
	pow_f64,
	pow_f64le,
	pow_f64be,
}

pow10 #

Source

pow10 :: proc{
	pow10_f16,
	pow10_f16le,
	pow10_f16be,
	pow10_f32,
	pow10_f32le,
	pow10_f32be,
	pow10_f64,
	pow10_f64le,
	pow10_f64be,
}

remainder #

Source

remainder :: proc{
	remainder_f16,
	remainder_f16le,
	remainder_f16be,
	remainder_f32,
	remainder_f32le,
	remainder_f32be,
	remainder_f64,
	remainder_f64le,
	remainder_f64be,
}

round #

Source

round :: proc{
	round_f16,
	round_f16le,
	round_f16be,
	round_f32,
	round_f32le,
	round_f32be,
	round_f64,
	round_f64le,
	round_f64be,
}

sign #

Source

sign :: proc{
	sign_f16,
	sign_f16le,
	sign_f16be,
	sign_f32,
	sign_f32le,
	sign_f32be,
	sign_f64,
	sign_f64le,
	sign_f64be,
	sign_int,
	sign_i16,
	sign_i16le,
	sign_i16be,
	sign_i32,
	sign_i32le,
	sign_i32be,
	sign_i64,
	sign_i64le,
	sign_i64be,
}

sign_bit #

Source

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,
	sign_bit_int,
	sign_bit_i16,
	sign_bit_i16le,
	sign_bit_i16be,
	sign_bit_i32,
	sign_bit_i32le,
	sign_bit_i32be,
	sign_bit_i64,
	sign_bit_i64le,
	sign_bit_i64be,
}

sin #

Source

sin :: proc{
	sin_f16,
	sin_f16le,
	sin_f16be,
	sin_f32,
	sin_f32le,
	sin_f32be,
	sin_f64,
	sin_f64le,
	sin_f64be,
}

Return the sine of θ in radians.

sincos #

Source

sincos :: proc{
	sincos_f16,
	sincos_f16le,
	sincos_f16be,
	sincos_f32,
	sincos_f32le,
	sincos_f32be,
	sincos_f64,
	sincos_f64le,
	sincos_f64be,
}

split_decimal #

Source

split_decimal :: proc{
	modf_f16,
	modf_f16le,
	modf_f16be,
	modf_f32,
	modf_f32le,
	modf_f32be,
	modf_f64,
	modf_f64le,
	modf_f64be,
}

sqrt #

Source

sqrt :: proc{
	sqrt_f16,
	sqrt_f16le,
	sqrt_f16be,
	sqrt_f32,
	sqrt_f32le,
	sqrt_f32be,
	sqrt_f64,
	sqrt_f64le,
	sqrt_f64be,
}

tan #

Source

tan :: proc{
	tan_f16,
	tan_f16le,
	tan_f16be,
	tan_f32,
	tan_f32le,
	tan_f32be,
	tan_f64,
	tan_f64le,
	tan_f64be,
}

Return the tangent of θ in radians.

to_degrees #

Source

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 #

Source

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 #

Source

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.