viva_tensor/tensor

Tensor - N-dimensional arrays for numerical computing

Design: NumPy-inspired with strides for zero-copy views. Uses Erlang :array for O(1) access + strides for efficient transpose/reshape.

Types

ErlangArray

</>

Opaque type for Erlang :array

pub type ErlangArray

Tensor

</>

Tensor with NumPy-style strides for zero-copy views

storage: contiguous data buffer (Erlang array for O(1) access)
shape: dimensions [d0, d1, …, dn]
strides: bytes to skip for each dimension [s0, s1, …, sn]
offset: starting position in storage (for views/slices)

pub type Tensor {
  Tensor(data: List(Float), shape: List(Int))
  StridedTensor(
    storage: ErlangArray,
    shape: List(Int),
    strides: List(Int),
    offset: Int,
  )
}

Constructors

Tensor(data: List(Float), shape: List(Int))

StridedTensor(
  storage: ErlangArray,
  shape: List(Int),
  strides: List(Int),
  offset: Int,
)

TensorError

</>

Tensor operation errors

pub type TensorError {
  ShapeMismatch(expected: List(Int), got: List(Int))
  InvalidShape(reason: String)
  DimensionError(reason: String)
  BroadcastError(a: List(Int), b: List(Int))
}

Constructors

ShapeMismatch(expected: List(Int), got: List(Int))

```
InvalidShape(reason: String)
```
```
DimensionError(reason: String)
```

BroadcastError(a: List(Int), b: List(Int))

Values

add

</>

pub fn add(a: Tensor, b: Tensor) -> Result(Tensor, TensorError)

Element-wise addition

add_broadcast

</>

pub fn add_broadcast(
  a: Tensor,
  b: Tensor,
) -> Result(Tensor, TensorError)

Element-wise addition with broadcasting

add_scalar

</>

pub fn add_scalar(t: Tensor, s: Float) -> Tensor

Add constant

argmax

</>

pub fn argmax(t: Tensor) -> Int

Argmax - index of largest element

argmin

</>

pub fn argmin(t: Tensor) -> Int

Argmin - index of smallest element

broadcast_shape

</>

pub fn broadcast_shape(
  a: List(Int),
  b: List(Int),
) -> Result(List(Int), TensorError)

Compute broadcast shape

broadcast_to

</>

pub fn broadcast_to(
  t: Tensor,
  target_shape: List(Int),
) -> Result(Tensor, TensorError)

Broadcast tensor to target shape

can_broadcast

</>

pub fn can_broadcast(a: List(Int), b: List(Int)) -> Bool

Check if two shapes can be broadcast together

clamp

</>

pub fn clamp(t: Tensor, min_val: Float, max_val: Float) -> Tensor

Clamp values

clone

</>

pub fn clone(t: Tensor) -> Tensor

Clone tensor

cols

</>

pub fn cols(t: Tensor) -> Int

Return number of columns (for matrices)

concat

</>

pub fn concat(tensors: List(Tensor)) -> Tensor

Concatenate vectors (1D)

concat_axis

</>

pub fn concat_axis(
  tensors: List(Tensor),
  axis: Int,
) -> Result(Tensor, TensorError)

Concatenate tensors along a specific axis For [2,3] and [2,3] tensors: concat_axis([a, b], 0) -> [4,3] For [2,3] and [2,3] tensors: concat_axis([a, b], 1) -> [2,6]

dim

</>

pub fn dim(t: Tensor, axis: Int) -> Result(Int, TensorError)

Specific dimension

div

</>

pub fn div(a: Tensor, b: Tensor) -> Result(Tensor, TensorError)

Element-wise division

dot

</>

pub fn dot(a: Tensor, b: Tensor) -> Result(Float, TensorError)

Dot product of two vectors

expand_dims

</>

pub fn expand_dims(t: Tensor, axis: Int) -> Tensor

Expand tensor to add batch dimension

fill

</>

