Intrinsics

The 969 primitive operations the builtin number types and Boolean are built on. The operators on those types, and their Numeric, Comparable and Equatable implementations (see Builtin Types), are defined in terms of them - use an intrinsic directly when you need exactly one operation on exactly one type, with no dispatch in between.

They're reached only through #builtin.intrinsic (see Macro Namespaces), never by a bare name, so they can't clash with your own functions.

Naming

  • OPERATION_<Type>_<Type> for two operands - ADD_U64_U64
  • OPERATION_<Type> for one - NEG_S32, SQRT_F64
  • CAST_<From>_<To> for a conversion - CAST_F64_S32

Both operands always have the same type - mixing types goes through a CAST first. Boolean and Codepoint are spelled BOOLEAN and CODEPOINT in a name. An integer result that doesn't fit is an OverflowError unless the name says otherwise (WRAPPING wraps around, SATURATING clamps; CHECKED is the same as none), and shifts past the width shift every bit out. Floats follow IEEE-754: results round to nearest, ties to even, NaN and infinities are values rather than errors, and comparisons are exact. A float cast to an integer rounds toward zero.

Arithmetic

ADD

#add
Arithmetic19 functions

a + b

  • ADD_U8_U8(a: U8, b: U8): U8
  • ADD_U16_U16(a: U16, b: U16): U16
  • ADD_U32_U32(a: U32, b: U32): U32
  • ADD_U64_U64(a: U64, b: U64): U64
  • ADD_U128_U128(a: U128, b: U128): U128
  • ADD_U256_U256(a: U256, b: U256): U256
  • ADD_S8_S8(a: S8, b: S8): S8
  • ADD_S16_S16(a: S16, b: S16): S16
  • ADD_S32_S32(a: S32, b: S32): S32
  • ADD_S64_S64(a: S64, b: S64): S64
  • ADD_S128_S128(a: S128, b: S128): S128
  • ADD_S256_S256(a: S256, b: S256): S256
  • ADD_F16_F16(a: F16, b: F16): F16
  • ADD_F32_F32(a: F32, b: F32): F32
  • ADD_F64_F64(a: F64, b: F64): F64
  • ADD_C32_C32(a: C32, b: C32): C32
  • ADD_C64_C64(a: C64, b: C64): C64
  • ADD_Q32_Q32(a: Q32, b: Q32): Q32
  • ADD_Q64_Q64(a: Q64, b: Q64): Q64

SUB

#sub
Arithmetic19 functions

a - b

  • SUB_U8_U8(a: U8, b: U8): U8
  • SUB_U16_U16(a: U16, b: U16): U16
  • SUB_U32_U32(a: U32, b: U32): U32
  • SUB_U64_U64(a: U64, b: U64): U64
  • SUB_U128_U128(a: U128, b: U128): U128
  • SUB_U256_U256(a: U256, b: U256): U256
  • SUB_S8_S8(a: S8, b: S8): S8
  • SUB_S16_S16(a: S16, b: S16): S16
  • SUB_S32_S32(a: S32, b: S32): S32
  • SUB_S64_S64(a: S64, b: S64): S64
  • SUB_S128_S128(a: S128, b: S128): S128
  • SUB_S256_S256(a: S256, b: S256): S256
  • SUB_F16_F16(a: F16, b: F16): F16
  • SUB_F32_F32(a: F32, b: F32): F32
  • SUB_F64_F64(a: F64, b: F64): F64
  • SUB_C32_C32(a: C32, b: C32): C32
  • SUB_C64_C64(a: C64, b: C64): C64
  • SUB_Q32_Q32(a: Q32, b: Q32): Q32
  • SUB_Q64_Q64(a: Q64, b: Q64): Q64

MUL

#mul
Arithmetic19 functions

a * b (quaternions: not commutative)

  • MUL_U8_U8(a: U8, b: U8): U8
  • MUL_U16_U16(a: U16, b: U16): U16
  • MUL_U32_U32(a: U32, b: U32): U32
  • MUL_U64_U64(a: U64, b: U64): U64
  • MUL_U128_U128(a: U128, b: U128): U128
  • MUL_U256_U256(a: U256, b: U256): U256
  • MUL_S8_S8(a: S8, b: S8): S8
  • MUL_S16_S16(a: S16, b: S16): S16
  • MUL_S32_S32(a: S32, b: S32): S32
  • MUL_S64_S64(a: S64, b: S64): S64
  • MUL_S128_S128(a: S128, b: S128): S128
  • MUL_S256_S256(a: S256, b: S256): S256
  • MUL_F16_F16(a: F16, b: F16): F16
  • MUL_F32_F32(a: F32, b: F32): F32
  • MUL_F64_F64(a: F64, b: F64): F64
  • MUL_C32_C32(a: C32, b: C32): C32
  • MUL_C64_C64(a: C64, b: C64): C64
  • MUL_Q32_Q32(a: Q32, b: Q32): Q32
  • MUL_Q64_Q64(a: Q64, b: Q64): Q64

DIV

#div
Arithmetic19 functions

a / b (integers: truncates toward zero)

  • DIV_U8_U8(a: U8, b: U8): DivisionByZeroError ! U8
  • DIV_U16_U16(a: U16, b: U16): DivisionByZeroError ! U16
  • DIV_U32_U32(a: U32, b: U32): DivisionByZeroError ! U32
  • DIV_U64_U64(a: U64, b: U64): DivisionByZeroError ! U64
  • DIV_U128_U128(a: U128, b: U128): DivisionByZeroError ! U128
  • DIV_U256_U256(a: U256, b: U256): DivisionByZeroError ! U256
  • DIV_S8_S8(a: S8, b: S8): DivisionByZeroError ! S8
  • DIV_S16_S16(a: S16, b: S16): DivisionByZeroError ! S16
  • DIV_S32_S32(a: S32, b: S32): DivisionByZeroError ! S32
  • DIV_S64_S64(a: S64, b: S64): DivisionByZeroError ! S64
  • DIV_S128_S128(a: S128, b: S128): DivisionByZeroError ! S128
  • DIV_S256_S256(a: S256, b: S256): DivisionByZeroError ! S256
  • DIV_F16_F16(a: F16, b: F16): F16
  • DIV_F32_F32(a: F32, b: F32): F32
  • DIV_F64_F64(a: F64, b: F64): F64
  • DIV_C32_C32(a: C32, b: C32): C32
  • DIV_C64_C64(a: C64, b: C64): C64
  • DIV_Q32_Q32(a: Q32, b: Q32): Q32
  • DIV_Q64_Q64(a: Q64, b: Q64): Q64

FLOORDIV

#floordiv
Arithmetic15 functions

a // b - rounds toward negative infinity

  • FLOORDIV_U8_U8(a: U8, b: U8): DivisionByZeroError ! U8
  • FLOORDIV_U16_U16(a: U16, b: U16): DivisionByZeroError ! U16
  • FLOORDIV_U32_U32(a: U32, b: U32): DivisionByZeroError ! U32
  • FLOORDIV_U64_U64(a: U64, b: U64): DivisionByZeroError ! U64
  • FLOORDIV_U128_U128(a: U128, b: U128): DivisionByZeroError ! U128
  • FLOORDIV_U256_U256(a: U256, b: U256): DivisionByZeroError ! U256
  • FLOORDIV_S8_S8(a: S8, b: S8): DivisionByZeroError ! S8
  • FLOORDIV_S16_S16(a: S16, b: S16): DivisionByZeroError ! S16
  • FLOORDIV_S32_S32(a: S32, b: S32): DivisionByZeroError ! S32
  • FLOORDIV_S64_S64(a: S64, b: S64): DivisionByZeroError ! S64
  • FLOORDIV_S128_S128(a: S128, b: S128): DivisionByZeroError ! S128
  • FLOORDIV_S256_S256(a: S256, b: S256): DivisionByZeroError ! S256
  • FLOORDIV_F16_F16(a: F16, b: F16): F16
  • FLOORDIV_F32_F32(a: F32, b: F32): F32
  • FLOORDIV_F64_F64(a: F64, b: F64): F64

REM

#rem
Arithmetic15 functions

