numpy.util

class AxisError

class AxisError

View complete class API →

Constructors 1

__init__

__init__(self, message: str = "")

class TooHardError

class TooHardError

View complete class API →

Constructors 1

__init__

__init__(self, message: str = "")

function tuple_get

tuple_get(tup, idx)

function tuple_set

tuple_set(tup, idx, elm, init = 0)

function tuple_add

tuple_add(tup, idx, inc, init = 0)

function tuple_delete

tuple_delete(tup, idx, init = 0)

function tuple_insert

tuple_insert(tup, idx, elm, init = 0)

function tuple_swap

tuple_swap(tup, idx1, idx2, init = 0)

function tuple_perm

tuple_perm(tup, perm)

function tuple_perm_inv

tuple_perm_inv(perm)

function tuple_apply

tuple_apply(fn, tup1, tup2)

function tuple_insert_tuple

tuple_insert_tuple(tup, idx, ins, init = 0)

function count

count(shape)

function tuple_range

tuple_range(n: Literal[int])

function tuple_equal

tuple_equal(t1, t2)

function broadcast

broadcast(shape1, shape2)

function normalize_index

normalize_index(idx: int, axis: int, n: int)

function normalize_axis_index

normalize_axis_index(axis: int, ndim: int, prefix: str = "")

function has_duplicate

has_duplicate(t)

function normalize_axis_tuple

normalize_axis_tuple(axis, ndim: int, argname: str = "", allow_duplicates: bool = False)

function reconstruct_index

reconstruct_index(t1, t2, mask)

function index_to_coords

index_to_coords(index: int, limits)

function index_to_fcoords

index_to_fcoords(index: int, limits)

function coords_to_index

coords_to_index(coords: S, limits: S, S: type)

function coords_to_findex

coords_to_findex(coords: S, limits: S, S: type)

function sort

sort(p: Ptr[T], n: int, key, T: type)

function sort_by_stride

sort_by_stride(shape, strides)

function median

median(arr, n: int)

function multirange

multirange(limits)

function fmultirange

fmultirange(limits)

function noop

@pure @llvm

noop(x: T, D: type, T: type)

ret {=D} %x

function zero

@pure @llvm

zero(T: type)

ret {=T} zeroinitializer

function inf64

@pure @llvm

inf64()

ret double 0x7FF0000000000000

function inf32

@pure @llvm

inf32()

ret float 0x7FF0000000000000

function inf16

@pure @llvm

inf16()

ret half 0x7FF0000000000000

function inf

inf(T: type)

function nan64

@pure @llvm

nan64()

ret double 0x7FF8000000000000

function nan32

@pure @llvm

nan32()

ret float 0x7FF8000000000000

function nan16

@pure @llvm

nan16()

ret half 0x7FF8000000000000

function nan

nan(T: type)

function minnum64

@pure @llvm

minnum64()

ret double 0x10000000000000

function minnum32

@pure @llvm

minnum32()

ret float 0x3810000000000000

function minnum16

@pure @llvm

minnum16()

ret half 0xHFBFF

function minnum

minnum(T: type)

function maxnum64

@pure @llvm

maxnum64()

ret double 0x7FEFFFFFFFFFFFFF

function maxnum32

@pure @llvm

maxnum32()

ret float 0x47EFFFFFE0000000

function maxnum16

@pure @llvm

maxnum16()

ret half 0xH7BFF

function maxnum

maxnum(T: type)

function eps64

@pure @llvm

eps64()

ret double 0x3CB0000000000000

function eps32

@pure @llvm

eps32()

ret float 0x3E80000000000000

function eps16

@pure @llvm

eps16()

ret half 0xH1400

function eps

eps(T: type)

function mantdig64

mantdig64()

function mantdig32

mantdig32()

function mantdig16

mantdig16()

function mantdig

mantdig(T: type)

function maxexp64

maxexp64()

function maxexp32

maxexp32()

function maxexp16

maxexp16()

function maxexp

maxexp(T: type)

function bitcast

@pure @llvm

bitcast(x: T, D: type, T: type)

%y = bitcast {=T} %x to {=D}
ret {=D} %y