pub fn fill(shape: List(Int), value: Float) -> Tensor

Create tensor filled with value

flatten

</>

pub fn flatten(t: Tensor) -> Tensor

Flatten to 1D

from_list

</>

pub fn from_list(data: List(Float)) -> Tensor

Create tensor from list (1D)

from_list2d

</>

pub fn from_list2d(
  rows: List(List(Float)),
) -> Result(Tensor, TensorError)

Create 2D tensor (matrix) from list of lists

get

</>

pub fn get(t: Tensor, index: Int) -> Result(Float, TensorError)

Access element by linear index

get2d

</>

pub fn get2d(
  t: Tensor,
  row: Int,
  col: Int,
) -> Result(Float, TensorError)

Access 2D element

get2d_fast

</>

pub fn get2d_fast(
  t: Tensor,
  row: Int,
  col: Int,
) -> Result(Float, TensorError)

Get 2D element with O(1) access

get_col

</>

pub fn get_col(
  t: Tensor,
  col_idx: Int,
) -> Result(Tensor, TensorError)

Get matrix column as vector

get_data

</>

pub fn get_data(t: Tensor) -> List(Float)

Extract data as list from any tensor variant

get_fast

</>

pub fn get_fast(
  t: Tensor,
  index: Int,
) -> Result(Float, TensorError)

Get element with O(1) access for StridedTensor

get_row

</>

pub fn get_row(
  t: Tensor,
  row_idx: Int,
) -> Result(Tensor, TensorError)

Get matrix row as vector

he_init

</>

pub fn he_init(fan_in: Int, fan_out: Int) -> Tensor

He initialization (for ReLU)

is_contiguous

</>

pub fn is_contiguous(t: Tensor) -> Bool

Check if tensor is contiguous in memory

map

</>

pub fn map(t: Tensor, f: fn(Float) -> Float) -> Tensor

Apply function to each element

map_indexed

</>

pub fn map_indexed(
  t: Tensor,
  f: fn(Float, Int) -> Float,
) -> Tensor

Apply function with index

matmul

</>

pub fn matmul(
  a: Tensor,
  b: Tensor,
) -> Result(Tensor, TensorError)

Matrix-matrix multiplication: [m, n] @ [n, p] -> [m, p]

matmul_vec

</>

pub fn matmul_vec(
  mat: Tensor,
  vec: Tensor,
) -> Result(Tensor, TensorError)

Matrix-vector multiplication: [m, n] @ [n] -> [m]

matrix

</>

pub fn matrix(
  rows: Int,
  cols: Int,
  data: List(Float),
) -> Result(Tensor, TensorError)

Create matrix (2D tensor) with explicit dimensions

max

</>

pub fn max(t: Tensor) -> Float

Maximum value

mean

</>

pub fn mean(t: Tensor) -> Float

Mean

mean_axis

</>

pub fn mean_axis(
  t: Tensor,
  axis_idx: Int,
) -> Result(Tensor, TensorError)

Mean along a specific axis

min

</>

pub fn min(t: Tensor) -> Float

Minimum value

mul

</>

pub fn mul(a: Tensor, b: Tensor) -> Result(Tensor, TensorError)

Element-wise multiplication (Hadamard)

mul_broadcast

</>

pub fn mul_broadcast(
  a: Tensor,
  b: Tensor,
) -> Result(Tensor, TensorError)

Element-wise multiplication with broadcasting

negate

</>

pub fn negate(t: Tensor) -> Tensor

Negation

norm

</>

pub fn norm(t: Tensor) -> Float

L2 norm

normalize

</>

pub fn normalize(t: Tensor) -> Tensor

Normalize to unit length

ones

</>

pub fn ones(shape: List(Int)) -> Tensor

Create tensor of ones

outer

</>

pub fn outer(a: Tensor, b: Tensor) -> Result(Tensor, TensorError)

Outer product: [m] @ [n] -> [m, n]

product

</>

pub fn product(t: Tensor) -> Float

