module numpy.util¶
Source: stdlib/numpy/util.codon
AxisError¶
Magic methods¶
__init__(self, message: str = "")¶
TooHardError¶
Magic methods¶
__init__(self, message: str = "")¶
tuple_get(tup, idx)¶
tuple_set(tup, idx, elm, init = 0)¶
tuple_add(tup, idx, inc, init = 0)¶
tuple_delete(tup, idx, init = 0)¶
tuple_insert(tup, idx, elm, init = 0)¶
tuple_swap(tup, idx1, idx2, init = 0)¶
tuple_perm(tup, perm)¶
tuple_perm_inv(perm)¶
tuple_apply(fn, tup1, tup2)¶
tuple_insert_tuple(tup, idx, ins, init = 0)¶
count(shape)¶
tuple_range(n: Literal[int])¶
tuple_equal(t1, t2)¶
broadcast(shape1, shape2)¶
normalize_index(idx: int, axis: int, n: int)¶
normalize_axis_index(axis: int, ndim: int, prefix: str = "")¶
has_duplicate(t)¶
normalize_axis_tuple(axis, ndim: int, argname: str = "", allow_duplicates: bool = False)¶
reconstruct_index(t1, t2, mask)¶
index_to_coords(index: int, limits)¶
index_to_fcoords(index: int, limits)¶
coords_to_index(coords: S, limits: S, S: type)¶
coords_to_findex(coords: S, limits: S, S: type)¶
sort(p: Ptr[T], n: int, key, T: type)¶
sort_by_stride(shape, strides)¶
median(arr, n: int)¶
multirange(limits)¶
fmultirange(limits)¶
noop(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret {=D} %x
zero(T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret {=T} zeroinitializer
inf64() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret double 0x7FF0000000000000
inf32() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret float 0x7FF0000000000000
inf16() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret half 0x7FF0000000000000
inf(T: type)¶
nan64() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret double 0x7FF8000000000000
nan32() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret float 0x7FF8000000000000
nan16() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret half 0x7FF8000000000000
nan(T: type)¶
minnum64() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret double 0x10000000000000
minnum32() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret float 0x3810000000000000
minnum16() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret half 0xHFBFF
minnum(T: type)¶
maxnum64() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret double 0x7FEFFFFFFFFFFFFF
maxnum32() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret float 0x47EFFFFFE0000000
maxnum16() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret half 0xH7BFF
maxnum(T: type)¶
eps64() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret double 0x3CB0000000000000
eps32() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret float 0x3E80000000000000
eps16() @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
ret half 0xH1400
eps(T: type)¶
mantdig64()¶
mantdig32()¶
mantdig16()¶
mantdig(T: type)¶
maxexp64()¶
maxexp32()¶
maxexp16()¶
maxexp(T: type)¶
bitcast(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = bitcast {=T} %x to {=D}
ret {=D} %y
uitofp(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = uitofp {=T} %x to {=D}
ret {=D} %y
sitofp(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = sitofp {=T} %x to {=D}
ret {=D} %y
fptoui(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = fptoui {=T} %x to {=D}
ret {=D} %y
fptosi(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = fptosi {=T} %x to {=D}
ret {=D} %y
zext(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = zext {=T} %x to {=D}
ret {=D} %y
sext(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = sext {=T} %x to {=D}
ret {=D} %y
itrunc(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = trunc {=T} %x to {=D}
ret {=D} %y
fpext(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = fpext {=T} %x to {=D}
ret {=D} %y
fptrunc(x: T, D: type, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = fptrunc {=T} %x to {=D}
ret {=D} %y
fmin64(x: float, y: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.minimum.f64(double, double)
%z = call double @llvm.minimum.f64(double %x, double %y)
ret double %z
fmin32(x: float32, y: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.minimum.f32(float, float)
%z = call float @llvm.minimum.f32(float %x, float %y)
ret float %z
fmin16(x: float16, y: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.minimum.f16(half, half)
%z = call half @llvm.minimum.f16(half %x, half %y)
ret half %z
fmin(x, y)¶
fmax64(x: float, y: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.maximum.f64(double, double)
%z = call double @llvm.maximum.f64(double %x, double %y)
ret double %z
fmax32(x: float32, y: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.maximum.f32(float, float)
%z = call float @llvm.maximum.f32(float %x, float %y)
ret float %z
fmax16(x: float16, y: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.maximum.f16(half, half)
%z = call half @llvm.maximum.f16(half %x, half %y)
ret half %z
fmax(x, y)¶
fminnum64(x: float, y: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.minimumnum.f64(double, double)
%z = call double @llvm.minimumnum.f64(double %x, double %y)
ret double %z
fminnum32(x: float32, y: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.minimumnum.f32(float, float)
%z = call float @llvm.minimumnum.f32(float %x, float %y)
ret float %z
fminnum16(x: float16, y: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.minimumnum.f16(half, half)
%z = call half @llvm.minimumnum.f16(half %x, half %y)
ret half %z
fminnum(x, y)¶
fmaxnum64(x: float, y: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.maximumnum.f64(double, double)
%z = call double @llvm.maximumnum.f64(double %x, double %y)
ret double %z
fmaxnum32(x: float32, y: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.maximumnum.f32(float, float)
%z = call float @llvm.maximumnum.f32(float %x, float %y)
ret float %z
fmaxnum16(x: float16, y: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.maximumnum.f16(half, half)
%z = call half @llvm.maximumnum.f16(half %x, half %y)
ret half %z
fmaxnum(x, y)¶
bswap(x: T, T: type) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare {=T} @llvm.bswap.{=T}({=T})
%y = call {=T} @llvm.bswap.{=T}({=T} %x)
ret {=T} %y
isinf64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.fabs.f64(double)
%a = call double @llvm.fabs.f64(double %x)
%y = fcmp oeq double %a, 0x7FF0000000000000
%z = zext i1 %y to i8
ret i8 %z
isinf32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.fabs.f32(float)
%a = call float @llvm.fabs.f32(float %x)
%y = fcmp oeq float %a, 0x7FF0000000000000
%z = zext i1 %y to i8
ret i8 %z
isinf16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.fabs.f16(half)
%a = call half @llvm.fabs.f16(half %x)
%y = fcmp oeq half %a, 0x7FF0000000000000
%z = zext i1 %y to i8
ret i8 %z
isinf(x)¶
isnan64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = fcmp uno double %x, 0.000000e+00
%z = zext i1 %y to i8
ret i8 %z
isnan32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = fcmp uno float %x, 0.000000e+00
%z = zext i1 %y to i8
ret i8 %z
isnan16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%y = fcmp uno half %x, 0.000000e+00
%z = zext i1 %y to i8
ret i8 %z
isnan(x)¶
signbit64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%n = bitcast double %x to i64
%s = icmp slt i64 %n, 0
%b = zext i1 %s to i8
ret i8 %b
signbit32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%n = bitcast float %x to i32
%s = icmp slt i32 %n, 0
%b = zext i1 %s to i8
ret i8 %b
signbit16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%n = bitcast half %x to i16
%s = icmp slt i16 %n, 0
%b = zext i1 %s to i8
ret i8 %b
signbit(x)¶
fabs64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.fabs.f64(double)
%y = call double @llvm.fabs.f64(double %x)
ret double %y
fabs32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.fabs.f32(float)
%y = call float @llvm.fabs.f32(float %x)
ret float %y
fabs16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.fabs.f16(half)
%y = call half @llvm.fabs.f16(half %x)
ret half %y
fabs(x)¶
isfinite64(x: float)¶
isfinite32(x: float32)¶
isfinite16(x: float16)¶
isfinite(x)¶
rint64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.rint.f64(double)
%y = call double @llvm.rint.f64(double %x)
ret double %y
rint32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.rint.f32(float)
%y = call float @llvm.rint.f32(float %x)
ret float %y
rint16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.rint.f16(half)
%y = call half @llvm.rint.f16(half %x)
ret half %y
rint(x)¶
floor64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.floor.f64(double)
%y = call double @llvm.floor.f64(double %x)
ret double %y
floor32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.floor.f32(float)
%y = call float @llvm.floor.f32(float %x)
ret float %y
floor16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.floor.f16(half)
%y = call half @llvm.floor.f16(half %x)
ret half %y
floor(x)¶
ceil64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.ceil.f64(double)
%y = call double @llvm.ceil.f64(double %x)
ret double %y
ceil32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.ceil.f32(float)
%y = call float @llvm.ceil.f32(float %x)
ret float %y
ceil16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.ceil.f16(half)
%y = call half @llvm.ceil.f16(half %x)
ret half %y
ceil(x)¶
trunc64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.trunc.f64(double)
%y = call double @llvm.trunc.f64(double %x)
ret double %y
trunc32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.trunc.f32(float)
%y = call float @llvm.trunc.f32(float %x)
ret float %y
trunc16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.trunc.f16(half)
%y = call half @llvm.trunc.f16(half %x)
ret half %y
trunc(x)¶
exp64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.exp.f64(double)
%y = call double @llvm.exp.f64(double %x)
ret double %y
exp32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.exp.f32(float)
%y = call float @llvm.exp.f32(float %x)
ret float %y
exp16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.exp.f16(half)
%y = call half @llvm.exp.f16(half %x)
ret half %y
exp(x)¶
exp2_64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.exp2.f64(double)
%y = call double @llvm.exp2.f64(double %x)
ret double %y
exp2_32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.exp2.f32(float)
%y = call float @llvm.exp2.f32(float %x)
ret float %y
exp2_16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.exp2.f16(half)
%y = call half @llvm.exp2.f16(half %x)
ret half %y
exp2(x)¶
expm1_64(x: float)¶
expm1_32(x: float32)¶
expm1(x)¶
log64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.log.f64(double)
%y = call double @llvm.log.f64(double %x)
ret double %y
log32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.log.f32(float)
%y = call float @llvm.log.f32(float %x)
ret float %y
log16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.log.f16(half)
%y = call half @llvm.log.f16(half %x)
ret half %y
log(x)¶
log2_64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.log2.f64(double)
%y = call double @llvm.log2.f64(double %x)
ret double %y
log2_32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.log2.f32(float)
%y = call float @llvm.log2.f32(float %x)
ret float %y
log2_16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.log2.f16(half)
%y = call half @llvm.log2.f16(half %x)
ret half %y
log2(x)¶
log10_64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.log10.f64(double)
%y = call double @llvm.log10.f64(double %x)
ret double %y
log10_32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.log10.f32(float)
%y = call float @llvm.log10.f32(float %x)
ret float %y
log10_16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.log10.f16(half)
%y = call half @llvm.log10.f16(half %x)
ret half %y
log10(x)¶
log1p64(x: float)¶
log1p32(x: float32)¶
log1p(x)¶
sqrt64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.sqrt.f64(double)
%y = call double @llvm.sqrt.f64(double %x)
ret double %y
sqrt32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.sqrt.f32(float)
%y = call float @llvm.sqrt.f32(float %x)
ret float %y
sqrt16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.sqrt.f16(half)
%y = call half @llvm.sqrt.f16(half %x)
ret half %y
sqrt(x)¶
cbrt64(x: float)¶
cbrt32(x: float32)¶
cbrt(x)¶
sin64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.sin.f64(double)
%y = call double @llvm.sin.f64(double %x)
ret double %y
sin32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.sin.f32(float)
%y = call float @llvm.sin.f32(float %x)
ret float %y
sin16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.sin.f16(half)
%y = call half @llvm.sin.f16(half %x)
ret half %y
sin(x)¶
cos64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.cos.f64(double)
%y = call double @llvm.cos.f64(double %x)
ret double %y
cos32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.cos.f32(float)
%y = call float @llvm.cos.f32(float %x)
ret float %y
cos16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.cos.f16(half)
%y = call half @llvm.cos.f16(half %x)
ret half %y
cos(x)¶
tan64(x: float)¶
tan32(x: float32)¶
tan(x)¶
asin64(x: float)¶
asin32(x: float32)¶
asin(x)¶
acos64(x: float)¶
acos32(x: float32)¶
acos(x)¶
atan64(x: float)¶
atan32(x: float32)¶
atan(x)¶
sinh64(x: float)¶
sinh32(x: float32)¶
sinh(x)¶
cosh64(x: float)¶
cosh32(x: float32)¶
cosh(x)¶
tanh64(x: float)¶
tanh32(x: float32)¶
tanh(x)¶
asinh64(x: float)¶
asinh32(x: float32)¶
asinh(x)¶
acosh64(x: float)¶
acosh32(x: float32)¶
acosh(x)¶
atanh64(x: float)¶
atanh32(x: float32)¶
atanh(x)¶
atan2_64(x: float, y: float)¶
atan2_32(x: float32, y: float32)¶
atan2(x, y)¶
copysign64(x: float, y: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.copysign.f64(double, double)
%z = call double @llvm.copysign.f64(double %x, double %y)
ret double %z
copysign32(x: float32, y: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.copysign.f32(float, float)
%z = call float @llvm.copysign.f32(float %x, float %y)
ret float %z
copysign16(x: float16, y: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.copysign.f16(half, half)
%z = call half @llvm.copysign.f16(half %x, half %y)
ret half %z
copysign(x, y)¶
pow64(x: float, y: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.pow.f64(double, double)
%z = call double @llvm.pow.f64(double %x, double %y)
ret double %z
pow32(x: float32, y: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.pow.f32(float, float)
%z = call float @llvm.pow.f32(float %x, float %y)
ret float %z
pow16(x: float16, y: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare half @llvm.pow.f16(half, half)
%z = call half @llvm.pow.f16(half %x, half %y)
ret half %z
pow(x, y)¶
frexp64(x: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare { double, i32 } @llvm.frexp.f64(double)
%y = call { double, i32 } @llvm.frexp.f64(double %x)
%y0 = extractvalue { double, i32 } %y, 0
%y1 = extractvalue { double, i32 } %y, 1
%z1 = sext i32 %y1 to i64
%r0 = insertvalue { double, i64 } undef, double %y0, 0
%r1 = insertvalue { double, i64 } %r0, i64 %z1, 1
ret { double, i64 } %r1
frexp32(x: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare { float, i32 } @llvm.frexp.f32(float)
%y = call { float, i32 } @llvm.frexp.f32(float %x)
%y0 = extractvalue { float, i32 } %y, 0
%y1 = extractvalue { float, i32 } %y, 1
%z1 = sext i32 %y1 to i64
%r0 = insertvalue { float, i64 } undef, float %y0, 0
%r1 = insertvalue { float, i64 } %r0, i64 %z1, 1
ret { float, i64 } %r1
frexp16(x: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare { half, i32 } @llvm.frexp.f16(half)
%y = call { half, i32 } @llvm.frexp.f16(half %x)
%y0 = extractvalue { half, i32 } %y, 0
%y1 = extractvalue { half, i32 } %y, 1
%z1 = sext i32 %y1 to i64
%r0 = insertvalue { half, i64 } undef, half %y0, 0
%r1 = insertvalue { half, i64 } %r0, i64 %z1, 1
ret { half, i64 } %r1
frexp(x)¶
ldexp64(x: float, exp: int) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare double @llvm.ldexp.f64(double, i32)
%e = trunc i64 %exp to i32
%y = call double @llvm.ldexp.f64(double %x, i32 %e)
ret double %y
ldexp32(x: float32, exp: int) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
declare float @llvm.ldexp.f32(float, i32)
%e = trunc i64 %exp to i32
%y = call float @llvm.ldexp.f32(float %x, i32 %e)
ret float %y
ldexp16(x: float16, exp: int)¶
ldexp(x, exp: int)¶
LOGE2 = 0.693147180559945309417232121458176568¶
LOGE10 = 2.302585092994045684017991454684364208¶
LOG2E = 1.442695040888963407359924681001892137¶
LOG10E = 0.434294481903251827651128918916605082¶
SQRT2 = 1.414213562373095048801688724209698079¶
PI = 3.141592653589793238462643383279502884¶
PI_2 = 1.570796326794896619231321691639751442¶
E = 2.718281828459045235360287471352662498¶
logaddexp64(x: float, y: float)¶
logaddexp32(x: float32, y: float32)¶
logaddexp(x, y)¶
logaddexp2_64(x: float, y: float)¶
logaddexp2_32(x: float32, y: float32)¶
logaddexp2(x, y)¶
hypot64(x: float, y: float)¶
hypot32(x: float32, y: float32)¶
hypot(x, y)¶
modf64(x: float)¶
modf32(x: float32)¶
modf16(x: float16)¶
modf(x)¶
nextafter64(x: float, y: float)¶
nextafter32(x: float32, y: float32)¶
nextafter16(x: float16, y: float16)¶
nextafter(x, y)¶
cdiv_int(x: Int[N], y: Int[N], N: Literal[int]) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%z = sdiv i{=N} %x, %y
ret i{=N} %z
cdiv_int(x: int, y: int) @overload Function is overloaded @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%z = sdiv i64 %x, %y
ret i64 %z
cmod_int(x: Int[N], y: Int[N], N: Literal[int]) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%z = srem i{=N} %x, %y
ret i{=N} %z
cmod_int(x: int, y: int) @overload Function is overloaded @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%z = srem i64 %x, %y
ret i64 %z
pydiv(x: Int[N], y: Int[N], N: Literal[int])¶
pydiv(x: int, y: int) @overload Function is overloaded ¶
pymod(x: Int[N], y: Int[N], N: Literal[int])¶
pymod(x: int, y: int) @overload Function is overloaded ¶
cdiv64(x: float, y: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%z = fdiv double %x, %y
ret double %z
cdiv32(x: float32, y: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%z = fdiv float %x, %y
ret float %z
cdiv16(x: float16, y: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%z = fdiv half %x, %y
ret half %z
cdiv(x, y)¶
cmod64(x: float, y: float) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%z = frem double %x, %y
ret double %z
cmod32(x: float32, y: float32) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%z = frem float %x, %y
ret float %z
cmod16(x: float16, y: float16) @pure Function has no side effects and returns same value for same inputs @llvm Function is implemented with inline LLVM IR ¶
%z = frem half %x, %y
ret half %z