function uitofp

@pure @llvm

uitofp(x: T, D: type, T: type)

%y = uitofp {=T} %x to {=D}
ret {=D} %y

function sitofp

@pure @llvm

sitofp(x: T, D: type, T: type)

%y = sitofp {=T} %x to {=D}
ret {=D} %y

function fptoui

@pure @llvm

fptoui(x: T, D: type, T: type)

%y = fptoui {=T} %x to {=D}
ret {=D} %y

function fptosi

@pure @llvm

fptosi(x: T, D: type, T: type)

%y = fptosi {=T} %x to {=D}
ret {=D} %y

function zext

@pure @llvm

zext(x: T, D: type, T: type)

%y = zext {=T} %x to {=D}
ret {=D} %y

function sext

@pure @llvm

sext(x: T, D: type, T: type)

%y = sext {=T} %x to {=D}
ret {=D} %y

function itrunc

@pure @llvm

itrunc(x: T, D: type, T: type)

%y = trunc {=T} %x to {=D}
ret {=D} %y

function fpext

@pure @llvm

fpext(x: T, D: type, T: type)

%y = fpext {=T} %x to {=D}
ret {=D} %y

function fptrunc

@pure @llvm

fptrunc(x: T, D: type, T: type)

%y = fptrunc {=T} %x to {=D}
ret {=D} %y

function fmin64

@pure @llvm

fmin64(x: float, y: float)

declare double @llvm.minimum.f64(double, double)
%z = call double @llvm.minimum.f64(double %x, double %y)
ret double %z

function fmin32

@pure @llvm

fmin32(x: float32, y: float32)

declare float @llvm.minimum.f32(float, float)
%z = call float @llvm.minimum.f32(float %x, float %y)
ret float %z

function fmin16

@pure @llvm

fmin16(x: float16, y: float16)

declare half @llvm.minimum.f16(half, half)
%z = call half @llvm.minimum.f16(half %x, half %y)
ret half %z

function fmin

fmin(x, y)

function fmax64

@pure @llvm

fmax64(x: float, y: float)

declare double @llvm.maximum.f64(double, double)
%z = call double @llvm.maximum.f64(double %x, double %y)
ret double %z

function fmax32

@pure @llvm

fmax32(x: float32, y: float32)

declare float @llvm.maximum.f32(float, float)
%z = call float @llvm.maximum.f32(float %x, float %y)
ret float %z

function fmax16

@pure @llvm

fmax16(x: float16, y: float16)

declare half @llvm.maximum.f16(half, half)
%z = call half @llvm.maximum.f16(half %x, half %y)
ret half %z

function fmax

fmax(x, y)

function fminnum64

@pure @llvm

fminnum64(x: float, y: float)

declare double @llvm.minimumnum.f64(double, double)
%z = call double @llvm.minimumnum.f64(double %x, double %y)
ret double %z

function fminnum32

@pure @llvm

fminnum32(x: float32, y: float32)

declare float @llvm.minimumnum.f32(float, float)
%z = call float @llvm.minimumnum.f32(float %x, float %y)
ret float %z

function fminnum16

@pure @llvm

fminnum16(x: float16, y: float16)

declare half @llvm.minimumnum.f16(half, half)
%z = call half @llvm.minimumnum.f16(half %x, half %y)
ret half %z

function fminnum

fminnum(x, y)

function fmaxnum64

@pure @llvm

fmaxnum64(x: float, y: float)

declare double @llvm.maximumnum.f64(double, double)
%z = call double @llvm.maximumnum.f64(double %x, double %y)
ret double %z

function fmaxnum32

@pure @llvm

fmaxnum32(x: float32, y: float32)

declare float @llvm.maximumnum.f32(float, float)
%z = call float @llvm.maximumnum.f32(float %x, float %y)
ret float %z

function fmaxnum16

@pure @llvm

fmaxnum16(x: float16, y: float16)

declare half @llvm.maximumnum.f16(half, half)
%z = call half @llvm.maximumnum.f16(half %x, half %y)
ret half %z

function fmaxnum

fmaxnum(x, y)

function bswap

