# `ExCubecl.NIF`
[🔗](https://github.com/ohhi-vn/ex_cubecl/blob/v0.1.0/lib/ex_cubecl/nif.ex#L15)

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)`.

# `abs_tensor`

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

# `acos`

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

# `acosh`

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

# `add`

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

# `all_tensor`

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

# `any_tensor`

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

# `argmax_tensor`

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

# `argmin_tensor`

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

# `argsort_tensor`

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

# `as_type_tensor`

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

# `asin`

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

# `asinh`

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

# `atan2`

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

# `atan`

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

# `atanh`

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

# `bitcast_tensor`

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

# `bitwise_and`

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

# `bitwise_not`

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

# `bitwise_or`

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

# `bitwise_xor`

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

# `broadcast_tensor`

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

# `cbrt`

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

# `ceil_tensor`

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

# `clip_tensor`

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

# `concatenate_tensors`

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

# `conjugate`

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

# `constant_tensor`

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

# `conv`

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

# `cos`

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

# `cosh`

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

# `count_leading_zeros`

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

# `deallocate_tensor`

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

# `divide`

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

# `dot_tensor`

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

# `equal`

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

# `erf`

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

# `erf_inv`

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

# `erfc`

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

# `exp`

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

# `expm1`

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

# `eye_tensor`

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

# `fft_tensor`

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

# `floor_tensor`

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

# `gather`

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

# `greater`

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

# `greater_equal`

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

# `ifft_tensor`

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

# `imag`

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

# `indexed_add`

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

# `indexed_put`

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

# `iota_tensor`

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

# `is_infinity`

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

# `is_nan`

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

# `left_shift`

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

# `less`

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

# `less_equal`

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

# `load_nifs`

# `log1p`

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

# `log`

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

# `logical_and`

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

# `logical_or`

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

# `logical_xor`

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

# `max_tensor`

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

# `min_tensor`

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

# `multiply`

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

# `negate`

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

# `new_tensor`

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

# `not_equal`

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

# `pad_tensor`

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

# `population_count`

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

# `pow`

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

# `product_tensor`

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

# `put_slice`

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

# `quotient`

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

# `read_tensor`

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

# `real`

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

# `reduce`

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

# `reduce_max`

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

# `reduce_min`

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

# `relu`

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

# `remainder`

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

# `reshape_tensor`

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

# `reverse_tensor`

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

# `right_shift`

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

# `round_tensor`

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

# `rsqrt`

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

# `select_tensor`

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

# `sigmoid`

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

# `sign_tensor`

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

# `sin`

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

# `sinh`

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

# `slice_tensor`

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

# `sort_tensor`

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

# `sqrt`

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

# `squeeze_tensor`

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

# `stack_tensors`

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

# `subtract`

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

# `sum_tensor`

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

# `tan`

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

# `tanh`

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

# `tensor_dtype`

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

# `tensor_shape`

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

# `transpose_tensor`

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

# `triangular_solve`

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

# `window_max`

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

# `window_min`

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

# `window_product`

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

# `window_reduce`

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

# `window_scatter_max`

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

# `window_scatter_min`

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

# `window_sum`

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

---

*Consult [api-reference.md](api-reference.md) for complete listing*