ExCubecl.NIF (ExCubecl v0.1.0)

Copy Markdown View Source

NIF stubs for the CubeCL Rust backend.

Each function delegates to the Rust NIF implementation. If the NIF is not loaded, returns :erlang.nif_error(:nif_not_loaded).

Summary

Functions

abs_tensor(a)
acos(a)
acosh(a)
add(a, b)
all_tensor(buf, opts)
any_tensor(buf, opts)
argmax_tensor(buf, opts)
argmin_tensor(buf, opts)
argsort_tensor(buf, opts)
as_type_tensor(buf, dtype_str)
asin(a)
asinh(a)
atan2(a, b)
atan(a)
atanh(a)
bitcast_tensor(buf, dtype_str)
bitwise_and(a, b)
bitwise_not(a)
bitwise_or(a, b)
bitwise_xor(a, b)
broadcast_tensor(buf, target_shape, axes)
cbrt(a)
ceil_tensor(a)
clip_tensor(buf, min, max)
concatenate_tensors(bufs, axis)
conjugate(a)
constant_tensor(shape, dtype_str, value)
conv(input, kernel, opts)
cos(a)
cosh(a)
count_leading_zeros(a)
deallocate_tensor(ref)
divide(a, b)
dot_tensor(a, c1, b1, b, c2, b2)
equal(a, b)
erf(a)
erf_inv(a)
erfc(a)
exp(a)
expm1(a)
eye_tensor(shape, dtype_str)
fft_tensor(buf, opts)
floor_tensor(a)
gather(input, indices, opts)
greater(a, b)
greater_equal(a, b)
ifft_tensor(buf, opts)
imag(a)
indexed_add(t, idx, upd, opts)
indexed_put(t, idx, upd, opts)
iota_tensor(shape, dtype_str, axis)
is_infinity(a)
is_nan(a)
left_shift(a, b)
less(a, b)
less_equal(a, b)
load_nifs()
log1p(a)
log(a)
logical_and(a, b)
logical_or(a, b)
logical_xor(a, b)
max_tensor(a, b)
min_tensor(a, b)
multiply(a, b)
negate(a)
new_tensor(data, shape, dtype)
not_equal(a, b)
pad_tensor(buf, pad_value, padding_config)
population_count(a)
pow(a, b)
product_tensor(buf, opts)
put_slice(t, starts, slice)
quotient(a, b)
read_tensor(ref)
real(a)
reduce(t, acc, opts, fun)
reduce_max(buf, opts)
reduce_min(buf, opts)
relu(a)
remainder(a, b)
reshape_tensor(buf, new_shape)
reverse_tensor(buf, axes)
right_shift(a, b)
round_tensor(a)
rsqrt(a)
select_tensor(pred, on_true, on_false)
sigmoid(a)
sign_tensor(a)
sin(a)
sinh(a)
slice_tensor(buf, starts, lengths, strides)
sort_tensor(buf, opts)
sqrt(a)
squeeze_tensor(buf, axes)
stack_tensors(bufs, axis)
subtract(a, b)
sum_tensor(buf, opts)
tan(a)
tanh(a)
tensor_dtype(ref)
tensor_shape(ref)
transpose_tensor(buf, axes)
triangular_solve(a, b, opts)
window_max(buf, shape, opts)
window_min(buf, shape, opts)
window_product(buf, shape, opts)
window_reduce(t, acc, shape, opts, fun)
window_scatter_max(t, src, init, shape, opts)
window_scatter_min(t, src, init, shape, opts)
window_sum(buf, shape, opts)

Functions

abs_tensor(a)

@spec abs_tensor(reference()) :: {:ok, reference()} | {:error, term()}

acos(a)

@spec acos(reference()) :: {:ok, reference()} | {:error, term()}

acosh(a)

@spec acosh(reference()) :: {:ok, reference()} | {:error, term()}

add(a, b)

@spec add(reference(), reference()) :: {:ok, reference()} | {:error, term()}

all_tensor(buf, opts)