@pure @llvm

bswap(x: T, T: type)

declare {=T} @llvm.bswap.{=T}({=T})
%y = call {=T} @llvm.bswap.{=T}({=T} %x)
ret {=T} %y

function isinf64

@pure @llvm

isinf64(x: float)

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

function isinf32

@pure @llvm

isinf32(x: float32)

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

function isinf16

@pure @llvm

isinf16(x: float16)

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

function isinf

isinf(x)

function isnan64

@pure @llvm

isnan64(x: float)

%y = fcmp uno double %x, 0.000000e+00
%z = zext i1 %y to i8
ret i8 %z

function isnan32

@pure @llvm

isnan32(x: float32)

%y = fcmp uno float %x, 0.000000e+00
%z = zext i1 %y to i8
ret i8 %z

function isnan16

@pure @llvm

isnan16(x: float16)

%y = fcmp uno half %x, 0.000000e+00
%z = zext i1 %y to i8
ret i8 %z

function isnan

isnan(x)

function signbit64

@pure @llvm

signbit64(x: float)

%n = bitcast double %x to i64
%s = icmp slt i64 %n, 0
%b = zext i1 %s to i8
ret i8 %b

function signbit32

@pure @llvm

signbit32(x: float32)

%n = bitcast float %x to i32
%s = icmp slt i32 %n, 0
%b = zext i1 %s to i8
ret i8 %b

function signbit16

@pure @llvm

signbit16(x: float16)

%n = bitcast half %x to i16
%s = icmp slt i16 %n, 0
%b = zext i1 %s to i8
ret i8 %b

function signbit

signbit(x)

function fabs64

@pure @llvm

fabs64(x: float)

declare double @llvm.fabs.f64(double)
%y = call double @llvm.fabs.f64(double %x)
ret double %y

function fabs32

@pure @llvm

fabs32(x: float32)

declare float @llvm.fabs.f32(float)
%y = call float @llvm.fabs.f32(float %x)
ret float %y

function fabs16

@pure @llvm

fabs16(x: float16)

declare half @llvm.fabs.f16(half)
%y = call half @llvm.fabs.f16(half %x)
ret half %y

function fabs

fabs(x)

function isfinite64

isfinite64(x: float)

function isfinite32

isfinite32(x: float32)

function isfinite16

isfinite16(x: float16)

function isfinite

isfinite(x)

function rint64

@pure @llvm

rint64(x: float)

declare double @llvm.rint.f64(double)
%y = call double @llvm.rint.f64(double %x)
ret double %y

function rint32

@pure @llvm

rint32(x: float32)

declare float @llvm.rint.f32(float)
%y = call float @llvm.rint.f32(float %x)
ret float %y

function rint16

@pure @llvm

rint16(x: float16)

declare half @llvm.rint.f16(half)
%y = call half @llvm.rint.f16(half %x)
ret half %y

function rint

rint(x)

function floor64

@pure @llvm

floor64(x: float)

declare double @llvm.floor.f64(double)
%y = call double @llvm.floor.f64(double %x)
ret double %y

function floor32

@pure @llvm

floor32(x: float32)

declare float @llvm.floor.f32(float)
%y = call float @llvm.floor.f32(float %x)
ret float %y

function floor16

@pure @llvm

floor16(x: float16)

declare half @llvm.floor.f16(half)
%y = call half @llvm.floor.f16(half %x)
ret half %y

function floor

floor(x)

function ceil64

@pure @llvm

ceil64(x: float)

declare double @llvm.ceil.f64(double)
%y = call double @llvm.ceil.f64(double %x)
ret double %y

function ceil32

@pure @llvm

ceil32(x: float32)

declare float @llvm.ceil.f32(float)
%y = call float @llvm.ceil.f32(float %x)
ret float %y

function ceil16

@pure @llvm

ceil16(x: float16)

declare half @llvm.ceil.f16(half)
%y = call half @llvm.ceil.f16(half %x)
ret half %y

function ceil

ceil(x)

function trunc64

@pure @llvm

trunc64(x: float)

declare double @llvm.trunc.f64(double)
%y = call double @llvm.trunc.f64(double %x)
ret double %y