a % b - takes the sign of a

  • REM_U8_U8(a: U8, b: U8): DivisionByZeroError ! U8
  • REM_U16_U16(a: U16, b: U16): DivisionByZeroError ! U16
  • REM_U32_U32(a: U32, b: U32): DivisionByZeroError ! U32
  • REM_U64_U64(a: U64, b: U64): DivisionByZeroError ! U64
  • REM_U128_U128(a: U128, b: U128): DivisionByZeroError ! U128
  • REM_U256_U256(a: U256, b: U256): DivisionByZeroError ! U256
  • REM_S8_S8(a: S8, b: S8): DivisionByZeroError ! S8
  • REM_S16_S16(a: S16, b: S16): DivisionByZeroError ! S16
  • REM_S32_S32(a: S32, b: S32): DivisionByZeroError ! S32
  • REM_S64_S64(a: S64, b: S64): DivisionByZeroError ! S64
  • REM_S128_S128(a: S128, b: S128): DivisionByZeroError ! S128
  • REM_S256_S256(a: S256, b: S256): DivisionByZeroError ! S256
  • REM_F16_F16(a: F16, b: F16): F16
  • REM_F32_F32(a: F32, b: F32): F32
  • REM_F64_F64(a: F64, b: F64): F64

MOD

#mod
Arithmetic15 functions

remainder that takes the sign of b (Integer.modulo)

  • MOD_U8_U8(a: U8, b: U8): DivisionByZeroError ! U8
  • MOD_U16_U16(a: U16, b: U16): DivisionByZeroError ! U16
  • MOD_U32_U32(a: U32, b: U32): DivisionByZeroError ! U32
  • MOD_U64_U64(a: U64, b: U64): DivisionByZeroError ! U64
  • MOD_U128_U128(a: U128, b: U128): DivisionByZeroError ! U128
  • MOD_U256_U256(a: U256, b: U256): DivisionByZeroError ! U256
  • MOD_S8_S8(a: S8, b: S8): DivisionByZeroError ! S8
  • MOD_S16_S16(a: S16, b: S16): DivisionByZeroError ! S16
  • MOD_S32_S32(a: S32, b: S32): DivisionByZeroError ! S32
  • MOD_S64_S64(a: S64, b: S64): DivisionByZeroError ! S64
  • MOD_S128_S128(a: S128, b: S128): DivisionByZeroError ! S128
  • MOD_S256_S256(a: S256, b: S256): DivisionByZeroError ! S256
  • MOD_F16_F16(a: F16, b: F16): F16
  • MOD_F32_F32(a: F32, b: F32): F32
  • MOD_F64_F64(a: F64, b: F64): F64

POW

#pow
Arithmetic19 functions