Product of all elements

random_normal

</>

pub fn random_normal(
  shape: List(Int),
  mean_val: Float,
  std_val: Float,
) -> Tensor

Tensor with normal random values (approx via Box-Muller)

random_uniform

</>

pub fn random_uniform(shape: List(Int)) -> Tensor

Tensor with uniform random values [0, 1)

rank

</>

pub fn rank(t: Tensor) -> Int

Number of dimensions (rank)

reshape

</>

pub fn reshape(
  t: Tensor,
  new_shape: List(Int),
) -> Result(Tensor, TensorError)

Reshape tensor

rows

</>

pub fn rows(t: Tensor) -> Int

Return number of rows (for matrices)

scale

</>

pub fn scale(t: Tensor, s: Float) -> Tensor

Scale by constant

size

</>

pub fn size(t: Tensor) -> Int

Total number of elements

slice

</>

pub fn slice(
  t: Tensor,
  start: List(Int),
  lengths: List(Int),
) -> Result(Tensor, TensorError)

Slice tensor: extract sub-tensor from start to start+lengths slice(t, [1], [3]) extracts elements at indices 1, 2, 3

squeeze

</>

pub fn squeeze(t: Tensor) -> Tensor

Remove dimensions of size 1

squeeze_axis

</>

pub fn squeeze_axis(
  t: Tensor,
  axis: Int,
) -> Result(Tensor, TensorError)

Remove dimension at specific axis if it’s 1

stack

</>

pub fn stack(
  tensors: List(Tensor),
  axis: Int,
) -> Result(Tensor, TensorError)

Stack tensors along a new axis For [3] and [3] tensors: stack([a, b], 0) -> [2, 3] For [3] and [3] tensors: stack([a, b], 1) -> [3, 2]

std

</>

pub fn std(t: Tensor) -> Float

Standard deviation

sub

</>

pub fn sub(a: Tensor, b: Tensor) -> Result(Tensor, TensorError)

Element-wise subtraction

sum

</>

pub fn sum(t: Tensor) -> Float

Sum all elements

sum_axis

</>

pub fn sum_axis(
  t: Tensor,
  axis_idx: Int,
) -> Result(Tensor, TensorError)

Sum along a specific axis For a [2, 3] tensor, sum_axis(, 0) gives [3], sum_axis(, 1) gives [2]

take_first

</>

pub fn take_first(t: Tensor, n: Int) -> Tensor

Take first N elements along first axis

take_last

</>

pub fn take_last(t: Tensor, n: Int) -> Tensor

Take last N elements along first axis

to_contiguous

</>

pub fn to_contiguous(t: Tensor) -> Tensor

Convert strided tensor back to regular (materializes the view)

to_list

</>

pub fn to_list(t: Tensor) -> List(Float)

Convert to list

to_list2d

</>

pub fn to_list2d(
  t: Tensor,
) -> Result(List(List(Float)), TensorError)

Convert matrix to list of lists

to_strided

</>

pub fn to_strided(t: Tensor) -> Tensor

Convert regular tensor to strided (O(n) once, then O(1) access)

transpose

</>

pub fn transpose(t: Tensor) -> Result(Tensor, TensorError)

Matrix transpose

transpose_strided

</>

pub fn transpose_strided(
  t: Tensor,
) -> Result(Tensor, TensorError)

ZERO-COPY TRANSPOSE - just swap strides and shape!

unsqueeze

</>

pub fn unsqueeze(t: Tensor, axis: Int) -> Tensor

Add dimension of size 1 at specified axis

variance

</>

pub fn variance(t: Tensor) -> Float

Variance of all elements

vector

</>

pub fn vector(data: List(Float)) -> Tensor

Create vector (1D tensor)

xavier_init

</>

pub fn xavier_init(fan_in: Int, fan_out: Int) -> Tensor

Xavier initialization for weights

zeros

</>

pub fn zeros(shape: List(Int)) -> Tensor

Create tensor of zeros