function trunc32

@pure @llvm

trunc32(x: float32)

declare float @llvm.trunc.f32(float)
%y = call float @llvm.trunc.f32(float %x)
ret float %y

function trunc16

@pure @llvm

trunc16(x: float16)

declare half @llvm.trunc.f16(half)
%y = call half @llvm.trunc.f16(half %x)
ret half %y

function trunc

trunc(x)

function exp64

@pure @llvm

exp64(x: float)

declare double @llvm.exp.f64(double)
%y = call double @llvm.exp.f64(double %x)
ret double %y

function exp32

@pure @llvm

exp32(x: float32)

declare float @llvm.exp.f32(float)
%y = call float @llvm.exp.f32(float %x)
ret float %y

function exp16

@pure @llvm

exp16(x: float16)

declare half @llvm.exp.f16(half)
%y = call half @llvm.exp.f16(half %x)
ret half %y

function exp

exp(x)

function exp2_64

@pure @llvm

exp2_64(x: float)

declare double @llvm.exp2.f64(double)
%y = call double @llvm.exp2.f64(double %x)
ret double %y

function exp2_32

@pure @llvm

exp2_32(x: float32)

declare float @llvm.exp2.f32(float)
%y = call float @llvm.exp2.f32(float %x)
ret float %y

function exp2_16

@pure @llvm

exp2_16(x: float16)

declare half @llvm.exp2.f16(half)
%y = call half @llvm.exp2.f16(half %x)
ret half %y

function exp2

exp2(x)

function expm1_64

expm1_64(x: float)

function expm1_32

expm1_32(x: float32)

function expm1

expm1(x)

function log64

@pure @llvm

log64(x: float)

declare double @llvm.log.f64(double)
%y = call double @llvm.log.f64(double %x)
ret double %y

function log32

@pure @llvm

log32(x: float32)

declare float @llvm.log.f32(float)
%y = call float @llvm.log.f32(float %x)
ret float %y

function log16

@pure @llvm

log16(x: float16)

declare half @llvm.log.f16(half)
%y = call half @llvm.log.f16(half %x)
ret half %y

function log

log(x)

function log2_64

@pure @llvm

log2_64(x: float)

declare double @llvm.log2.f64(double)
%y = call double @llvm.log2.f64(double %x)
ret double %y

function log2_32

@pure @llvm

log2_32(x: float32)

declare float @llvm.log2.f32(float)
%y = call float @llvm.log2.f32(float %x)
ret float %y

function log2_16

@pure @llvm

log2_16(x: float16)

declare half @llvm.log2.f16(half)
%y = call half @llvm.log2.f16(half %x)
ret half %y

function log2

log2(x)

function log10_64

@pure @llvm

log10_64(x: float)

declare double @llvm.log10.f64(double)
%y = call double @llvm.log10.f64(double %x)
ret double %y

function log10_32

@pure @llvm

log10_32(x: float32)

declare float @llvm.log10.f32(float)
%y = call float @llvm.log10.f32(float %x)
ret float %y

function log10_16

@pure @llvm

log10_16(x: float16)

declare half @llvm.log10.f16(half)
%y = call half @llvm.log10.f16(half %x)
ret half %y

function log10

log10(x)

function log1p64

log1p64(x: float)

function log1p32

log1p32(x: float32)

function log1p

log1p(x)

function sqrt64

@pure @llvm

sqrt64(x: float)

declare double @llvm.sqrt.f64(double)
%y = call double @llvm.sqrt.f64(double %x)
ret double %y

function sqrt32

@pure @llvm

sqrt32(x: float32)

declare float @llvm.sqrt.f32(float)
%y = call float @llvm.sqrt.f32(float %x)
ret float %y

function sqrt16

@pure @llvm

sqrt16(x: float16)

declare half @llvm.sqrt.f16(half)
%y = call half @llvm.sqrt.f16(half %x)
ret half %y

function sqrt

sqrt(x)

function cbrt64

cbrt64(x: float)

function cbrt32

cbrt32(x: float32)

function cbrt

cbrt(x)

function sin64

@pure @llvm