a ^ b (S*: a negative b is an OverflowError, the result isn't a whole number)

  • POW_U8_U8(a: U8, b: U8): U8
  • POW_U16_U16(a: U16, b: U16): U16
  • POW_U32_U32(a: U32, b: U32): U32
  • POW_U64_U64(a: U64, b: U64): U64
  • POW_U128_U128(a: U128, b: U128): U128
  • POW_U256_U256(a: U256, b: U256): U256
  • POW_S8_S8(a: S8, b: S8): OverflowError ! S8
  • POW_S16_S16(a: S16, b: S16): OverflowError ! S16
  • POW_S32_S32(a: S32, b: S32): OverflowError ! S32
  • POW_S64_S64(a: S64, b: S64): OverflowError ! S64
  • POW_S128_S128(a: S128, b: S128): OverflowError ! S128
  • POW_S256_S256(a: S256, b: S256): OverflowError ! S256
  • POW_F16_F16(a: F16, b: F16): F16
  • POW_F32_F32(a: F32, b: F32): F32
  • POW_F64_F64(a: F64, b: F64): F64
  • POW_C32_C32(a: C32, b: C32): C32
  • POW_C64_C64(a: C64, b: C64): C64
  • POW_Q32_Q32(a: Q32, b: Q32): Q32
  • POW_Q64_Q64(a: Q64, b: Q64): Q64

NEG

#neg
Arithmetic19 functions

prefix -a (unsigned: an OverflowError for anything but 0)

  • NEG_U8(value: U8): U8
  • NEG_U16(value: U16): U16
  • NEG_U32(value: U32): U32
  • NEG_U64(value: U64): U64
  • NEG_U128(value: U128): U128
  • NEG_U256(value: U256): U256
  • NEG_S8(value: S8): S8
  • NEG_S16(value: S16): S16
  • NEG_S32(value: S32): S32
  • NEG_S64(value: S64): S64
  • NEG_S128(value: S128): S128
  • NEG_S256(value: S256): S256
  • NEG_F16(value: F16): F16
  • NEG_F32(value: F32): F32
  • NEG_F64(value: F64): F64
  • NEG_C32(value: C32): C32
  • NEG_C64(value: C64): C64
  • NEG_Q32(value: Q32): Q32
  • NEG_Q64(value: Q64): Q64

ABS

#abs
Arithmetic15 functions

absolute value (S*.min() is an OverflowError)

  • ABS_U8(value: U8): U8
  • ABS_U16(value: U16): U16
  • ABS_U32(value: U32): U32
  • ABS_U64(value: U64): U64
  • ABS_U128(value: U128): U128
  • ABS_U256(value: U256): U256
  • ABS_S8(value: S8): S8
  • ABS_S16(value: S16): S16
  • ABS_S32(value: S32): S32
  • ABS_S64(value: S64): S64
  • ABS_S128(value: S128): S128
  • ABS_S256(value: S256): S256
  • ABS_F16(value: F16): F16
  • ABS_F32(value: F32): F32
  • ABS_F64(value: F64): F64

MIN

#min
Arithmetic15 functions

the smaller of a and b (floats: NaN if either is NaN)

  • MIN_U8_U8(a: U8, b: U8): U8
  • MIN_U16_U16(a: U16, b: U16): U16
  • MIN_U32_U32(a: U32, b: U32): U32
  • MIN_U64_U64(a: U64, b: U64): U64
  • MIN_U128_U128(a: U128, b: U128): U128
  • MIN_U256_U256(a: U256, b: U256): U256
  • MIN_S8_S8(a: S8, b: S8): S8
  • MIN_S16_S16(a: S16, b: S16): S16
  • MIN_S32_S32(a: S32, b: S32): S32
  • MIN_S64_S64(a: S64, b: S64): S64
  • MIN_S128_S128(a: S128, b: S128): S128
  • MIN_S256_S256(a: S256, b: S256): S256
  • MIN_F16_F16(a: F16, b: F16): F16
  • MIN_F32_F32(a: F32, b: F32): F32
  • MIN_F64_F64(a: F64, b: F64): F64

MAX

#max
Arithmetic15 functions

the larger of a and b (floats: NaN if either is NaN)

  • MAX_U8_U8(a: U8, b: U8): U8
  • MAX_U16_U16(a: U16, b: U16): U16
  • MAX_U32_U32(a: U32, b: U32): U32
  • MAX_U64_U64(a: U64, b: U64): U64
  • MAX_U128_U128(a: U128, b: U128): U128
  • MAX_U256_U256(a: U256, b: U256): U256
  • MAX_S8_S8(a: S8, b: S8): S8
  • MAX_S16_S16(a: S16, b: S16): S16
  • MAX_S32_S32(a: S32, b: S32): S32
  • MAX_S64_S64(a: S64, b: S64): S64
  • MAX_S128_S128(a: S128, b: S128): S128
  • MAX_S256_S256(a: S256, b: S256): S256
  • MAX_F16_F16(a: F16, b: F16): F16
  • MAX_F32_F32(a: F32, b: F32): F32
  • MAX_F64_F64(a: F64, b: F64): F64

ADD_CHECKED

#add-checked
Arithmetic12 functions

a + b, an OverflowError when it doesn't fit - the same as ADD

  • ADD_CHECKED_U8_U8(a: U8, b: U8): OverflowError ! U8
  • ADD_CHECKED_U16_U16(a: U16, b: U16): OverflowError ! U16
  • ADD_CHECKED_U32_U32(a: U32, b: U32): OverflowError ! U32
  • ADD_CHECKED_U64_U64(a: U64, b: U64): OverflowError ! U64
  • ADD_CHECKED_U128_U128(a: U128, b: U128): OverflowError ! U128
  • ADD_CHECKED_U256_U256(a: U256, b: U256): OverflowError ! U256
  • ADD_CHECKED_S8_S8(a: S8, b: S8): OverflowError ! S8
  • ADD_CHECKED_S16_S16(a: S16, b: S16): OverflowError ! S16
  • ADD_CHECKED_S32_S32(a: S32, b: S32): OverflowError ! S32
  • ADD_CHECKED_S64_S64(a: S64, b: S64): OverflowError ! S64
  • ADD_CHECKED_S128_S128(a: S128, b: S128): OverflowError ! S128
  • ADD_CHECKED_S256_S256(a: S256, b: S256): OverflowError ! S256

SUB_CHECKED

#sub-checked
Arithmetic12 functions

a - b, an OverflowError when it doesn't fit - the same as SUB

  • SUB_CHECKED_U8_U8(a: U8, b: U8): OverflowError ! U8
  • SUB_CHECKED_U16_U16(a: U16, b: U16): OverflowError ! U16
  • SUB_CHECKED_U32_U32(a: U32, b: U32): OverflowError ! U32
  • SUB_CHECKED_U64_U64(a: U64, b: U64): OverflowError ! U64
  • SUB_CHECKED_U128_U128(a: U128, b: U128): OverflowError ! U128
  • SUB_CHECKED_U256_U256(a: U256, b: U256): OverflowError ! U256
  • SUB_CHECKED_S8_S8(a: S8, b: S8): OverflowError ! S8
  • SUB_CHECKED_S16_S16(a: S16, b: S16): OverflowError ! S16
  • SUB_CHECKED_S32_S32(a: S32, b: S32): OverflowError ! S32
  • SUB_CHECKED_S64_S64(a: S64, b: S64): OverflowError ! S64
  • SUB_CHECKED_S128_S128(a: S128, b: S128): OverflowError ! S128
  • SUB_CHECKED_S256_S256(a: S256, b: S256): OverflowError ! S256

MUL_CHECKED

#mul-checked
Arithmetic12 functions

a * b, an OverflowError when it doesn't fit - the same as MUL

  • MUL_CHECKED_U8_U8(a: U8, b: U8): OverflowError ! U8
  • MUL_CHECKED_U16_U16(a: U16, b: U16): OverflowError ! U16
  • MUL_CHECKED_U32_U32(a: U32, b: U32): OverflowError ! U32
  • MUL_CHECKED_U64_U64(a: U64, b: U64): OverflowError ! U64
  • MUL_CHECKED_U128_U128(a: U128, b: U128): OverflowError ! U128
  • MUL_CHECKED_U256_U256(a: U256, b: U256): OverflowError ! U256
  • MUL_CHECKED_S8_S8(a: S8, b: S8): OverflowError ! S8
  • MUL_CHECKED_S16_S16(a: S16, b: S16): OverflowError ! S16
  • MUL_CHECKED_S32_S32(a: S32, b: S32): OverflowError ! S32
  • MUL_CHECKED_S64_S64(a: S64, b: S64): OverflowError ! S64
  • MUL_CHECKED_S128_S128(a: S128, b: S128): OverflowError ! S128
  • MUL_CHECKED_S256_S256(a: S256, b: S256): OverflowError ! S256

NEG_CHECKED

#neg-checked
Arithmetic6 functions

-a, an OverflowError when it doesn't fit - the same as NEG

  • NEG_CHECKED_S8(value: S8): OverflowError ! S8
  • NEG_CHECKED_S16(value: S16): OverflowError ! S16
  • NEG_CHECKED_S32(value: S32): OverflowError ! S32
  • NEG_CHECKED_S64(value: S64): OverflowError ! S64
  • NEG_CHECKED_S128(value: S128): OverflowError ! S128
  • NEG_CHECKED_S256(value: S256): OverflowError ! S256

ADD_WRAPPING

#add-wrapping
Arithmetic12 functions

a + b, wraps around modulo 2^bits - a +% b

  • ADD_WRAPPING_U8_U8(a: U8, b: U8): U8
  • ADD_WRAPPING_U16_U16(a: U16, b: U16): U16
  • ADD_WRAPPING_U32_U32(a: U32, b: U32): U32
  • ADD_WRAPPING_U64_U64(a: U64, b: U64): U64
  • ADD_WRAPPING_U128_U128(a: U128, b: U128): U128
  • ADD_WRAPPING_U256_U256(a: U256, b: U256): U256
  • ADD_WRAPPING_S8_S8(a: S8, b: S8): S8
  • ADD_WRAPPING_S16_S16(a: S16, b: S16): S16
  • ADD_WRAPPING_S32_S32(a: S32, b: S32): S32
  • ADD_WRAPPING_S64_S64(a: S64, b: S64): S64
  • ADD_WRAPPING_S128_S128(a: S128, b: S128): S128
  • ADD_WRAPPING_S256_S256(a: S256, b: S256): S256

SUB_WRAPPING

#sub-wrapping
Arithmetic12 functions

a - b, wraps around modulo 2^bits - a -% b

  • SUB_WRAPPING_U8_U8(a: U8, b: U8): U8
  • SUB_WRAPPING_U16_U16(a: U16, b: U16): U16
  • SUB_WRAPPING_U32_U32(a: U32, b: U32): U32
  • SUB_WRAPPING_U64_U64(a: U64, b: U64): U64
  • SUB_WRAPPING_U128_U128(a: U128, b: U128): U128
  • SUB_WRAPPING_U256_U256(a: U256, b: U256): U256
  • SUB_WRAPPING_S8_S8(a: S8, b: S8): S8
  • SUB_WRAPPING_S16_S16(a: S16, b: S16): S16
  • SUB_WRAPPING_S32_S32(a: S32, b: S32): S32
  • SUB_WRAPPING_S64_S64(a: S64, b: S64): S64
  • SUB_WRAPPING_S128_S128(a: S128, b: S128): S128
  • SUB_WRAPPING_S256_S256(a: S256, b: S256): S256

MUL_WRAPPING

#mul-wrapping
Arithmetic12 functions

a * b, wraps around modulo 2^bits - a *% b

  • MUL_WRAPPING_U8_U8(a: U8, b: U8): U8
  • MUL_WRAPPING_U16_U16(a: U16, b: U16): U16
  • MUL_WRAPPING_U32_U32(a: U32, b: U32): U32
  • MUL_WRAPPING_U64_U64(a: U64, b: U64): U64
  • MUL_WRAPPING_U128_U128(a: U128, b: U128): U128
  • MUL_WRAPPING_U256_U256(a: U256, b: U256): U256
  • MUL_WRAPPING_S8_S8(a: S8, b: S8): S8
  • MUL_WRAPPING_S16_S16(a: S16, b: S16): S16
  • MUL_WRAPPING_S32_S32(a: S32, b: S32): S32
  • MUL_WRAPPING_S64_S64(a: S64, b: S64): S64
  • MUL_WRAPPING_S128_S128(a: S128, b: S128): S128
  • MUL_WRAPPING_S256_S256(a: S256, b: S256): S256

NEG_WRAPPING

#neg-wrapping
Arithmetic6 functions

-a, wraps around modulo 2^bits

  • NEG_WRAPPING_S8(value: S8): S8
  • NEG_WRAPPING_S16(value: S16): S16
  • NEG_WRAPPING_S32(value: S32): S32
  • NEG_WRAPPING_S64(value: S64): S64
  • NEG_WRAPPING_S128(value: S128): S128
  • NEG_WRAPPING_S256(value: S256): S256

ADD_SATURATING

#add-saturating
Arithmetic12 functions

a + b, clamps to min() / max() - a +| b

  • ADD_SATURATING_U8_U8(a: U8, b: U8): U8
  • ADD_SATURATING_U16_U16(a: U16, b: U16): U16
  • ADD_SATURATING_U32_U32(a: U32, b: U32): U32
  • ADD_SATURATING_U64_U64(a: U64, b: U64): U64
  • ADD_SATURATING_U128_U128(a: U128, b: U128): U128
  • ADD_SATURATING_U256_U256(a: U256, b: U256): U256
  • ADD_SATURATING_S8_S8(a: S8, b: S8): S8
  • ADD_SATURATING_S16_S16(a: S16, b: S16): S16
  • ADD_SATURATING_S32_S32(a: S32, b: S32): S32
  • ADD_SATURATING_S64_S64(a: S64, b: S64): S64
  • ADD_SATURATING_S128_S128(a: S128, b: S128): S128
  • ADD_SATURATING_S256_S256(a: S256, b: S256): S256

SUB_SATURATING

#sub-saturating
Arithmetic12 functions

a - b, clamps to min() / max() - a -| b

  • SUB_SATURATING_U8_U8(a: U8, b: U8): U8
  • SUB_SATURATING_U16_U16(a: U16, b: U16): U16
  • SUB_SATURATING_U32_U32(a: U32, b: U32): U32
  • SUB_SATURATING_U64_U64(a: U64, b: U64): U64
  • SUB_SATURATING_U128_U128(a: U128, b: U128): U128
  • SUB_SATURATING_U256_U256(a: U256, b: U256): U256
  • SUB_SATURATING_S8_S8(a: S8, b: S8): S8
  • SUB_SATURATING_S16_S16(a: S16, b: S16): S16
  • SUB_SATURATING_S32_S32(a: S32, b: S32): S32
  • SUB_SATURATING_S64_S64(a: S64, b: S64): S64
  • SUB_SATURATING_S128_S128(a: S128, b: S128): S128
  • SUB_SATURATING_S256_S256(a: S256, b: S256): S256

MUL_SATURATING

#mul-saturating
Arithmetic12 functions

a * b, clamps to min() / max() - a *| b

  • MUL_SATURATING_U8_U8(a: U8, b: U8): U8
  • MUL_SATURATING_U16_U16(a: U16, b: U16): U16
  • MUL_SATURATING_U32_U32(a: U32, b: U32): U32
  • MUL_SATURATING_U64_U64(a: U64, b: U64): U64
  • MUL_SATURATING_U128_U128(a: U128, b: U128): U128
  • MUL_SATURATING_U256_U256(a: U256, b: U256): U256
  • MUL_SATURATING_S8_S8(a: S8, b: S8): S8
  • MUL_SATURATING_S16_S16(a: S16, b: S16): S16
  • MUL_SATURATING_S32_S32(a: S32, b: S32): S32
  • MUL_SATURATING_S64_S64(a: S64, b: S64): S64
  • MUL_SATURATING_S128_S128(a: S128, b: S128): S128
  • MUL_SATURATING_S256_S256(a: S256, b: S256): S256

Comparison

EQ

#eq
Comparison21 functions

a == b (floats: IEEE-equal - NaN is never equal, not even to itself, an infinity only to itself,

  • EQ_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Boolean
  • EQ_CODEPOINT_CODEPOINT(a: Codepoint, b: Codepoint): Boolean
  • EQ_U8_U8(a: U8, b: U8): Boolean
  • EQ_U16_U16(a: U16, b: U16): Boolean
  • EQ_U32_U32(a: U32, b: U32): Boolean
  • EQ_U64_U64(a: U64, b: U64): Boolean
  • EQ_U128_U128(a: U128, b: U128): Boolean
  • EQ_U256_U256(a: U256, b: U256): Boolean
  • EQ_S8_S8(a: S8, b: S8): Boolean
  • EQ_S16_S16(a: S16, b: S16): Boolean
  • EQ_S32_S32(a: S32, b: S32): Boolean
  • EQ_S64_S64(a: S64, b: S64): Boolean
  • EQ_S128_S128(a: S128, b: S128): Boolean
  • EQ_S256_S256(a: S256, b: S256): Boolean
  • EQ_F16_F16(a: F16, b: F16): Boolean
  • EQ_F32_F32(a: F32, b: F32): Boolean
  • EQ_F64_F64(a: F64, b: F64): Boolean
  • EQ_C32_C32(a: C32, b: C32): Boolean
  • EQ_C64_C64(a: C64, b: C64): Boolean
  • EQ_Q32_Q32(a: Q32, b: Q32): Boolean
  • EQ_Q64_Q64(a: Q64, b: Q64): Boolean

NE

#ne
Comparison21 functions

a != b (not EQ)

  • NE_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Boolean
  • NE_CODEPOINT_CODEPOINT(a: Codepoint, b: Codepoint): Boolean
  • NE_U8_U8(a: U8, b: U8): Boolean
  • NE_U16_U16(a: U16, b: U16): Boolean
  • NE_U32_U32(a: U32, b: U32): Boolean
  • NE_U64_U64(a: U64, b: U64): Boolean
  • NE_U128_U128(a: U128, b: U128): Boolean
  • NE_U256_U256(a: U256, b: U256): Boolean
  • NE_S8_S8(a: S8, b: S8): Boolean
  • NE_S16_S16(a: S16, b: S16): Boolean
  • NE_S32_S32(a: S32, b: S32): Boolean
  • NE_S64_S64(a: S64, b: S64): Boolean
  • NE_S128_S128(a: S128, b: S128): Boolean
  • NE_S256_S256(a: S256, b: S256): Boolean
  • NE_F16_F16(a: F16, b: F16): Boolean
  • NE_F32_F32(a: F32, b: F32): Boolean
  • NE_F64_F64(a: F64, b: F64): Boolean
  • NE_C32_C32(a: C32, b: C32): Boolean
  • NE_C64_C64(a: C64, b: C64): Boolean
  • NE_Q32_Q32(a: Q32, b: Q32): Boolean
  • NE_Q64_Q64(a: Q64, b: Q64): Boolean

LT

#lt
Comparison17 functions

a < b (floats: false when either is NaN, or when they're EQ)

  • LT_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Boolean
  • LT_CODEPOINT_CODEPOINT(a: Codepoint, b: Codepoint): Boolean
  • LT_U8_U8(a: U8, b: U8): Boolean
  • LT_U16_U16(a: U16, b: U16): Boolean
  • LT_U32_U32(a: U32, b: U32): Boolean
  • LT_U64_U64(a: U64, b: U64): Boolean
  • LT_U128_U128(a: U128, b: U128): Boolean
  • LT_U256_U256(a: U256, b: U256): Boolean
  • LT_S8_S8(a: S8, b: S8): Boolean
  • LT_S16_S16(a: S16, b: S16): Boolean
  • LT_S32_S32(a: S32, b: S32): Boolean
  • LT_S64_S64(a: S64, b: S64): Boolean
  • LT_S128_S128(a: S128, b: S128): Boolean
  • LT_S256_S256(a: S256, b: S256): Boolean
  • LT_F16_F16(a: F16, b: F16): Boolean
  • LT_F32_F32(a: F32, b: F32): Boolean
  • LT_F64_F64(a: F64, b: F64): Boolean

LE

#le
Comparison17 functions

a <= b (floats: LT or EQ)

  • LE_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Boolean
  • LE_CODEPOINT_CODEPOINT(a: Codepoint, b: Codepoint): Boolean
  • LE_U8_U8(a: U8, b: U8): Boolean
  • LE_U16_U16(a: U16, b: U16): Boolean
  • LE_U32_U32(a: U32, b: U32): Boolean
  • LE_U64_U64(a: U64, b: U64): Boolean
  • LE_U128_U128(a: U128, b: U128): Boolean
  • LE_U256_U256(a: U256, b: U256): Boolean
  • LE_S8_S8(a: S8, b: S8): Boolean
  • LE_S16_S16(a: S16, b: S16): Boolean
  • LE_S32_S32(a: S32, b: S32): Boolean
  • LE_S64_S64(a: S64, b: S64): Boolean
  • LE_S128_S128(a: S128, b: S128): Boolean
  • LE_S256_S256(a: S256, b: S256): Boolean
  • LE_F16_F16(a: F16, b: F16): Boolean
  • LE_F32_F32(a: F32, b: F32): Boolean
  • LE_F64_F64(a: F64, b: F64): Boolean

GT

#gt
Comparison17 functions

a > b (floats: false when either is NaN, or when they're EQ)

  • GT_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Boolean
  • GT_CODEPOINT_CODEPOINT(a: Codepoint, b: Codepoint): Boolean
  • GT_U8_U8(a: U8, b: U8): Boolean
  • GT_U16_U16(a: U16, b: U16): Boolean
  • GT_U32_U32(a: U32, b: U32): Boolean
  • GT_U64_U64(a: U64, b: U64): Boolean
  • GT_U128_U128(a: U128, b: U128): Boolean
  • GT_U256_U256(a: U256, b: U256): Boolean
  • GT_S8_S8(a: S8, b: S8): Boolean
  • GT_S16_S16(a: S16, b: S16): Boolean
  • GT_S32_S32(a: S32, b: S32): Boolean
  • GT_S64_S64(a: S64, b: S64): Boolean
  • GT_S128_S128(a: S128, b: S128): Boolean
  • GT_S256_S256(a: S256, b: S256): Boolean
  • GT_F16_F16(a: F16, b: F16): Boolean
  • GT_F32_F32(a: F32, b: F32): Boolean
  • GT_F64_F64(a: F64, b: F64): Boolean

GE

#ge
Comparison17 functions

a >= b (floats: GT or EQ)

  • GE_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Boolean
  • GE_CODEPOINT_CODEPOINT(a: Codepoint, b: Codepoint): Boolean
  • GE_U8_U8(a: U8, b: U8): Boolean
  • GE_U16_U16(a: U16, b: U16): Boolean
  • GE_U32_U32(a: U32, b: U32): Boolean
  • GE_U64_U64(a: U64, b: U64): Boolean
  • GE_U128_U128(a: U128, b: U128): Boolean
  • GE_U256_U256(a: U256, b: U256): Boolean
  • GE_S8_S8(a: S8, b: S8): Boolean
  • GE_S16_S16(a: S16, b: S16): Boolean
  • GE_S32_S32(a: S32, b: S32): Boolean
  • GE_S64_S64(a: S64, b: S64): Boolean
  • GE_S128_S128(a: S128, b: S128): Boolean
  • GE_S256_S256(a: S256, b: S256): Boolean
  • GE_F16_F16(a: F16, b: F16): Boolean
  • GE_F32_F32(a: F32, b: F32): Boolean
  • GE_F64_F64(a: F64, b: F64): Boolean

CMP

#cmp
Comparison17 functions

Comparable.compare - floats order NaN after everything, like Comparable does, and are Equal when EQ

  • CMP_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Ordering
  • CMP_CODEPOINT_CODEPOINT(a: Codepoint, b: Codepoint): Ordering
  • CMP_U8_U8(a: U8, b: U8): Ordering
  • CMP_U16_U16(a: U16, b: U16): Ordering
  • CMP_U32_U32(a: U32, b: U32): Ordering
  • CMP_U64_U64(a: U64, b: U64): Ordering
  • CMP_U128_U128(a: U128, b: U128): Ordering
  • CMP_U256_U256(a: U256, b: U256): Ordering
  • CMP_S8_S8(a: S8, b: S8): Ordering
  • CMP_S16_S16(a: S16, b: S16): Ordering
  • CMP_S32_S32(a: S32, b: S32): Ordering
  • CMP_S64_S64(a: S64, b: S64): Ordering
  • CMP_S128_S128(a: S128, b: S128): Ordering
  • CMP_S256_S256(a: S256, b: S256): Ordering
  • CMP_F16_F16(a: F16, b: F16): Ordering
  • CMP_F32_F32(a: F32, b: F32): Ordering
  • CMP_F64_F64(a: F64, b: F64): Ordering

Bitwise (integers)

BOR

#bor
Bitwise (integers)12 functions

a bor b

  • BOR_U8_U8(a: U8, b: U8): U8
  • BOR_U16_U16(a: U16, b: U16): U16
  • BOR_U32_U32(a: U32, b: U32): U32
  • BOR_U64_U64(a: U64, b: U64): U64
  • BOR_U128_U128(a: U128, b: U128): U128
  • BOR_U256_U256(a: U256, b: U256): U256
  • BOR_S8_S8(a: S8, b: S8): S8
  • BOR_S16_S16(a: S16, b: S16): S16
  • BOR_S32_S32(a: S32, b: S32): S32
  • BOR_S64_S64(a: S64, b: S64): S64
  • BOR_S128_S128(a: S128, b: S128): S128
  • BOR_S256_S256(a: S256, b: S256): S256

BXOR

#bxor
Bitwise (integers)12 functions

a bxor b

  • BXOR_U8_U8(a: U8, b: U8): U8
  • BXOR_U16_U16(a: U16, b: U16): U16
  • BXOR_U32_U32(a: U32, b: U32): U32
  • BXOR_U64_U64(a: U64, b: U64): U64
  • BXOR_U128_U128(a: U128, b: U128): U128
  • BXOR_U256_U256(a: U256, b: U256): U256
  • BXOR_S8_S8(a: S8, b: S8): S8
  • BXOR_S16_S16(a: S16, b: S16): S16
  • BXOR_S32_S32(a: S32, b: S32): S32
  • BXOR_S64_S64(a: S64, b: S64): S64
  • BXOR_S128_S128(a: S128, b: S128): S128
  • BXOR_S256_S256(a: S256, b: S256): S256

BAND

#band
Bitwise (integers)12 functions

a band b

  • BAND_U8_U8(a: U8, b: U8): U8
  • BAND_U16_U16(a: U16, b: U16): U16
  • BAND_U32_U32(a: U32, b: U32): U32
  • BAND_U64_U64(a: U64, b: U64): U64
  • BAND_U128_U128(a: U128, b: U128): U128
  • BAND_U256_U256(a: U256, b: U256): U256
  • BAND_S8_S8(a: S8, b: S8): S8
  • BAND_S16_S16(a: S16, b: S16): S16
  • BAND_S32_S32(a: S32, b: S32): S32
  • BAND_S64_S64(a: S64, b: S64): S64
  • BAND_S128_S128(a: S128, b: S128): S128
  • BAND_S256_S256(a: S256, b: S256): S256

BNOT

#bnot
Bitwise (integers)12 functions

~a

  • BNOT_U8(value: U8): U8
  • BNOT_U16(value: U16): U16
  • BNOT_U32(value: U32): U32
  • BNOT_U64(value: U64): U64
  • BNOT_U128(value: U128): U128
  • BNOT_U256(value: U256): U256
  • BNOT_S8(value: S8): S8
  • BNOT_S16(value: S16): S16
  • BNOT_S32(value: S32): S32
  • BNOT_S64(value: S64): S64
  • BNOT_S128(value: S128): S128
  • BNOT_S256(value: S256): S256

SHL

#shl
Bitwise (integers)12 functions

a shl b - b at or above the bit count shifts every bit out: 0

  • SHL_U8_U8(a: U8, b: U8): U8
  • SHL_U16_U16(a: U16, b: U16): U16
  • SHL_U32_U32(a: U32, b: U32): U32
  • SHL_U64_U64(a: U64, b: U64): U64
  • SHL_U128_U128(a: U128, b: U128): U128
  • SHL_U256_U256(a: U256, b: U256): U256
  • SHL_S8_S8(a: S8, b: S8): S8
  • SHL_S16_S16(a: S16, b: S16): S16
  • SHL_S32_S32(a: S32, b: S32): S32
  • SHL_S64_S64(a: S64, b: S64): S64
  • SHL_S128_S128(a: S128, b: S128): S128
  • SHL_S256_S256(a: S256, b: S256): S256

SHR

#shr
Bitwise (integers)12 functions

a shr b - arithmetic for S*, logical for U*; b at or above the bit count shifts every bit out (-1

  • SHR_U8_U8(a: U8, b: U8): U8
  • SHR_U16_U16(a: U16, b: U16): U16
  • SHR_U32_U32(a: U32, b: U32): U32
  • SHR_U64_U64(a: U64, b: U64): U64
  • SHR_U128_U128(a: U128, b: U128): U128
  • SHR_U256_U256(a: U256, b: U256): U256
  • SHR_S8_S8(a: S8, b: S8): S8
  • SHR_S16_S16(a: S16, b: S16): S16
  • SHR_S32_S32(a: S32, b: S32): S32
  • SHR_S64_S64(a: S64, b: S64): S64
  • SHR_S128_S128(a: S128, b: S128): S128
  • SHR_S256_S256(a: S256, b: S256): S256

ROTL

#rotl
Bitwise (integers)12 functions

rotate left by b bits (modulo the bit count)

  • ROTL_U8_U8(a: U8, b: U8): U8
  • ROTL_U16_U16(a: U16, b: U16): U16
  • ROTL_U32_U32(a: U32, b: U32): U32
  • ROTL_U64_U64(a: U64, b: U64): U64
  • ROTL_U128_U128(a: U128, b: U128): U128
  • ROTL_U256_U256(a: U256, b: U256): U256
  • ROTL_S8_S8(a: S8, b: S8): S8
  • ROTL_S16_S16(a: S16, b: S16): S16
  • ROTL_S32_S32(a: S32, b: S32): S32
  • ROTL_S64_S64(a: S64, b: S64): S64
  • ROTL_S128_S128(a: S128, b: S128): S128
  • ROTL_S256_S256(a: S256, b: S256): S256

ROTR

#rotr
Bitwise (integers)12 functions

rotate right by b bits (modulo the bit count)

  • ROTR_U8_U8(a: U8, b: U8): U8
  • ROTR_U16_U16(a: U16, b: U16): U16
  • ROTR_U32_U32(a: U32, b: U32): U32
  • ROTR_U64_U64(a: U64, b: U64): U64
  • ROTR_U128_U128(a: U128, b: U128): U128
  • ROTR_U256_U256(a: U256, b: U256): U256
  • ROTR_S8_S8(a: S8, b: S8): S8
  • ROTR_S16_S16(a: S16, b: S16): S16
  • ROTR_S32_S32(a: S32, b: S32): S32
  • ROTR_S64_S64(a: S64, b: S64): S64
  • ROTR_S128_S128(a: S128, b: S128): S128
  • ROTR_S256_S256(a: S256, b: S256): S256

POPCNT

#popcnt
Bitwise (integers)12 functions

number of set bits

  • POPCNT_U8(value: U8): U8
  • POPCNT_U16(value: U16): U8
  • POPCNT_U32(value: U32): U8
  • POPCNT_U64(value: U64): U8
  • POPCNT_U128(value: U128): U8
  • POPCNT_U256(value: U256): U8
  • POPCNT_S8(value: S8): U8
  • POPCNT_S16(value: S16): U8
  • POPCNT_S32(value: S32): U8
  • POPCNT_S64(value: S64): U8
  • POPCNT_S128(value: S128): U8
  • POPCNT_S256(value: S256): U8

CLZ

#clz
Bitwise (integers)12 functions

number of leading zero bits

  • CLZ_U8(value: U8): U8
  • CLZ_U16(value: U16): U8
  • CLZ_U32(value: U32): U8
  • CLZ_U64(value: U64): U8
  • CLZ_U128(value: U128): U8
  • CLZ_U256(value: U256): U8
  • CLZ_S8(value: S8): U8
  • CLZ_S16(value: S16): U8
  • CLZ_S32(value: S32): U8
  • CLZ_S64(value: S64): U8
  • CLZ_S128(value: S128): U8
  • CLZ_S256(value: S256): U8

CTZ

#ctz
Bitwise (integers)12 functions

number of trailing zero bits

  • CTZ_U8(value: U8): U8
  • CTZ_U16(value: U16): U8
  • CTZ_U32(value: U32): U8
  • CTZ_U64(value: U64): U8
  • CTZ_U128(value: U128): U8
  • CTZ_U256(value: U256): U8
  • CTZ_S8(value: S8): U8
  • CTZ_S16(value: S16): U8
  • CTZ_S32(value: S32): U8
  • CTZ_S64(value: S64): U8
  • CTZ_S128(value: S128): U8
  • CTZ_S256(value: S256): U8

BSWAP

#bswap
Bitwise (integers)12 functions

reverse the byte order

  • BSWAP_U8(value: U8): U8
  • BSWAP_U16(value: U16): U16
  • BSWAP_U32(value: U32): U32
  • BSWAP_U64(value: U64): U64
  • BSWAP_U128(value: U128): U128
  • BSWAP_U256(value: U256): U256
  • BSWAP_S8(value: S8): S8
  • BSWAP_S16(value: S16): S16
  • BSWAP_S32(value: S32): S32
  • BSWAP_S64(value: S64): S64
  • BSWAP_S128(value: S128): S128
  • BSWAP_S256(value: S256): S256

Casts

CAST: integer to integer

#cast-integer-to-integer
Casts132 functions

a value the target can't hold (narrowing, or S* to U* below zero) is an

  • CAST_U8_U16(value: U8): U16
  • CAST_U8_U32(value: U8): U32
  • CAST_U8_U64(value: U8): U64
  • CAST_U8_U128(value: U8): U128
  • CAST_U8_U256(value: U8): U256
  • CAST_U8_S8(value: U8): S8
  • CAST_U8_S16(value: U8): S16
  • CAST_U8_S32(value: U8): S32
  • CAST_U8_S64(value: U8): S64
  • CAST_U8_S128(value: U8): S128
  • CAST_U8_S256(value: U8): S256
  • CAST_U16_U8(value: U16): U8
  • CAST_U16_U32(value: U16): U32
  • CAST_U16_U64(value: U16): U64
  • CAST_U16_U128(value: U16): U128
  • CAST_U16_U256(value: U16): U256
  • CAST_U16_S8(value: U16): S8
  • CAST_U16_S16(value: U16): S16
  • CAST_U16_S32(value: U16): S32
  • CAST_U16_S64(value: U16): S64
  • CAST_U16_S128(value: U16): S128
  • CAST_U16_S256(value: U16): S256
  • CAST_U32_U8(value: U32): U8
  • CAST_U32_U16(value: U32): U16
  • CAST_U32_U64(value: U32): U64
  • CAST_U32_U128(value: U32): U128
  • CAST_U32_U256(value: U32): U256
  • CAST_U32_S8(value: U32): S8
  • CAST_U32_S16(value: U32): S16
  • CAST_U32_S32(value: U32): S32
  • CAST_U32_S64(value: U32): S64
  • CAST_U32_S128(value: U32): S128
  • CAST_U32_S256(value: U32): S256
  • CAST_U64_U8(value: U64): U8
  • CAST_U64_U16(value: U64): U16
  • CAST_U64_U32(value: U64): U32
  • CAST_U64_U128(value: U64): U128
  • CAST_U64_U256(value: U64): U256
  • CAST_U64_S8(value: U64): S8
  • CAST_U64_S16(value: U64): S16
  • CAST_U64_S32(value: U64): S32
  • CAST_U64_S64(value: U64): S64
  • CAST_U64_S128(value: U64): S128
  • CAST_U64_S256(value: U64): S256
  • CAST_U128_U8(value: U128): U8
  • CAST_U128_U16(value: U128): U16
  • CAST_U128_U32(value: U128): U32
  • CAST_U128_U64(value: U128): U64
  • CAST_U128_U256(value: U128): U256
  • CAST_U128_S8(value: U128): S8
  • CAST_U128_S16(value: U128): S16
  • CAST_U128_S32(value: U128): S32
  • CAST_U128_S64(value: U128): S64
  • CAST_U128_S128(value: U128): S128
  • CAST_U128_S256(value: U128): S256
  • CAST_U256_U8(value: U256): U8
  • CAST_U256_U16(value: U256): U16
  • CAST_U256_U32(value: U256): U32
  • CAST_U256_U64(value: U256): U64
  • CAST_U256_U128(value: U256): U128
  • CAST_U256_S8(value: U256): S8
  • CAST_U256_S16(value: U256): S16
  • CAST_U256_S32(value: U256): S32
  • CAST_U256_S64(value: U256): S64
  • CAST_U256_S128(value: U256): S128
  • CAST_U256_S256(value: U256): S256
  • CAST_S8_U8(value: S8): U8
  • CAST_S8_U16(value: S8): U16
  • CAST_S8_U32(value: S8): U32
  • CAST_S8_U64(value: S8): U64
  • CAST_S8_U128(value: S8): U128
  • CAST_S8_U256(value: S8): U256
  • CAST_S8_S16(value: S8): S16
  • CAST_S8_S32(value: S8): S32
  • CAST_S8_S64(value: S8): S64
  • CAST_S8_S128(value: S8): S128
  • CAST_S8_S256(value: S8): S256
  • CAST_S16_U8(value: S16): U8
  • CAST_S16_U16(value: S16): U16
  • CAST_S16_U32(value: S16): U32
  • CAST_S16_U64(value: S16): U64
  • CAST_S16_U128(value: S16): U128
  • CAST_S16_U256(value: S16): U256
  • CAST_S16_S8(value: S16): S8
  • CAST_S16_S32(value: S16): S32
  • CAST_S16_S64(value: S16): S64
  • CAST_S16_S128(value: S16): S128
  • CAST_S16_S256(value: S16): S256
  • CAST_S32_U8(value: S32): U8
  • CAST_S32_U16(value: S32): U16
  • CAST_S32_U32(value: S32): U32
  • CAST_S32_U64(value: S32): U64
  • CAST_S32_U128(value: S32): U128
  • CAST_S32_U256(value: S32): U256
  • CAST_S32_S8(value: S32): S8
  • CAST_S32_S16(value: S32): S16
  • CAST_S32_S64(value: S32): S64
  • CAST_S32_S128(value: S32): S128
  • CAST_S32_S256(value: S32): S256
  • CAST_S64_U8(value: S64): U8
  • CAST_S64_U16(value: S64): U16
  • CAST_S64_U32(value: S64): U32
  • CAST_S64_U64(value: S64): U64
  • CAST_S64_U128(value: S64): U128
  • CAST_S64_U256(value: S64): U256
  • CAST_S64_S8(value: S64): S8
  • CAST_S64_S16(value: S64): S16
  • CAST_S64_S32(value: S64): S32
  • CAST_S64_S128(value: S64): S128
  • CAST_S64_S256(value: S64): S256
  • CAST_S128_U8(value: S128): U8
  • CAST_S128_U16(value: S128): U16
  • CAST_S128_U32(value: S128): U32
  • CAST_S128_U64(value: S128): U64
  • CAST_S128_U128(value: S128): U128
  • CAST_S128_U256(value: S128): U256
  • CAST_S128_S8(value: S128): S8
  • CAST_S128_S16(value: S128): S16
  • CAST_S128_S32(value: S128): S32
  • CAST_S128_S64(value: S128): S64
  • CAST_S128_S256(value: S128): S256
  • CAST_S256_U8(value: S256): U8
  • CAST_S256_U16(value: S256): U16
  • CAST_S256_U32(value: S256): U32
  • CAST_S256_U64(value: S256): U64
  • CAST_S256_U128(value: S256): U128
  • CAST_S256_U256(value: S256): U256
  • CAST_S256_S8(value: S256): S8
  • CAST_S256_S16(value: S256): S16
  • CAST_S256_S32(value: S256): S32
  • CAST_S256_S64(value: S256): S64
  • CAST_S256_S128(value: S256): S128

CAST: integer to float

#cast-integer-to-float
Casts36 functions

rounds to nearest, ties to even, when the float can't hold it exactly

  • CAST_U8_F16(value: U8): F16
  • CAST_U8_F32(value: U8): F32
  • CAST_U8_F64(value: U8): F64
  • CAST_U16_F16(value: U16): F16
  • CAST_U16_F32(value: U16): F32
  • CAST_U16_F64(value: U16): F64
  • CAST_U32_F16(value: U32): F16
  • CAST_U32_F32(value: U32): F32
  • CAST_U32_F64(value: U32): F64
  • CAST_U64_F16(value: U64): F16
  • CAST_U64_F32(value: U64): F32
  • CAST_U64_F64(value: U64): F64
  • CAST_U128_F16(value: U128): F16
  • CAST_U128_F32(value: U128): F32
  • CAST_U128_F64(value: U128): F64
  • CAST_U256_F16(value: U256): F16
  • CAST_U256_F32(value: U256): F32
  • CAST_U256_F64(value: U256): F64
  • CAST_S8_F16(value: S8): F16
  • CAST_S8_F32(value: S8): F32
  • CAST_S8_F64(value: S8): F64
  • CAST_S16_F16(value: S16): F16
  • CAST_S16_F32(value: S16): F32
  • CAST_S16_F64(value: S16): F64
  • CAST_S32_F16(value: S32): F16
  • CAST_S32_F32(value: S32): F32
  • CAST_S32_F64(value: S32): F64
  • CAST_S64_F16(value: S64): F16
  • CAST_S64_F32(value: S64): F32
  • CAST_S64_F64(value: S64): F64
  • CAST_S128_F16(value: S128): F16
  • CAST_S128_F32(value: S128): F32
  • CAST_S128_F64(value: S128): F64
  • CAST_S256_F16(value: S256): F16
  • CAST_S256_F32(value: S256): F32
  • CAST_S256_F64(value: S256): F64

CAST: float to integer

#cast-float-to-integer
Casts36 functions

rounds toward zero; out of range, NaN and an infinity are a CastError

  • CAST_F16_U8(value: F16): CastError ! U8
  • CAST_F32_U8(value: F32): CastError ! U8
  • CAST_F16_U16(value: F16): CastError ! U16
  • CAST_F32_U16(value: F32): CastError ! U16
  • CAST_F16_U32(value: F16): CastError ! U32
  • CAST_F32_U32(value: F32): CastError ! U32
  • CAST_F16_U64(value: F16): CastError ! U64
  • CAST_F32_U64(value: F32): CastError ! U64
  • CAST_F16_U128(value: F16): CastError ! U128
  • CAST_F32_U128(value: F32): CastError ! U128
  • CAST_F16_U256(value: F16): CastError ! U256
  • CAST_F32_U256(value: F32): CastError ! U256
  • CAST_F16_S8(value: F16): CastError ! S8
  • CAST_F32_S8(value: F32): CastError ! S8
  • CAST_F16_S16(value: F16): CastError ! S16
  • CAST_F32_S16(value: F32): CastError ! S16
  • CAST_F16_S32(value: F16): CastError ! S32
  • CAST_F32_S32(value: F32): CastError ! S32
  • CAST_F16_S64(value: F16): CastError ! S64
  • CAST_F32_S64(value: F32): CastError ! S64
  • CAST_F16_S128(value: F16): CastError ! S128
  • CAST_F32_S128(value: F32): CastError ! S128
  • CAST_F16_S256(value: F16): CastError ! S256
  • CAST_F32_S256(value: F32): CastError ! S256
  • CAST_F64_U8(value: F64): CastError ! U8
  • CAST_F64_U16(value: F64): CastError ! U16
  • CAST_F64_U32(value: F64): CastError ! U32
  • CAST_F64_U64(value: F64): CastError ! U64
  • CAST_F64_U128(value: F64): CastError ! U128
  • CAST_F64_U256(value: F64): CastError ! U256
  • CAST_F64_S8(value: F64): CastError ! S8
  • CAST_F64_S16(value: F64): CastError ! S16
  • CAST_F64_S32(value: F64): CastError ! S32
  • CAST_F64_S64(value: F64): CastError ! S64
  • CAST_F64_S128(value: F64): CastError ! S128
  • CAST_F64_S256(value: F64): CastError ! S256

CAST: float to float

#cast-float-to-float
Casts6 functions

rounds to nearest, ties to even, when narrowing

  • CAST_F16_F64(value: F16): F64
  • CAST_F32_F16(value: F32): F16
  • CAST_F32_F64(value: F32): F64
  • CAST_F16_F32(value: F16): F32
  • CAST_F64_F16(value: F64): F16
  • CAST_F64_F32(value: F64): F32

CAST: real to complex

#cast-real-to-complex
Casts30 functions

imaginary part 0

  • CAST_U8_C32(value: U8): C32
  • CAST_U8_C64(value: U8): C64
  • CAST_U16_C32(value: U16): C32
  • CAST_U16_C64(value: U16): C64
  • CAST_U32_C32(value: U32): C32
  • CAST_U32_C64(value: U32): C64
  • CAST_U64_C32(value: U64): C32
  • CAST_U64_C64(value: U64): C64
  • CAST_U128_C32(value: U128): C32
  • CAST_U128_C64(value: U128): C64
  • CAST_U256_C32(value: U256): C32
  • CAST_U256_C64(value: U256): C64
  • CAST_S8_C32(value: S8): C32
  • CAST_S8_C64(value: S8): C64
  • CAST_S16_C32(value: S16): C32
  • CAST_S16_C64(value: S16): C64
  • CAST_S32_C32(value: S32): C32
  • CAST_S32_C64(value: S32): C64
  • CAST_S64_C32(value: S64): C32
  • CAST_S64_C64(value: S64): C64
  • CAST_S128_C32(value: S128): C32
  • CAST_S128_C64(value: S128): C64
  • CAST_S256_C32(value: S256): C32
  • CAST_S256_C64(value: S256): C64
  • CAST_F16_C32(value: F16): C32
  • CAST_F32_C32(value: F32): C32
  • CAST_F16_C64(value: F16): C64
  • CAST_F32_C64(value: F32): C64
  • CAST_F64_C32(value: F64): C32
  • CAST_F64_C64(value: F64): C64

CAST: complex to complex

#cast-complex-to-complex
Casts2 functions

each part cast like float to float

  • CAST_C32_C64(value: C32): C64
  • CAST_C64_C32(value: C64): C32

CAST: real to quaternion

#cast-real-to-quaternion
Casts30 functions

x, y, z parts 0

  • CAST_U8_Q32(value: U8): Q32
  • CAST_U8_Q64(value: U8): Q64
  • CAST_U16_Q32(value: U16): Q32
  • CAST_U16_Q64(value: U16): Q64
  • CAST_U32_Q32(value: U32): Q32
  • CAST_U32_Q64(value: U32): Q64
  • CAST_U64_Q32(value: U64): Q32
  • CAST_U64_Q64(value: U64): Q64
  • CAST_U128_Q32(value: U128): Q32
  • CAST_U128_Q64(value: U128): Q64
  • CAST_U256_Q32(value: U256): Q32
  • CAST_U256_Q64(value: U256): Q64
  • CAST_S8_Q32(value: S8): Q32
  • CAST_S8_Q64(value: S8): Q64
  • CAST_S16_Q32(value: S16): Q32
  • CAST_S16_Q64(value: S16): Q64
  • CAST_S32_Q32(value: S32): Q32
  • CAST_S32_Q64(value: S32): Q64
  • CAST_S64_Q32(value: S64): Q32
  • CAST_S64_Q64(value: S64): Q64
  • CAST_S128_Q32(value: S128): Q32
  • CAST_S128_Q64(value: S128): Q64
  • CAST_S256_Q32(value: S256): Q32
  • CAST_S256_Q64(value: S256): Q64
  • CAST_F16_Q32(value: F16): Q32
  • CAST_F32_Q32(value: F32): Q32
  • CAST_F16_Q64(value: F16): Q64
  • CAST_F32_Q64(value: F32): Q64
  • CAST_F64_Q32(value: F64): Q32
  • CAST_F64_Q64(value: F64): Q64

CAST: complex to quaternion

#cast-complex-to-quaternion
Casts4 functions

real to w, imaginary to x, y and z 0

  • CAST_C32_Q32(value: C32): Q32
  • CAST_C32_Q64(value: C32): Q64
  • CAST_C64_Q32(value: C64): Q32
  • CAST_C64_Q64(value: C64): Q64

CAST: quaternion to quaternion

#cast-quaternion-to-quaternion
Casts2 functions

each part cast like float to float

  • CAST_Q32_Q64(value: Q32): Q64
  • CAST_Q64_Q32(value: Q64): Q32

CAST: Boolean and Codepoint

#cast-boolean-and-codepoint
Casts4 functions
  • CAST_BOOLEAN_U8(value: Boolean): U8false 0, true 1
  • CAST_U8_BOOLEAN(value: U8): Boolean0 false, anything else true
  • CAST_CODEPOINT_U32(value: Codepoint): U32
  • CAST_U32_CODEPOINT(value: U32): CastError ! Codepointsurrogates and above 0x10FFFF are a CastError

Float math

SQRT

#sqrt
Float math3 functions

square root (NaN below zero)

  • SQRT_F16(value: F16): F16
  • SQRT_F32(value: F32): F32
  • SQRT_F64(value: F64): F64

CBRT

#cbrt
Float math3 functions

cube root

  • CBRT_F16(value: F16): F16
  • CBRT_F32(value: F32): F32
  • CBRT_F64(value: F64): F64

EXP

#exp
Float math3 functions

e ^ value

  • EXP_F16(value: F16): F16
  • EXP_F32(value: F32): F32
  • EXP_F64(value: F64): F64

EXP2

#exp2
Float math3 functions

2 ^ value

  • EXP2_F16(value: F16): F16
  • EXP2_F32(value: F32): F32
  • EXP2_F64(value: F64): F64

LN

#ln
Float math3 functions

natural logarithm

  • LN_F16(value: F16): F16
  • LN_F32(value: F32): F32
  • LN_F64(value: F64): F64

LOG2

#log2
Float math3 functions

base-2 logarithm

  • LOG2_F16(value: F16): F16
  • LOG2_F32(value: F32): F32
  • LOG2_F64(value: F64): F64

LOG10

#log10
Float math3 functions

base-10 logarithm

  • LOG10_F16(value: F16): F16
  • LOG10_F32(value: F32): F32
  • LOG10_F64(value: F64): F64

SIN

#sin
Float math3 functions

sine (radians)

  • SIN_F16(value: F16): F16
  • SIN_F32(value: F32): F32
  • SIN_F64(value: F64): F64

COS

#cos
Float math3 functions

cosine (radians)

  • COS_F16(value: F16): F16
  • COS_F32(value: F32): F32
  • COS_F64(value: F64): F64

TAN

#tan
Float math3 functions

tangent (radians)

  • TAN_F16(value: F16): F16
  • TAN_F32(value: F32): F32
  • TAN_F64(value: F64): F64

ASIN

#asin
Float math3 functions

arcsine

  • ASIN_F16(value: F16): F16
  • ASIN_F32(value: F32): F32
  • ASIN_F64(value: F64): F64

ACOS

#acos
Float math3 functions

arccosine

  • ACOS_F16(value: F16): F16
  • ACOS_F32(value: F32): F32
  • ACOS_F64(value: F64): F64

ATAN

#atan
Float math3 functions

arctangent

  • ATAN_F16(value: F16): F16
  • ATAN_F32(value: F32): F32
  • ATAN_F64(value: F64): F64

SINH

#sinh
Float math3 functions

hyperbolic sine

  • SINH_F16(value: F16): F16
  • SINH_F32(value: F32): F32
  • SINH_F64(value: F64): F64

COSH

#cosh
Float math3 functions

hyperbolic cosine

  • COSH_F16(value: F16): F16
  • COSH_F32(value: F32): F32
  • COSH_F64(value: F64): F64

TANH

#tanh
Float math3 functions

hyperbolic tangent

  • TANH_F16(value: F16): F16
  • TANH_F32(value: F32): F32
  • TANH_F64(value: F64): F64

FLOOR

#floor
Float math3 functions

round toward negative infinity

  • FLOOR_F16(value: F16): F16
  • FLOOR_F32(value: F32): F32
  • FLOOR_F64(value: F64): F64

CEIL

#ceil
Float math3 functions

round toward positive infinity

  • CEIL_F16(value: F16): F16
  • CEIL_F32(value: F32): F32
  • CEIL_F64(value: F64): F64

ROUND

#round
Float math3 functions

round to nearest, half away from zero

  • ROUND_F16(value: F16): F16
  • ROUND_F32(value: F32): F32
  • ROUND_F64(value: F64): F64

ROUNDEVEN

#roundeven
Float math3 functions

round to nearest, half to even

  • ROUNDEVEN_F16(value: F16): F16
  • ROUNDEVEN_F32(value: F32): F32
  • ROUNDEVEN_F64(value: F64): F64

TRUNC

#trunc
Float math3 functions

round toward zero

  • TRUNC_F16(value: F16): F16
  • TRUNC_F32(value: F32): F32
  • TRUNC_F64(value: F64): F64

ATAN2

#atan2
Float math3 functions

angle of the point (b, a) - a is y, b is x

  • ATAN2_F16_F16(a: F16, b: F16): F16
  • ATAN2_F32_F32(a: F32, b: F32): F32
  • ATAN2_F64_F64(a: F64, b: F64): F64

HYPOT

#hypot
Float math3 functions

sqrt(a^2 + b^2) without intermediate overflow

  • HYPOT_F16_F16(a: F16, b: F16): F16
  • HYPOT_F32_F32(a: F32, b: F32): F32
  • HYPOT_F64_F64(a: F64, b: F64): F64

COPYSIGN

#copysign
Float math3 functions

a's magnitude with b's sign

  • COPYSIGN_F16_F16(a: F16, b: F16): F16
  • COPYSIGN_F32_F32(a: F32, b: F32): F32
  • COPYSIGN_F64_F64(a: F64, b: F64): F64

FMA

#fma
Float math3 functions

a * b + c, rounded once

  • FMA_F16_F16_F16(a: F16, b: F16, c: F16): F16
  • FMA_F32_F32_F32(a: F32, b: F32, c: F32): F32
  • FMA_F64_F64_F64(a: F64, b: F64, c: F64): F64

ISNAN

#isnan
Float math3 functions

value is NaN

  • ISNAN_F16(value: F16): Boolean
  • ISNAN_F32(value: F32): Boolean
  • ISNAN_F64(value: F64): Boolean

ISINF

#isinf
Float math3 functions

value is positive or negative infinity

  • ISINF_F16(value: F16): Boolean
  • ISINF_F32(value: F32): Boolean
  • ISINF_F64(value: F64): Boolean

BITCAST

#bitcast
Float math6 functions

reinterpret the raw IEEE-754 bits, same width, no conversion

  • BITCAST_F16_U16(value: F16): U16
  • BITCAST_F32_U32(value: F32): U32
  • BITCAST_U16_F16(value: U16): F16
  • BITCAST_U32_F32(value: U32): F32
  • BITCAST_F64_U64(value: F64): U64
  • BITCAST_U64_F64(value: U64): F64

Boolean

AND

#and
Boolean1 functions

a and b

  • AND_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Boolean

OR

#or
Boolean1 functions

a or b

  • OR_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Boolean

XOR

#xor
Boolean1 functions

a xor b

  • XOR_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Boolean

IFF

#iff
Boolean1 functions

a iff b

  • IFF_BOOLEAN_BOOLEAN(a: Boolean, b: Boolean): Boolean

NOT

#not
Boolean1 functions

not a

  • NOT_BOOLEAN(value: Boolean): Boolean