@spec all_tensor(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

any_tensor(buf, opts)

@spec any_tensor(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

argmax_tensor(buf, opts)

@spec argmax_tensor(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

argmin_tensor(buf, opts)

@spec argmin_tensor(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

argsort_tensor(buf, opts)

@spec argsort_tensor(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

as_type_tensor(buf, dtype_str)

@spec as_type_tensor(reference(), String.t()) :: {:ok, reference()} | {:error, term()}

asin(a)

@spec asin(reference()) :: {:ok, reference()} | {:error, term()}

asinh(a)

@spec asinh(reference()) :: {:ok, reference()} | {:error, term()}

atan2(a, b)

@spec atan2(reference(), reference()) :: {:ok, reference()} | {:error, term()}

atan(a)

@spec atan(reference()) :: {:ok, reference()} | {:error, term()}

atanh(a)

@spec atanh(reference()) :: {:ok, reference()} | {:error, term()}

bitcast_tensor(buf, dtype_str)

@spec bitcast_tensor(reference(), String.t()) :: {:ok, reference()} | {:error, term()}

bitwise_and(a, b)

@spec bitwise_and(reference(), reference()) :: {:ok, reference()} | {:error, term()}

bitwise_not(a)

@spec bitwise_not(reference()) :: {:ok, reference()} | {:error, term()}

bitwise_or(a, b)

@spec bitwise_or(reference(), reference()) :: {:ok, reference()} | {:error, term()}

bitwise_xor(a, b)

@spec bitwise_xor(reference(), reference()) :: {:ok, reference()} | {:error, term()}

broadcast_tensor(buf, target_shape, axes)

@spec broadcast_tensor(reference(), [non_neg_integer()], [non_neg_integer()]) ::
  {:ok, reference()} | {:error, term()}

cbrt(a)

@spec cbrt(reference()) :: {:ok, reference()} | {:error, term()}

ceil_tensor(a)

@spec ceil_tensor(reference()) :: {:ok, reference()} | {:error, term()}

clip_tensor(buf, min, max)

@spec clip_tensor(reference(), reference(), reference()) ::
  {:ok, reference()} | {:error, term()}

concatenate_tensors(bufs, axis)

@spec concatenate_tensors([reference()], non_neg_integer()) ::
  {:ok, reference()} | {:error, term()}

conjugate(a)

@spec conjugate(reference()) :: {:ok, reference()} | {:error, term()}

constant_tensor(shape, dtype_str, value)

@spec constant_tensor([non_neg_integer()], String.t(), float()) ::
  {:ok, reference()} | {:error, term()}

conv(input, kernel, opts)

@spec conv(reference(), reference(), keyword()) ::
  {:ok, reference()} | {:error, term()}

cos(a)

@spec cos(reference()) :: {:ok, reference()} | {:error, term()}

cosh(a)

@spec cosh(reference()) :: {:ok, reference()} | {:error, term()}

count_leading_zeros(a)

@spec count_leading_zeros(reference()) :: {:ok, reference()} | {:error, term()}

deallocate_tensor(ref)

@spec deallocate_tensor(reference()) :: :ok | {:error, term()}

divide(a, b)

@spec divide(reference(), reference()) :: {:ok, reference()} | {:error, term()}

dot_tensor(a, c1, b1, b, c2, b2)

@spec dot_tensor(
  reference(),
  non_neg_integer(),
  non_neg_integer(),
  reference(),
  non_neg_integer(),
  non_neg_integer()
) :: {:ok, reference()} | {:error, term()}

equal(a, b)

@spec equal(reference(), reference()) :: {:ok, reference()} | {:error, term()}

erf(a)

@spec erf(reference()) :: {:ok, reference()} | {:error, term()}

erf_inv(a)

@spec erf_inv(reference()) :: {:ok, reference()} | {:error, term()}

erfc(a)

@spec erfc(reference()) :: {:ok, reference()} | {:error, term()}

exp(a)

@spec exp(reference()) :: {:ok, reference()} | {:error, term()}

expm1(a)

@spec expm1(reference()) :: {:ok, reference()} | {:error, term()}

eye_tensor(shape, dtype_str)

@spec eye_tensor([non_neg_integer()], String.t()) ::
  {:ok, reference()} | {:error, term()}

fft_tensor(buf, opts)

@spec fft_tensor(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

floor_tensor(a)

@spec floor_tensor(reference()) :: {:ok, reference()} | {:error, term()}

gather(input, indices, opts)

@spec gather(reference(), reference(), keyword()) ::
  {:ok, reference()} | {:error, term()}

greater(a, b)

@spec greater(reference(), reference()) :: {:ok, reference()} | {:error, term()}

greater_equal(a, b)

@spec greater_equal(reference(), reference()) :: {:ok, reference()} | {:error, term()}

ifft_tensor(buf, opts)

@spec ifft_tensor(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

imag(a)

@spec imag(reference()) :: {:ok, reference()} | {:error, term()}

indexed_add(t, idx, upd, opts)

@spec indexed_add(reference(), reference(), reference(), keyword()) ::
  {:ok, reference()} | {:error, term()}

indexed_put(t, idx, upd, opts)

@spec indexed_put(reference(), reference(), reference(), keyword()) ::
  {:ok, reference()} | {:error, term()}

iota_tensor(shape, dtype_str, axis)

@spec iota_tensor([non_neg_integer()], String.t(), non_neg_integer()) ::
  {:ok, reference()} | {:error, term()}

is_infinity(a)

@spec is_infinity(reference()) :: {:ok, reference()} | {:error, term()}

is_nan(a)

@spec is_nan(reference()) :: {:ok, reference()} | {:error, term()}

left_shift(a, b)

@spec left_shift(reference(), reference()) :: {:ok, reference()} | {:error, term()}

less(a, b)

@spec less(reference(), reference()) :: {:ok, reference()} | {:error, term()}

less_equal(a, b)

@spec less_equal(reference(), reference()) :: {:ok, reference()} | {:error, term()}

load_nifs()

log1p(a)

@spec log1p(reference()) :: {:ok, reference()} | {:error, term()}

log(a)

@spec log(reference()) :: {:ok, reference()} | {:error, term()}

logical_and(a, b)

@spec logical_and(reference(), reference()) :: {:ok, reference()} | {:error, term()}

logical_or(a, b)

@spec logical_or(reference(), reference()) :: {:ok, reference()} | {:error, term()}

logical_xor(a, b)

@spec logical_xor(reference(), reference()) :: {:ok, reference()} | {:error, term()}

max_tensor(a, b)

@spec max_tensor(reference(), reference()) :: {:ok, reference()} | {:error, term()}

min_tensor(a, b)

@spec min_tensor(reference(), reference()) :: {:ok, reference()} | {:error, term()}

multiply(a, b)

@spec multiply(reference(), reference()) :: {:ok, reference()} | {:error, term()}

negate(a)

@spec negate(reference()) :: {:ok, reference()} | {:error, term()}

new_tensor(data, shape, dtype)

@spec new_tensor(binary(), [non_neg_integer()], String.t()) ::
  {:ok, reference()} | {:error, term()}

not_equal(a, b)

@spec not_equal(reference(), reference()) :: {:ok, reference()} | {:error, term()}

pad_tensor(buf, pad_value, padding_config)

@spec pad_tensor(reference(), reference(), [{integer(), integer(), integer()}]) ::
  {:ok, reference()} | {:error, term()}

population_count(a)

@spec population_count(reference()) :: {:ok, reference()} | {:error, term()}

pow(a, b)

@spec pow(reference(), reference()) :: {:ok, reference()} | {:error, term()}

product_tensor(buf, opts)

@spec product_tensor(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

put_slice(t, starts, slice)

@spec put_slice(reference(), [non_neg_integer()], reference()) ::
  {:ok, reference()} | {:error, term()}

quotient(a, b)

@spec quotient(reference(), reference()) :: {:ok, reference()} | {:error, term()}

read_tensor(ref)

@spec read_tensor(reference()) :: {:ok, binary()} | {:error, term()}

real(a)

@spec real(reference()) :: {:ok, reference()} | {:error, term()}

reduce(t, acc, opts, fun)

@spec reduce(reference(), reference(), keyword(), term()) ::
  {:ok, reference()} | {:error, term()}

reduce_max(buf, opts)

@spec reduce_max(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

reduce_min(buf, opts)

@spec reduce_min(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

relu(a)

@spec relu(reference()) :: {:ok, reference()} | {:error, term()}

remainder(a, b)

@spec remainder(reference(), reference()) :: {:ok, reference()} | {:error, term()}

reshape_tensor(buf, new_shape)

@spec reshape_tensor(reference(), [non_neg_integer()]) ::
  {:ok, reference()} | {:error, term()}

reverse_tensor(buf, axes)

@spec reverse_tensor(reference(), [non_neg_integer()]) ::
  {:ok, reference()} | {:error, term()}

right_shift(a, b)

@spec right_shift(reference(), reference()) :: {:ok, reference()} | {:error, term()}

round_tensor(a)

@spec round_tensor(reference()) :: {:ok, reference()} | {:error, term()}

rsqrt(a)

@spec rsqrt(reference()) :: {:ok, reference()} | {:error, term()}

select_tensor(pred, on_true, on_false)

@spec select_tensor(reference(), reference(), reference()) ::
  {:ok, reference()} | {:error, term()}

sigmoid(a)

@spec sigmoid(reference()) :: {:ok, reference()} | {:error, term()}

sign_tensor(a)

@spec sign_tensor(reference()) :: {:ok, reference()} | {:error, term()}

sin(a)

@spec sin(reference()) :: {:ok, reference()} | {:error, term()}

sinh(a)

@spec sinh(reference()) :: {:ok, reference()} | {:error, term()}

slice_tensor(buf, starts, lengths, strides)

@spec slice_tensor(reference(), [non_neg_integer()], [non_neg_integer()], [
  non_neg_integer()
]) ::
  {:ok, reference()} | {:error, term()}

sort_tensor(buf, opts)

@spec sort_tensor(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

sqrt(a)

@spec sqrt(reference()) :: {:ok, reference()} | {:error, term()}

squeeze_tensor(buf, axes)

@spec squeeze_tensor(reference(), [integer()]) ::
  {:ok, reference()} | {:error, term()}

stack_tensors(bufs, axis)

@spec stack_tensors([reference()], non_neg_integer()) ::
  {:ok, reference()} | {:error, term()}

subtract(a, b)

@spec subtract(reference(), reference()) :: {:ok, reference()} | {:error, term()}

sum_tensor(buf, opts)

@spec sum_tensor(
  reference(),
  keyword()
) :: {:ok, reference()} | {:error, term()}

tan(a)

@spec tan(reference()) :: {:ok, reference()} | {:error, term()}

tanh(a)

@spec tanh(reference()) :: {:ok, reference()} | {:error, term()}

tensor_dtype(ref)

@spec tensor_dtype(reference()) :: {:ok, non_neg_integer()} | {:error, term()}

tensor_shape(ref)

@spec tensor_shape(reference()) :: {:ok, [non_neg_integer()]} | {:error, term()}

transpose_tensor(buf, axes)

@spec transpose_tensor(reference(), [non_neg_integer()]) ::
  {:ok, reference()} | {:error, term()}

triangular_solve(a, b, opts)

@spec triangular_solve(reference(), reference(), keyword()) ::
  {:ok, reference()} | {:error, term()}

window_max(buf, shape, opts)

@spec window_max(reference(), [non_neg_integer()], keyword()) ::
  {:ok, reference()} | {:error, term()}

window_min(buf, shape, opts)

@spec window_min(reference(), [non_neg_integer()], keyword()) ::
  {:ok, reference()} | {:error, term()}

window_product(buf, shape, opts)

@spec window_product(reference(), [non_neg_integer()], keyword()) ::
  {:ok, reference()} | {:error, term()}

window_reduce(t, acc, shape, opts, fun)

@spec window_reduce(reference(), reference(), [non_neg_integer()], keyword(), term()) ::
  {:ok, reference()} | {:error, term()}

window_scatter_max(t, src, init, shape, opts)

@spec window_scatter_max(
  reference(),
  reference(),
  reference(),
  [non_neg_integer()],
  keyword()
) ::
  {:ok, reference()} | {:error, term()}

window_scatter_min(t, src, init, shape, opts)

@spec window_scatter_min(
  reference(),
  reference(),
  reference(),
  [non_neg_integer()],
  keyword()
) ::
  {:ok, reference()} | {:error, term()}

window_sum(buf, shape, opts)

@spec window_sum(reference(), [non_neg_integer()], keyword()) ::
  {:ok, reference()} | {:error, term()}