sin64(x: float)

declare double @llvm.sin.f64(double)
%y = call double @llvm.sin.f64(double %x)
ret double %y

function sin32

@pure @llvm

sin32(x: float32)

declare float @llvm.sin.f32(float)
%y = call float @llvm.sin.f32(float %x)
ret float %y

function sin16

@pure @llvm

sin16(x: float16)

declare half @llvm.sin.f16(half)
%y = call half @llvm.sin.f16(half %x)
ret half %y

function sin

sin(x)

function cos64

@pure @llvm

cos64(x: float)

declare double @llvm.cos.f64(double)
%y = call double @llvm.cos.f64(double %x)
ret double %y

function cos32

@pure @llvm

cos32(x: float32)

declare float @llvm.cos.f32(float)
%y = call float @llvm.cos.f32(float %x)
ret float %y

function cos16

@pure @llvm

cos16(x: float16)

declare half @llvm.cos.f16(half)
%y = call half @llvm.cos.f16(half %x)
ret half %y

function cos

cos(x)

function tan64

tan64(x: float)

function tan32

tan32(x: float32)

function tan

tan(x)

function asin64

asin64(x: float)

function asin32

asin32(x: float32)

function asin

asin(x)

function acos64

acos64(x: float)

function acos32

acos32(x: float32)

function acos

acos(x)

function atan64

atan64(x: float)

function atan32

atan32(x: float32)

function atan

atan(x)

function sinh64

sinh64(x: float)

function sinh32

sinh32(x: float32)

function sinh

sinh(x)

function cosh64

cosh64(x: float)

function cosh32

cosh32(x: float32)

function cosh

cosh(x)

function tanh64

tanh64(x: float)

function tanh32

tanh32(x: float32)

function tanh

tanh(x)

function asinh64

asinh64(x: float)

function asinh32

asinh32(x: float32)

function asinh

asinh(x)

function acosh64

acosh64(x: float)

function acosh32

acosh32(x: float32)

function acosh

acosh(x)

function atanh64

atanh64(x: float)

function atanh32

atanh32(x: float32)

function atanh

atanh(x)

function atan2_64

atan2_64(x: float, y: float)

function atan2_32

atan2_32(x: float32, y: float32)

function atan2

atan2(x, y)

function copysign64

@pure @llvm

copysign64(x: float, y: float)

declare double @llvm.copysign.f64(double, double)
%z = call double @llvm.copysign.f64(double %x, double %y)
ret double %z

function copysign32

@pure @llvm

copysign32(x: float32, y: float32)

declare float @llvm.copysign.f32(float, float)
%z = call float @llvm.copysign.f32(float %x, float %y)
ret float %z

function copysign16

@pure @llvm

copysign16(x: float16, y: float16)

declare half @llvm.copysign.f16(half, half)
%z = call half @llvm.copysign.f16(half %x, half %y)
ret half %z

function copysign

copysign(x, y)

function pow64

@pure @llvm

pow64(x: float, y: float)

declare double @llvm.pow.f64(double, double)
%z = call double @llvm.pow.f64(double %x, double %y)
ret double %z

function pow32

@pure @llvm

pow32(x: float32, y: float32)

declare float @llvm.pow.f32(float, float)
%z = call float @llvm.pow.f32(float %x, float %y)
ret float %z

function pow16

@pure @llvm

pow16(x: float16, y: float16)

declare half @llvm.pow.f16(half, half)
%z = call half @llvm.pow.f16(half %x, half %y)
ret half %z

function pow

pow(x, y)

function frexp64

@pure @llvm

frexp64(x: float)

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

function frexp32

@pure @llvm

frexp32(x: float32)

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

function frexp16

@pure @llvm

frexp16(x: float16)

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

function frexp

frexp(x)

function ldexp64

@pure @llvm

ldexp64(x: float, exp: int)

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

function ldexp32

@pure @llvm

ldexp32(x: float32, exp: int)

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

function ldexp16

ldexp16(x: float16, exp: int)

function ldexp

ldexp(x, exp: int)

variable LOGE2

LOGE2 = 0.693147180559945309417232121458176568

