viva_tensor - v1.3.0

viva_tensor

viva_tensor - Pure Gleam tensor library

N-dimensional arrays with named axes, broadcasting, and zero-copy views.

Features

Quick Start

import viva_tensor as t
import viva_tensor/axis

// Create tensors
let a = t.zeros([2, 3])
let b = t.ones([2, 3])

// Operations
let c = t.add(a, b)
let d = t.matmul(a, t.transpose(b))

// Named tensors
let named = t.named.zeros([axis.batch(32), axis.feature(128)])
let summed = t.named.sum_along(named, axis.Batch)

Types

Conv2dConfig

</>

Conv2d configuration type

pub type Conv2dConfig =
  tensor.Conv2dConfig

Values

add

</> 
pub fn add(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Element-wise addition

add_broadcast

</> 
pub fn add_broadcast(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Add with broadcasting

argmax

</> 
pub fn argmax(t: tensor.Tensor) -> Int

Index of maximum value

argmin

</> 
pub fn argmin(t: tensor.Tensor) -> Int

Index of minimum value

avg_pool2d

</> 
pub fn avg_pool2d(
  input: tensor.Tensor,
  pool_h: Int,
  pool_w: Int,
  stride_h: Int,
  stride_w: Int,
) -> Result(tensor.Tensor, tensor.TensorError)

Average pooling 2D

can_broadcast

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

Check if shapes can broadcast

clamp

</> 
pub fn clamp(
  t: tensor.Tensor,
  min_val: Float,
  max_val: Float,
) -> tensor.Tensor

Clamp values

conv2d

</> 
pub fn conv2d(
  input: tensor.Tensor,
  kernel: tensor.Tensor,
  config: tensor.Conv2dConfig,
) -> Result(tensor.Tensor, tensor.TensorError)

2D Convolution Input: [H, W] or [C, H, W] or [N, C, H, W] Kernel: [KH, KW] or [C, KH, KW] or [C_out, C_in, KH, KW]

conv2d_config

</> 
pub fn conv2d_config() -> tensor.Conv2dConfig

Default conv2d config (3x3 kernel, stride 1, no padding)

conv2d_same

</> 
pub fn conv2d_same(
  kernel_h: Int,
  kernel_w: Int,
) -> tensor.Conv2dConfig

Conv2d config with “same” padding (output same size as input)

div

</> 
pub fn div(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Element-wise division

dot

</> 
pub fn dot(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(Float, tensor.TensorError)

Dot product of two vectors

fill

</> 
pub fn fill(shape: List(Int), value: Float) -> tensor.Tensor

Create tensor filled with value

flatten

</> 
pub fn flatten(t: tensor.Tensor) -> tensor.Tensor

Flatten to 1D

from_list

</> 
pub fn from_list(data: List(Float)) -> tensor.Tensor

Create tensor from list (1D)

from_list2d

</> 
pub fn from_list2d(
  rows: List(List(Float)),
) -> Result(tensor.Tensor, tensor.TensorError)

Create 2D tensor from list of lists

global_avg_pool2d

</> 
pub fn global_avg_pool2d(
  input: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Global average pooling - reduces [N, C, H, W] to [N, C, 1, 1]

he_init

</> 
pub fn he_init(fan_in: Int, fan_out: Int) -> tensor.Tensor

He initialization (for ReLU networks)

is_contiguous

</> 
pub fn is_contiguous(t: tensor.Tensor) -> Bool

Check if contiguous

map

</> 
pub fn map(
  t: tensor.Tensor,
  f: fn(Float) -> Float,
) -> tensor.Tensor

Apply function to each element

matmul

</> 
pub fn matmul(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Matrix-matrix multiplication

matmul_vec

</> 
pub fn matmul_vec(
  mat: tensor.Tensor,
  vec: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Matrix-vector multiplication

matrix

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

Create matrix (2D tensor)

max

</> 
pub fn max(t: tensor.Tensor) -> Float

Maximum value

max_pool2d

</> 
pub fn max_pool2d(
  input: tensor.Tensor,
  pool_h: Int,
  pool_w: Int,
  stride_h: Int,
  stride_w: Int,
) -> Result(tensor.Tensor, tensor.TensorError)

Max pooling 2D Input: [H, W] or [N, C, H, W]

mean

</> 
pub fn mean(t: tensor.Tensor) -> Float

Mean of all elements

min

</> 
pub fn min(t: tensor.Tensor) -> Float

Minimum value

mul

</> 
pub fn mul(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Element-wise multiplication

mul_broadcast

</> 
pub fn mul_broadcast(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Multiply with broadcasting

norm

</> 
pub fn norm(t: tensor.Tensor) -> Float

L2 norm

normalize

</> 
pub fn normalize(t: tensor.Tensor) -> tensor.Tensor

Normalize to unit length

ones

</> 
pub fn ones(shape: List(Int)) -> tensor.Tensor

Create tensor of ones

outer

</> 
pub fn outer(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Outer product

pad2d

</> 
pub fn pad2d(
  t: tensor.Tensor,
  pad_h: Int,
  pad_w: Int,
) -> Result(tensor.Tensor, tensor.TensorError)

Pad 2D tensor with zeros

pad4d

</> 
pub fn pad4d(
  t: tensor.Tensor,
  pad_h: Int,
  pad_w: Int,
) -> Result(tensor.Tensor, tensor.TensorError)

Pad 4D tensor (batch) with zeros

random_normal

</> 
pub fn random_normal(
  shape: List(Int),
  mean: Float,
  std: Float,
) -> tensor.Tensor

Tensor with normal random values

random_uniform

</> 
pub fn random_uniform(shape: List(Int)) -> tensor.Tensor

Tensor with uniform random values [0, 1)

rank

</> 
pub fn rank(t: tensor.Tensor) -> Int

Get rank (number of dimensions)

reshape

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

Reshape tensor

scale

</> 
pub fn scale(t: tensor.Tensor, s: Float) -> tensor.Tensor

Scale by constant

shape

</> 
pub fn shape(t: tensor.Tensor) -> List(Int)

Get shape

size

</> 
pub fn size(t: tensor.Tensor) -> Int

Get total size

squeeze

</> 
pub fn squeeze(t: tensor.Tensor) -> tensor.Tensor

Remove dimensions of size 1

std

</> 
pub fn std(t: tensor.Tensor) -> Float

Standard deviation

sub

</> 
pub fn sub(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Element-wise subtraction

sum

</> 
pub fn sum(t: tensor.Tensor) -> Float

Sum all elements

to_contiguous

</> 
pub fn to_contiguous(t: tensor.Tensor) -> tensor.Tensor

Convert to contiguous tensor

to_list

</> 
pub fn to_list(t: tensor.Tensor) -> List(Float)

Convert to list

to_strided

</> 
pub fn to_strided(t: tensor.Tensor) -> tensor.Tensor

Convert to strided tensor (O(1) access)

transpose

</> 
pub fn transpose(
  t: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Transpose matrix

transpose_strided

</> 
pub fn transpose_strided(
  t: tensor.Tensor,
) -> Result(tensor.Tensor, tensor.TensorError)

Zero-copy transpose

unsqueeze

</> 
pub fn unsqueeze(
  t: tensor.Tensor,
  axis_idx: Int,
) -> tensor.Tensor

Add dimension of size 1

variance

</> 
pub fn variance(t: tensor.Tensor) -> Float

Variance

vector

</> 
pub fn vector(data: List(Float)) -> tensor.Tensor

Create vector (1D tensor)

xavier_init

</> 
pub fn xavier_init(fan_in: Int, fan_out: Int) -> tensor.Tensor

Xavier initialization for neural network weights

zeros

</> 
pub fn zeros(shape: List(Int)) -> tensor.Tensor

Create tensor of zeros

✨ Search Document