abs :: (x: $T) -> T

abs_fast :: (val: f32) -> f32

abs_fast :: (val: f64) -> f64

acos :: (t: f32) -> f32

acosh :: (t: $T) -> T

asin :: (t: f32) -> f32

asinh :: (t: $T) -> T

atan :: (t: f32) -> f32

atan2 :: (t: f32) -> f32

atanh :: (t: $T) -> T

ceil :: (val: f32) -> f32

ceil :: (val: f64) -> f64

choose :: (n: $T, k: T) -> T

clamp :: (v: $T, lo: T, hi: T) -> T

clz :: (val: i32) -> i32

clz :: (val: i64) -> i64

copysign_poly :: (x: $T, y: T) -> T

copysign :: (lhs: f32, rhs: f32) -> f32

copysign :: (lhs: f64, rhs: f64) -> f64

copysign :: (x: $T, y: T) -> T

cos :: (t: f32) -> f32

cosh :: (t: $T) -> T

ctz :: (val: i32) -> i32

ctz :: (val: i64) -> i64

exp :: (p: $T) -> T

floor :: (val: f32) -> f32

floor :: (val: f64) -> f64

fmod :: (x: f64, y: f64) -> f64

fmod :: (x: f32, y: f32) -> f32

gcd :: (a: $T, b: T) -> T

ilog2 :: (a: u32) -> u32

ilog2 :: (a: u64) -> u64

is_inf :: (x: f32) -> bool

is_inf :: (x: f64) -> bool

is_nan :: (x: f32) -> bool

is_nan :: (x: f64) -> bool

lcm :: (a: $T, b: T) -> T

lerp :: (t: f32, a: $T, b: T) -> T

ln :: (a: f32) -> f32

log :: (a: $T, base: $R) -> T

max :: (a: $T, b: T) -> T

max_fast :: (lhs: f32, rhs: f32) -> f32

max_fast :: (lhs: f64, rhs: f64) -> f64

min :: (a: $T, b: T) -> T

min_fast :: (lhs: f32, rhs: f32) -> f32

min_fast :: (lhs: f64, rhs: f64) -> f64

nearest :: (val: f32) -> f32

nearest :: (val: f64) -> f64

popcnt :: (val: i32) -> i32

popcnt :: (val: i64) -> i64

pow :: (base: $T, p: i32) -> T

pow :: (base: $T, p: i64) -> T

pow :: (base: $T, p: T) -> T

power_mod :: (base: u32, exp: u32, mod: u32) -> u32

rotate_left :: (lhs: i32, rhs: i32) -> i32

rotate_left :: (lhs: i64, rhs: i64) -> i64

rotate_right :: (lhs: i32, rhs: i32) -> i32

rotate_right :: (lhs: i64, rhs: i64) -> i64

sign :: (x: $T) -> T

sin :: (t: f32) -> f32

sinh :: (t: $T) -> T

sqrt :: (val: f32) -> f32

sqrt :: (val: f64) -> f64

sqrt :: (x: $T) -> T

sqrt_poly :: (x: $T) -> T

tanh :: (t: $T) -> T

trunc :: (val: f32) -> f32

trunc :: (val: f64) -> f64