variable LOGE10

LOGE10 = 2.302585092994045684017991454684364208

variable LOG2E

LOG2E = 1.442695040888963407359924681001892137

variable LOG10E

LOG10E = 0.434294481903251827651128918916605082

variable SQRT2

SQRT2 = 1.414213562373095048801688724209698079

variable PI

PI = 3.141592653589793238462643383279502884

variable PI_2

PI_2 = 1.570796326794896619231321691639751442

variable E

E = 2.718281828459045235360287471352662498

function logaddexp64

logaddexp64(x: float, y: float)

function logaddexp32

logaddexp32(x: float32, y: float32)

function logaddexp

logaddexp(x, y)

function logaddexp2_64

logaddexp2_64(x: float, y: float)

function logaddexp2_32

logaddexp2_32(x: float32, y: float32)

function logaddexp2

logaddexp2(x, y)

function hypot64

hypot64(x: float, y: float)

function hypot32

hypot32(x: float32, y: float32)

function hypot

hypot(x, y)

function modf64

modf64(x: float)

function modf32

modf32(x: float32)

function modf16

modf16(x: float16)

function modf

modf(x)

function nextafter64

nextafter64(x: float, y: float)

function nextafter32

nextafter32(x: float32, y: float32)

function nextafter16

nextafter16(x: float16, y: float16)

function nextafter

nextafter(x, y)

function cdiv_int

@pure @llvm

cdiv_int(x: Int[N], y: Int[N], N: Literal[int])

%z = sdiv i{=N} %x, %y
ret i{=N} %z

@overload

cdiv_int(x: int, y: int)

%z = sdiv i64 %x, %y
ret i64 %z

function cmod_int

@pure @llvm

cmod_int(x: Int[N], y: Int[N], N: Literal[int])

%z = srem i{=N} %x, %y
ret i{=N} %z

@overload

cmod_int(x: int, y: int)

%z = srem i64 %x, %y
ret i64 %z

function pydiv

pydiv(x: Int[N], y: Int[N], N: Literal[int])

@overload

pydiv(x: int, y: int)

function pymod

pymod(x: Int[N], y: Int[N], N: Literal[int])

@overload

pymod(x: int, y: int)

function cdiv64

@pure @llvm

cdiv64(x: float, y: float)

%z = fdiv double %x, %y
ret double %z

function cdiv32

@pure @llvm

cdiv32(x: float32, y: float32)

%z = fdiv float %x, %y
ret float %z

function cdiv16

@pure @llvm

cdiv16(x: float16, y: float16)

%z = fdiv half %x, %y
ret half %z

function cdiv

cdiv(x, y)

function cmod64

@pure @llvm

cmod64(x: float, y: float)

%z = frem double %x, %y
ret double %z

function cmod32

@pure @llvm

cmod32(x: float32, y: float32)

%z = frem float %x, %y
ret float %z

function cmod16

@pure @llvm

cmod16(x: float16, y: float16)

%z = frem half %x, %y
ret half %z

function cmod

cmod(x, y)

function pyfmod

pyfmod(x, y)

function i0_64

i0_64(x: float)

function i0_32

i0_32(x: float32)

function i0

i0(x)

function call_vectorized_loop

call_vectorized_loop(in1: Ptr[T], is1: int, in2: Ptr[T], is2: int, out: Ptr, os: int, n: int, func: Literal[str], T: type)

function isint

isint(X: type)

function isfloat

isfloat(X: type)

function iscomplex

iscomplex(X: type)

function isinexact

isinexact(X: type)

function sizeof

sizeof(X: type)

function atomic

atomic(X: type)

function free

free(p: Ptr[T], T: type)

function realloc

realloc(p: Ptr[T], newsize: int, oldsize: int, T: type)

function strides

strides(shape, forder: bool, X: type)

function cast

cast(x, T: type)

function coerce

coerce(T1: type, T2: type)

function op_types

op_types(T1: type, T2: type)

function to_float

to_float(x)

function str_to_dtype

str_to_dtype(s: Literal[str])

function dtype_to_str

dtype_to_str(dtype: type, include_byteorder: bool = True)