<imgsrc="static/vtl-feature-banner.svg"alt="VTL tensors, autograd, numerical computing, and CPU and GPU training paths"width="100%"

import vtl
t := vtl.from_array([1.0, 2, 3, 4], [2, 2])!
t.get([1, 1])
// 4.0

Features

• Tensors — create, slice, indexed take/take_nd/take_flat/put, choose/select, round_decimals, nan_to_num, compress, indices, pad, set membership, reshape, transpose, move/roll axes, N-D diagonal views, NumPy-style Kronecker products, broadcast, map/reduce, einsum, and complex128 storage with elementwise and matrix products
• Autograd — reverse-mode AD; arbitrary computational graphs
• Neural networks — Sequential API; Linear, Conv2D, LSTM, Attention, …
• Losses & optimizers — MSE, MAE, BCE, Hinge, Focal, CrossEntropy, Huber; Adam, AdamW, NAdam, RAdam, SGD, …
• Linear algebra — VSL-backed real matmul and general eigensolvers, pure-V complex128 matmul, solve, QR, LU, Cholesky, SVD, pinv
• Hardware — zero-copy Tensor.data for C libs; optional CUDA and Vulkan training paths

ML Release Highlights

The ML beta scope is the high-level VTL API: tensors, autograd, layers, losses, optimizers, datasets, and CPU training. CUDA and Vulkan paths are available for opt-in validation and early adopters, but remain experimental backend accelerators rather than stable user contracts.

For memory-safe local commands, see DEV_LIGHTWEIGHT.md.

Quick start

import vtl
import vtl.autograd
import vtl.nn.layers
import vtl.nn.models
import vtl.nn.optimizers

mut ctx := autograd.ctx[f32]()
mut model := models.sequential_from_ctx[f32](ctx)
model.input([784])
model.linear(256)
model.linear(10)
model.mse_loss()

input_tensor := vtl.zeros[f32]([64, 784])
mut x := ctx.variable(input_tensor)
y_pred := model.forward(x)!

target := vtl.zeros[f32]([64, 10])
mut loss_val := model.loss(y_pred, target)!
loss_val.backprop()!

mut opt := optimizers.adam_optimizer[f32](optimizers.AdamOptimizerConfig{
    learning_rate: 0.001
})
opt.build_params(model.info.layers)
opt.update()!

Module overview

Installation

VTL uses VSL for linear algebra. The core vtl module works without optional system BLAS/LAPACK, but LA features need VSL.

Follow VSL install instructions, then:

v install vtl

Testing

# Run the full scoped suite from ~/.vmodules; compiler parallelism is disabled
# to keep the local memory ceiling predictable.
cd ~/.vmodules
systemd-run --user --scope --property=MemoryMax=4G --property=MemorySwapMax=0 \
    env VJOBS=2 VTL_NO_PARALLEL=1 ./vtl/bin/test

See DEV_LIGHTWEIGHT.md for memory-safe subsets in CI.

Documentation

Start Here

Full index: docs/README.md.

Contributors

VTL's early development was inspired by vnum, part of the Vlang Num group, and the work of Christopher Zimmerman. The core was reimplemented while keeping that lineage and inspiration. The original vnum work carried a BSD 3-Clause license with attribution to vlang-num contributors; the historical license text is preserved in the VTL repository history. This acknowledgment records that history and does not change VTL's current license, shown below.

Made with contributors-img.

License

MIT

[awesomevbadge]: https://awesome.re/mentioned-badge.svg [workflowbadge]: https://github.com/vlang/vtl/actions/workflows/ci.yml/badge.svg [docsbadge]: https://github.com/vlang/vtl/actions/workflows/deploy-docs.yml/badge.svg [fullmlbadge]: https://github.com/vlang/vtl/actions/workflows/ci-full-ml.yml/badge.svg [benchmarksbadge]: https://github.com/vlang/vtl/actions/workflows/benchmark-pr-comment.yml/badge.svg [licensebadge]: https://img.shields.io/badge/License-MIT-blue.svg [vslbackedbadge]: https://img.shields.io/badge/VSL-backed-027d9c?logo=v [cudaoptionalbadge]: https://img.shields.io/badge/CUDA-optional-76b900?logo=nvidia [vulkanbadge]: https://img.shields.io/badge/Vulkan-f32-ac162c?logo=vulkan [awesomevurl]: https://github.com/vlang/awesome-v/blob/master/README.md#scientific-computing [workflowurl]: https://github.com/vlang/vtl/actions/workflows/ci.yml [docsurl]: https://github.com/vlang/vtl/actions/workflows/deploy-docs.yml [fullmlurl]: https://github.com/vlang/vtl/actions/workflows/ci-full-ml.yml [benchmarksurl]: https://github.com/vlang/vtl/actions/workflows/benchmark-pr-comment.yml [licenseurl]: https://github.com/vlang/vtl/blob/main/LICENSE

fn abs(input &Tensor[complex.Complex]) !&Tensor[f64]

abs is the NumPy-style alias for absolute.

fn absolute(input &Tensor[complex.Complex]) !&Tensor[f64]

absolute returns the magnitude of every complex element as a float64 tensor. math.hypot scales its inputs to avoid unnecessary overflow and underflow.

fn add_promoted[R, T, U](a &Tensor[T], b &Tensor[U]) !&Tensor[R]

add_promoted adds real numeric tensors after converting both operands to the explicitly selected NumPy-style promoted dtype. The output type R must match promote_types(dtype_ofT, dtype_ofU).

fn advanced_index[T](t &Tensor[T], indices []&Tensor[int]) !&Tensor[T]

advanced_index selects values using one integer coordinate tensor per input axis. Coordinate tensors are broadcast together, and each output element is read from the matching coordinate tuple. The result is an independent row-major copy. This API handles full coordinate tuples; mixing coordinate tensors with slices or scalar indices is not supported here.

fn arange[T](start f64, stop f64, step f64, params TensorData) !&Tensor[T]

arange returns evenly spaced values in the half-open interval [start, stop). The direction of step determines whether the result is ascending or descending.

fn arccos(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

arccos applies the principal inverse complex cosine to every element.

fn arccosh(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

arccosh applies the principal inverse complex hyperbolic cosine to every element.

fn arcsin(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

arcsin applies the principal inverse complex sine to every element.

fn arcsinh(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

arcsinh applies the principal inverse complex hyperbolic sine to every element.

fn arctan(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

arctan applies the principal inverse complex tangent to every element.

fn arctanh(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

arctanh applies the principal inverse complex hyperbolic tangent to every element.

fn argpartition[T](t &Tensor[T], kth int) !&Tensor[int]

argpartition returns local indices that place kth at its sorted position along the last axis. The order of the other indices is unspecified.

fn argpartition_axis[T](t &Tensor[T], kths []int, axis int) !&Tensor[int]

argpartition_axis partially orders local indices along axis. The returned tensor has the same shape as t and supports multiple kth positions.

fn argsort[T](t &Tensor[T]) !&Tensor[int]

argsort returns stable ascending sort indices along the last axis.

fn argsort_axis[T](t &Tensor[T], axis int) !&Tensor[int]

argsort_axis returns the stable ascending sort indices along axis. Returned indices are local to that axis; floating-point NaNs sort to the end.

fn argwhere[T](t &Tensor[T]) !&Tensor[int]

argwhere returns the coordinates of non-zero elements as a row-major tensor with shape [number of matches, input rank].

fn array_index(indices &Tensor[int]) TensorIndex

array_index selects positions using an integer coordinate tensor. All coordinate tensors in a mixed_index call are broadcast together.

fn bernoulli[T](prob f64, shape []int, params TensorData) &Tensor[T]

bernoulli returns a tensor of bernoulli random variables.

fn beta(alpha f64, beta f64, shape []int, params TensorData) !&Tensor[f64]

beta returns samples from the Beta distribution using VTL's global stream.

fn binomial[T](n int, prob f64, shape []int, params TensorData) !&Tensor[T]

binomial returns a tensor of binomial random variables.

fn boolean_index[T](t &Tensor[T], mask &Tensor[bool]) !&Tensor[T]

boolean_index selects values where mask is true. The mask shape must match the leading tensor dimensions; any remaining tensor dimensions are retained after the selected-element axis. The result is an independent row-major copy, matching NumPy's a[mask] behavior.

fn broadcast2[T](a &Tensor[T], b &Tensor[T]) !(&Tensor[T], &Tensor[T])

broadcast2 exposes this operation as part of the public API.

fn broadcast3[T](a &Tensor[T], b &Tensor[T], c &Tensor[T]) !(&Tensor[T], &Tensor[T], &Tensor[T])

broadcast3 exposes this operation as part of the public API.

fn broadcast_n[T](ts []&Tensor[T]) ![]&Tensor[T]

broadcast_n exposes this operation as part of the public API.

fn cast[T](x TensorDataType) T

cast exposes this operation as part of the public API.

fn cauchy(location f64, scale f64, shape []int, params TensorData) !&Tensor[f64]

cauchy returns samples from a Cauchy distribution using VTL's global stream.

fn chi_square(degrees_of_freedom f64, shape []int, params TensorData) !&Tensor[f64]

chi_square returns samples from a chi-square distribution using VTL's global random stream.

fn choose[T](indices &Tensor[int], choices []&Tensor[T]) !&Tensor[T]

choose selects values from choices using integer indices. Choices broadcast to one common shape, and indices broadcast to that shape. Each index must be in the range [0, choices.len).

fn clip_tensor[T](t &Tensor[T], lower &Tensor[T], upper &Tensor[T]) !&Tensor[T]

clip_tensor clamps values using broadcastable lower and upper bounds. It computes the result in one pass so callers do not need separate maximum and minimum tensors or intermediate results. Stride-based offsets avoid creating per-element coordinate arrays, including when an input is a view.

fn column_stack[T](ts []&Tensor[T]) !&Tensor[T]

column_stack stacks 1-D arrays as columns into a 2-D array.

fn complex_angle(input &Tensor[complex.Complex], degrees bool) !&Tensor[f64]

complex_angle returns the phase of each value in radians, or degrees when requested. The result range follows atan2 and is [-pi, pi].

fn complex_is_finite(input &Tensor[complex.Complex]) !&Tensor[bool]

complex_is_finite reports whether both components of each value are finite.

fn complex_is_inf(input &Tensor[complex.Complex]) !&Tensor[bool]

complex_is_inf reports whether either component of each value is infinite.

fn complex_is_nan(input &Tensor[complex.Complex]) !&Tensor[bool]

complex_is_nan reports whether either component of each value is NaN.

fn compress[T](condition &Tensor[bool], t &Tensor[T]) !&Tensor[T]

compress selects flattened values at positions where condition is true. As in NumPy, a condition shorter than the input stops selection at its length; extra condition values are ignored.

fn compress_axis[T](condition &Tensor[bool], t &Tensor[T], axis int) !&Tensor[T]

compress_axis selects slices along axis using a one-dimensional condition. If condition is shorter than the axis, the remaining slices are omitted.

fn concatenate[T](ts []&Tensor[T], data AxisData) !&Tensor[T]

concatenate concatenates two Tensors together

fn conj(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

conj returns the complex conjugate of every element in a complex tensor.

fn copysign[T](magnitude &Tensor[T], sign &Tensor[T]) !&Tensor[T]

copysign returns the magnitude of magnitude with the sign bit of sign. Both f32 and f64 inputs broadcast to a common output shape.

fn cos(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

cos applies the complex cosine to every element.

fn cosh(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

cosh applies the complex hyperbolic cosine to every element.

fn count_nonzero[T](t &Tensor[T]) int

count_nonzero counts non-zero values across every tensor dimension.

fn count_nonzero_axes[T](t &Tensor[T], axes []int, keepdims bool) !&Tensor[int]

count_nonzero_axes counts non-zero values along multiple axes. Negative axes are supported, axes must be unique, and an empty axis list preserves the input shape while converting each value to zero or one.

fn count_nonzero_axis[T](t &Tensor[T], axis int, keepdims bool) !&Tensor[int]

count_nonzero_axis counts non-zero values along one axis. By default the reduced axis is removed; set keepdims to retain it with length one.

fn diagonal[T](input &Tensor[T], params DiagonalData) !&Tensor[T]

diagonal returns a view along the diagonal of two axes of an N-D tensor. The selected axes are removed and the diagonal axis is appended to the result, following NumPy's shape convention. The view shares input storage. VTL tensors remain mutable, so writes through the result update the input.

fn diff[T](t &Tensor[T], n int, axis int) !&Tensor[T]

diff computes the n-th discrete difference along an axis. Negative axes count from the end, and n=0 returns a row-major copy of the input.

fn digitize[T](values &Tensor[T], bins &Tensor[T], right bool) !&Tensor[int]

digitize assigns values to monotonic bins. Increasing and decreasing edge arrays are supported; right selects which interval owns an edge value.

fn dirichlet[T](alpha &Tensor[T], sample_shape []int, params TensorData) !&Tensor[f64]

dirichlet returns normalized Gamma samples. The final output axis contains categories and sample_shape defines the preceding axes.

fn divide_promoted[R, T, U](a &Tensor[T], b &Tensor[U]) !&Tensor[R]

divide_promoted performs NumPy-style true division for real numeric tensors and booleans. The output dtype is float32 only when the promoted input dtype is float32; otherwise it is float64. Inputs are broadcast before division.

fn dstack[T](ts []&Tensor[T]) !&Tensor[T]

dstack stacks arrays in sequence depth wise (along third axis)

fn dtype_of[T]() DType

dtype_of returns the VTL dtype corresponding to the compile-time type T.

fn einsum[T](subscripts string, operands ...&Tensor[T]) !&Tensor[T]

einsum evaluates an Einstein summation expression over one or more tensors. It supports alphabetic axis labels, explicit or implicit output labels, repeated labels for diagonals, broadcasting of size-one axes, and any number of operands. Ellipses expand to the leading axes and are right-aligned across operands, enabling batched expressions such as ...ij,...jk->...ik.

When the output is omitted, labels that occur exactly once are returned in alphabetical order, following NumPy's implicit-output convention.

fn ellipsis_index() TensorIndex

ellipsis_index expands to enough full axes to cover the unindexed dimensions. At most one ellipsis is allowed in a mixed_index call.

fn empty[T](shape []int, params TensorData) &Tensor[T]

empty exposes this operation as part of the public API.

fn empty_like[T](t &Tensor[T]) &Tensor[T]

empty_like exposes this operation as part of the public API.

fn exp(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

exp applies the complex exponential to every complex tensor element.

fn exponential[T](lambda f64, shape []int, params TensorData) &Tensor[T]

exponential returns a tensor of exponential random variables.

fn eye[T](m int, n int, k int, params TensorData) &Tensor[T]

eye returns a 2D array with ones on the diagonal and zeros elsewhere

fn f_distribution(numerator_df f64, denominator_df f64, shape []int, params TensorData) !&Tensor[f64]

f_distribution returns samples from the F distribution using VTL's global random stream.

fn from_1d[T](arr []T, params TensorData) !&Tensor[T]

from_1d takes a one dimensional array of floating point values and returns a one dimensional Tensor if possible

fn from_2d[T](a [][]T, params TensorData) !&Tensor[T]

from_2d exposes this operation as part of the public API.

fn from_array[T](arr []T, shape []int, params TensorData) !&Tensor[T]

from_varray takes a one dimensional array of T values and coerces it into an arbitrary shaped Tensor if possible. Panics if the shape provided does not hold the provided array

fn full[T](shape []int, val T, params TensorData) &Tensor[T]

full exposes this operation as part of the public API.

fn full_index() TensorIndex

full_index selects every position on one axis.

fn full_like[T](t &Tensor[T], val T) &Tensor[T]

full_like returns a new tensor of the same shape and type as a given Tensor filled with a given val

fn gamma(alpha f64, scale f64, shape []int, params TensorData) !&Tensor[f64]

gamma returns samples from a Gamma distribution on VTL's global random stream. alpha is the shape and scale is the scale parameter.

fn geometric(probability f64, shape []int, params TensorData) !&Tensor[int]

geometric returns the number of Bernoulli trials needed for the first success, sampled from V's global random stream. Results start at 1.

fn gumbel(location f64, scale f64, shape []int, params TensorData) !&Tensor[f64]

gumbel returns samples from a Gumbel distribution using VTL's global stream.

fn hstack[T](ts []&Tensor[T]) !&Tensor[T]

hstack stacks arrays in sequence horizontally (column wise)

fn hypergeometric(ngood int, nbad int, nsample int, shape []int, params TensorData) !&Tensor[int]

hypergeometric returns the number of good items in draws made without replacement from a population containing ngood good and nbad bad items.

fn identity[T](n int, params TensorData) &Tensor[T]

identity exposes this operation as part of the public API.

fn imag(input &Tensor[complex.Complex]) !&Tensor[f64]

imag returns the imaginary components of a complex tensor as a float64 tensor.

fn indices(dimensions []int) !&Tensor[int]

indices returns a dense coordinate tensor with shape [dimensions.len, ...dimensions], matching numpy.indices for integer arrays. Each leading-axis plane contains the coordinates for one input dimension.

fn indices_sparse(dimensions []int) ![]&Tensor[int]

indices_sparse returns one broadcastable coordinate tensor per dimension. Each result has rank dimensions.len and only its own axis has non-unit length, matching numpy.indices(..., sparse: true) without allocating the dense coordinate stack.

fn integer_index(index int) TensorIndex

integer_index selects one position and removes its axis from the result.

fn isin[T](elements &Tensor[T], test_elements &Tensor[T]) &Tensor[bool]

isin returns a boolean tensor indicating whether each element occurs in test_elements. It preserves the shape and logical iteration order of the input, including for non-contiguous views.

fn kron[T](a &Tensor[T], b &Tensor[T]) !&Tensor[T]

kron returns the Kronecker product of two tensors. The lower-rank input is left-padded with singleton dimensions, matching NumPy's rank semantics.

fn laplace(location f64, scale f64, shape []int, params TensorData) !&Tensor[f64]

laplace returns samples from a Laplace distribution using VTL's global stream.

fn ldexp[T](mantissa &Tensor[T], exponent &Tensor[int]) !&Tensor[T]

ldexp scales each floating-point mantissa by 2 raised to the corresponding integer exponent. The operands broadcast to a common shape.

fn linspace[T](start f64, stop f64, num int, params LinspaceData) !&Tensor[T]

linspace returns num evenly spaced values between start and stop. The endpoint is included by default; set endpoint: false to exclude stop.

fn log(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

log applies the principal complex natural logarithm to every element.

fn logaddexp[T](a &Tensor[T], b &Tensor[T]) !&Tensor[T]

logaddexp computes log(exp(a) + exp(b)) elementwise using a stable form. The f32/f64 operands broadcast to a common output shape.

fn logaddexp2[T](a &Tensor[T], b &Tensor[T]) !&Tensor[T]

logaddexp2 computes log2(2^a + 2^b) elementwise using a stable form. The f32/f64 operands broadcast to a common output shape.

fn logistic(location f64, scale f64, shape []int, params TensorData) !&Tensor[f64]

logistic returns samples from a Logistic distribution using VTL's global stream.

fn lognormal(mean f64, sigma f64, shape []int, params TensorData) !&Tensor[f64]

lognormal returns samples whose natural logarithm follows a normal distribution using VTL's global random stream.

fn logspace[T](start f64, stop f64, num int, params LogspaceData) !&Tensor[T]

logspace returns num values spaced evenly on a logarithmic scale between base^start and base^stop. The endpoint is included by default.

fn masked_array[T](values &Tensor[T], mask &Tensor[bool]) !MaskedArray[T]

masked_array creates a masked tensor. The mask broadcasts against values; the returned values and mask are views with the common broadcast shape.

fn meshgrid[T](x &Tensor[T], y &Tensor[T]) !(&Tensor[T], &Tensor[T])

meshgrid builds dense two-dimensional XY coordinate grids from two vectors. The output shape is [len(y), len(x)], matching NumPy's default indexing="xy".

fn meshgrid_n[T](vectors []&Tensor[T], indexing MeshgridIndexing) ![]&Tensor[T]

meshgrid_n builds one dense coordinate tensor for each one-dimensional input. With xy, the first two dimensions are swapped, matching NumPy's default indexing convention. ij preserves the input axis order.

fn mixed_index[T](t &Tensor[T], indices []TensorIndex) !&Tensor[T]

mixed_index combines full slices, ranges, scalar integers, broadcasted coordinate tensors, ellipsis, and inserted size-one axes. Omitted trailing axes select the full axis. If every index is basic, the result is a view; if any coordinate tensor is used, the result is an independent row-major copy.

fn multiply_promoted[R, T, U](a &Tensor[T], b &Tensor[U]) !&Tensor[R]

multiply_promoted multiplies real numeric tensors after converting both operands to the explicitly selected NumPy-style promoted dtype. The output type R must match promote_types(dtype_ofT, dtype_ofU).

fn multivariate_normal(mean &Tensor[f64], covariance &Tensor[f64], sample_shape []int, params TensorData) !&Tensor[f64]

multivariate_normal draws samples with the requested mean and covariance using VTL's global random stream.

fn negative_binomial(n f64, probability f64, shape []int, params TensorData) !&Tensor[int]

negative_binomial counts failures before n successes on VTL's global random stream. n may be any finite positive real value.

fn new_random_generator(seed int) RandomGenerator

new_random_generator creates an independent generator initialized from seed.

fn newaxis_index() TensorIndex

newaxis_index inserts a size-one axis at this position without consuming an input axis. Basic indexing with a new axis remains a view.

fn nonzero[T](t &Tensor[T]) ![]&Tensor[int]

nonzero returns one index tensor per input axis, matching NumPy's tuple of coordinate arrays. A nonzero scalar is treated as a one-dimensional value with index zero, following NumPy's scalar promotion behavior.

fn normal[T](shape []int, params NormalTensorData) &Tensor[T]

normal returns a tensor of normal random variables.

fn one_hot(indices &Tensor[int], num_classes int) !&Tensor[int]

one_hot encodes integer class indices as rows of a one-hot matrix. The output shape is indices.shape followed by num_classes; every index must be in [0, num_classes). An empty index tensor returns an empty tensor with the corresponding trailing class dimension.

fn ones[T](shape []int, params TensorData) &Tensor[T]

ones exposes this operation as part of the public API.

fn ones_like[T](t &Tensor[T]) &Tensor[T]

ones_like exposes this operation as part of the public API.

fn pad[T](t &Tensor[T], pad_width [][]int, mode PadMode, constant_value T) !&Tensor[T]

pad adds a before/after width to every dimension. pad_width contains one [before, after] pair per axis. Reflect excludes the edge value; symmetric includes it. constant_value is used only with .constant.

fn pareto(shape_parameter f64, shape []int, params TensorData) !&Tensor[f64]

pareto returns standard Pareto samples (minimum zero) using VTL's global stream.

fn partition[T](t &Tensor[T], kth int) !&Tensor[T]

partition returns a copy with the value at kth in its sorted position and every preceding value less than or equal to it. Remaining values are unspecified, matching NumPy's default last-axis behavior.

fn partition_axis[T](t &Tensor[T], kths []int, axis int) !&Tensor[T]

partition_axis partially sorts each one-dimensional slice along axis. kth positions are local to each slice; multiple positions can be requested in one pass without fully sorting the data.

fn poisson(lambda f64, shape []int, params TensorData) !&Tensor[int]

poisson returns integer event counts from VTL's global random stream.

fn promote_types(a DType, b DType) !DType

promote_types returns the common dtype for two array dtypes. Its numeric rules are modeled on NumPy, using the integer and floating-point types VTL currently supports. If VTL has no signed integer width that can represent both inputs, it promotes to float64. Mixing strings with other dtypes is rejected; scalar-value weak promotion is not part of this dtype-only API.

fn random[T](min T, max T, shape []int, params TensorData) &Tensor[T]

random returns a new Tensor of given shape and type, initialized with random numbers between a given min and max value

fn random_seed(i int)

random_seed resets VTL's global random generator for reproducible results. The seed affects random tensor constructors and model parameter initialization that use V's default random generator.

fn range[T](from int, to int, params TensorData) &Tensor[T]

range returns a Tensor containing values ranging from [from, to)

fn ravel_multi_index(coordinates []&Tensor[int], dimensions []int,
	options MultiIndexOptions) !&Tensor[int]

ravel_multi_index converts one integer coordinate tensor per dimension to flat indices. Coordinate tensors broadcast together. The result shape is their broadcast shape. mode applies raise, wrap, or clip bounds handling to every axis; axis_modes may instead specify one mode per axis. Order selects C (row-major) or F (column-major) flattening.

fn rayleigh(scale f64, shape []int, params TensorData) !&Tensor[f64]

rayleigh returns samples from a Rayleigh distribution using VTL's global stream.

fn real(input &Tensor[complex.Complex]) !&Tensor[f64]

real returns the real components of a complex tensor as a float64 tensor.

fn remainder_promoted[R, T, U](a &Tensor[T], b &Tensor[U]) !&Tensor[R]

remainder_promoted returns the element-wise NumPy remainder of real numeric tensors after dtype promotion and broadcasting. Integer zero divisors produce zero; floating-point zero divisors produce NaN.

fn repeat[T](t &Tensor[T], repeats int) !&Tensor[T]

repeat returns a copy with each value repeated the requested number of times. If axis is omitted the tensor is flattened first, matching NumPy.

fn repeat_axis[T](t &Tensor[T], repeats int, axis int) !&Tensor[T]

repeat_axis repeats each value along axis and preserves the other dimensions.

fn roll[T](t &Tensor[T], shift int, axes ...int) !&Tensor[T]

roll shifts values along the flattened tensor when axes is omitted. When axes are provided, the same shift is applied independently to each axis. Negative axes and shifts are accepted. The result is always a copy.

fn roll_axes[T](t &Tensor[T], shift int, axes []int) !&Tensor[T]

roll_axes applies one scalar shift to each selected axis. Repeated axes accumulate their shifts, and an empty axis list leaves the tensor unchanged.

fn roll_flat[T](t &Tensor[T], shift int) !&Tensor[T]

roll_flat circularly shifts the row-major logical values and preserves the original shape.

fn roll_shifts[T](t &Tensor[T], shifts []int, axes []int) !&Tensor[T]

roll_shifts applies paired shifts and axes, accumulating repeated axes.

fn rot90[T](t &Tensor[T]) !&Tensor[T]

rot90 rotates a tensor counterclockwise by k quarter-turns in its first two dimensions, matching NumPy's default axes=(0, 1).

fn rot90_axes[T](t &Tensor[T], k int, axes []int) !&Tensor[T]

rot90_axes rotates counterclockwise in the plane defined by two distinct axes.

fn rot90_k[T](t &Tensor[T], k int) !&Tensor[T]

rot90_k rotates in the first two dimensions by k counterclockwise quarter-turns.

fn searchsorted[T](sorted &Tensor[T], values &Tensor[T], side SearchSide) !&Tensor[int]

searchsorted returns insertion positions for values in an ascending 1-D tensor. The input is assumed to be sorted; each query uses binary search.

fn searchsorted_descending[T](sorted &Tensor[T], values &Tensor[T], side SearchSide) !&Tensor[int]

searchsorted_descending returns insertion positions for values in a descending 1-D tensor. The input is assumed to be sorted; each query uses binary search. The output has the same shape as values.

fn select[T](conditions []&Tensor[bool], choices []&Tensor[T], default T) !&Tensor[T]

select picks the value from the first choice whose condition is true at each output position. Conditions and choices broadcast to a common shape; default is used where no condition is true.

fn seq[T](n int, params TensorData) &Tensor[T]

seq exposes this operation as part of the public API.

fn sin(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

sin applies the complex sine to every element.

fn sinh(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

sinh applies the complex hyperbolic sine to every element.

fn slice_all(step int) !TensorIndex

slice_all selects the whole axis, optionally traversing it in reverse.

fn slice_from(start int, step int) !TensorIndex

slice_from selects from start through the end of the axis in step increments. A negative step traverses toward the beginning.

fn slice_index(start int, stop int, step int) !TensorIndex

slice_index selects an explicit Python-style [start:stop:step] range. Negative boundaries count from the end; a zero step is rejected.

fn slice_to(stop int, step int) !TensorIndex

slice_to selects from the beginning of the axis through stop in step increments.

fn sort[T](t &Tensor[T]) !&Tensor[T]

sort returns a copy sorted along the last axis, matching NumPy's default.

fn sort_axis[T](t &Tensor[T], axis int) !&Tensor[T]

sort_axis returns a copy sorted in ascending order along axis. Floating-point NaNs sort after all non-NaN values, and equal values keep their input order.

fn sqrt(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

sqrt applies the principal complex square root to every element.

fn stack[T](ts []&Tensor[T], data AxisData) !&Tensor[T]

stack join a sequence of arrays along a new axis.

fn student_t(degrees_of_freedom f64, shape []int, params TensorData) !&Tensor[f64]

student_t returns samples from the standard Student's t distribution using VTL's global random stream.

fn subtract_promoted[R, T, U](a &Tensor[T], b &Tensor[U]) !&Tensor[R]

subtract_promoted subtracts real numeric tensors after converting both operands to the explicitly selected NumPy-style promoted dtype. The output type R must match promote_types(dtype_ofT, dtype_ofU).

fn tan(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

tan applies the complex tangent to every element.

fn tanh(input &Tensor[complex.Complex]) !&Tensor[complex.Complex]

tanh applies the complex hyperbolic tangent to every element.

fn td[T](x T) TensorDataType

td exposes this operation as part of the public API.

fn tensor[T](init T, shape []int, params TensorData) &Tensor[T]

tensor allocates a Tensor onto specified device with a given data

fn tensor_like[T](t &Tensor[T]) &Tensor[T]

tensor_like returns a new tensor created with similar storage properties as the Tensor t

fn tensor_like_with_shape[T](t &Tensor[T], shape []int) &Tensor[T]

tensor_like_with_shape returns a new tensor created with similar storage properties as the Tensor t with a given shape

fn tile[T](t &Tensor[T], reps []int) !&Tensor[T]

tile repeats t as a block according to reps. Repetition dimensions align from the right; shorter reps are padded with ones on the left, as in NumPy.

fn triangular(left f64, mode f64, right f64, shape []int, params TensorData) !&Tensor[f64]

triangular returns samples from a triangular distribution using VTL's global stream.

fn tril[T](input &Tensor[T], options TriangularOptions) !&Tensor[T]

tril returns a copy with entries above the k-th diagonal of each trailing matrix set to zero. Inputs must have at least two dimensions.

fn triu[T](input &Tensor[T], options TriangularOptions) !&Tensor[T]

triu returns a copy with entries below the k-th diagonal of each trailing matrix set to zero. Inputs must have at least two dimensions.

fn unique[T](t &Tensor[T]) !&Tensor[T]

unique returns the sorted unique values in a flattened copy of the tensor. Floating-point NaNs are treated as one value and sort after other values.

fn unique_axis[T](t &Tensor[T], axis int) !&Tensor[T]

unique_axis returns lexicographically sorted unique slices along axis.

fn unique_axis_result[T](t &Tensor[T], axis int) !UniqueAxisResult[T]

unique_axis_result returns unique slices, occurrence counts, first source axis positions, and inverse indices aligned to the input axis.

fn unique_counts[T](t &Tensor[T]) !UniqueCounts[T]

unique_counts returns sorted unique values and the number of occurrences of each value in the flattened input tensor.

fn unique_first_indices[T](t &Tensor[T]) !&Tensor[int]

unique_first_indices returns the first flattened input index for each sorted unique value.

fn unique_inverse[T](t &Tensor[T]) !&Tensor[int]

unique_inverse returns the unique-value index for each flattened input element. Apply it to unique(t) to reconstruct the input values.

fn unravel_index(indices &Tensor[int], dimensions []int, options UnravelIndexOptions) ![]&Tensor[int]

unravel_index converts flat indices into one coordinate tensor per axis. Each returned tensor has the same shape as indices. Order selects C (row-major) or F (column-major) decoding.

fn vander[T](input &Tensor[T], params VandermondeData) !&Tensor[T]

vander returns a Vandermonde matrix built from a one-dimensional input. The default column count is input.size; powers descend by default and increase when requested, matching NumPy's vander convention. T must be a numeric element type.

fn vstack[T](ts []&Tensor[T]) !&Tensor[T]

vstack stack arrays in sequence vertically (row wise)

fn wald(mean f64, scale f64, shape []int, params TensorData) !&Tensor[f64]

wald returns samples from a Wald (inverse Gaussian) distribution using VTL's global stream.

fn weibull(shape_parameter f64, shape []int, params TensorData) !&Tensor[f64]

weibull returns samples from the unit-scale Weibull distribution using VTL's global random stream.

fn where[T](condition &Tensor[bool], x &Tensor[T], y &Tensor[T]) !&Tensor[T]

where selects elements from x or y according to condition, broadcasting all three tensors to their common shape. True condition elements select x.

fn zeros[T](shape []int, params TensorData) &Tensor[T]

zeros exposes this operation as part of the public API.

fn zeros_like[T](t &Tensor[T]) &Tensor[T]

zeros_like exposes this operation as part of the public API.

interface AnyTensor[T] {
	shape   []int
	strides []int
	cpu() &Tensor[T]
	vcl() !&Tensor[T]
	str() string
	rank() int
	size() int
	is_matrix() bool
	is_square_matrix() bool
	is_vector() bool
	is_row_major() bool
	is_col_major() bool
	is_row_major_contiguous() bool
	is_col_major_contiguous() bool
	is_contiguous() bool
mut:
	memory MemoryFormat
}

AnyTensor is an interface that allows for any tensor to be used in the vtl library

fn (array &MaskedArray[T]) filled[T](fill_value T) &Tensor[T]

filled returns a row-major copy with masked entries replaced by fill_value.

fn (array &MaskedArray[T]) compressed[T]() !&Tensor[T]

compressed returns all unmasked values as a one-dimensional copy in row-major logical order.

fn (array &MaskedArray[T]) mixed_index[T](indices []TensorIndex) !MaskedArray[T]

mixed_index applies NumPy-style mixed basic and advanced indexing to both values and mask, preserving their alignment and view/copy behavior.

fn (array &MaskedArray[T]) take_along_axis[T](indices &Tensor[int], axis int) !MaskedArray[T]

take_along_axis gathers matching values and mask entries using the same broadcastable index tensor.

fn (array &MaskedArray[T]) put_along_axis[T](indices &Tensor[int], updates &MaskedArray[T], axis int) !MaskedArray[T]

put_along_axis returns a copy with masked-array updates written along axis. Update values and masks must match the index shape and are broadcast under the same shape rules as Tensor.put_along_axis.

fn (array &MaskedArray[T]) count[T]() int

count returns the number of unmasked values.

fn (array &MaskedArray[T]) cumsum[T]() !MaskedArray[T]

cumsum returns the flattened cumulative sum of valid values. Masked entries stay masked in the result and do not change the running total.

fn (array &MaskedArray[T]) cumsum_along_axis[T](axis int) !MaskedArray[T]

cumsum_along_axis returns prefix sums along one axis. Masked entries remain masked and are skipped by the running total.

fn (array &MaskedArray[T]) cumsum_as[U]() !MaskedArray[U]

cumsum_as returns the flattened cumulative sum using an explicit output accumulator type. Masked positions remain masked and are skipped.

fn (array &MaskedArray[T]) cumsum_along_axis_as[U](axis int) !MaskedArray[U]

cumsum_along_axis_as returns cumulative sums along one axis using an explicit output accumulator type.

fn (array &MaskedArray[T]) cumprod[T]() !MaskedArray[T]

cumprod returns the flattened cumulative product of valid values. Masked entries stay masked in the result and do not change the running product.

fn (array &MaskedArray[T]) cumprod_along_axis[T](axis int) !MaskedArray[T]

cumprod_along_axis returns prefix products along one axis. Masked entries remain masked and are skipped by the running product.

fn (array &MaskedArray[T]) cumprod_as[U]() !MaskedArray[U]

cumprod_as returns the flattened cumulative product using an explicit output accumulator type. Masked positions remain masked and are skipped.

fn (array &MaskedArray[T]) cumprod_along_axis_as[U](axis int) !MaskedArray[U]

cumprod_along_axis_as returns cumulative products along one axis using an explicit output accumulator type.

fn (array &MaskedArray[T]) add[T](other &MaskedArray[T]) !MaskedArray[T]

add adds two masked arrays with broadcasting and combines their masks.

fn (array &MaskedArray[T]) subtract[T](other &MaskedArray[T]) !MaskedArray[T]

subtract subtracts another masked array with broadcasting.

fn (array &MaskedArray[T]) multiply[T](other &MaskedArray[T]) !MaskedArray[T]

multiply multiplies two masked arrays with broadcasting.

fn (array &MaskedArray[T]) divide[T](other &MaskedArray[T]) !MaskedArray[T]

divide divides by another masked array with broadcasting.

fn (array &MaskedArray[T]) equal[T](other &MaskedArray[T]) !MaskedArray[bool]

equal performs a broadcasted equality comparison and masks invalid pairs.

fn (array &MaskedArray[T]) not_equal[T](other &MaskedArray[T]) !MaskedArray[bool]

not_equal performs a broadcasted inequality comparison and masks invalid pairs.

fn (array &MaskedArray[T]) less_than[T](other &MaskedArray[T]) !MaskedArray[bool]

less_than compares values with < and masks invalid pairs.

fn (array &MaskedArray[T]) less_equal[T](other &MaskedArray[T]) !MaskedArray[bool]

less_equal compares values with <= and masks invalid pairs.

fn (array &MaskedArray[T]) greater_than[T](other &MaskedArray[T]) !MaskedArray[bool]

greater_than compares values with > and masks invalid pairs.

fn (array &MaskedArray[T]) greater_equal[T](other &MaskedArray[T]) !MaskedArray[bool]

greater_equal compares values with >= and masks invalid pairs.

fn (array &MaskedArray[T]) add_scalar[T](scalar T) !MaskedArray[T]

add_scalar adds a valid scalar to every value and preserves the mask.

fn (array &MaskedArray[T]) subtract_scalar[T](scalar T) !MaskedArray[T]

subtract_scalar subtracts a valid scalar from every value and preserves the mask.

fn (array &MaskedArray[T]) multiply_scalar[T](scalar T) !MaskedArray[T]

multiply_scalar multiplies every value by a valid scalar and preserves the mask.

fn (array &MaskedArray[T]) divide_scalar[T](scalar T) !MaskedArray[T]

divide_scalar divides every value by a valid scalar and preserves the mask.

fn (array &MaskedArray[T]) sum[T]() MaskedValue[T]

sum reduces all unmasked values. An entirely masked array returns a masked additive identity with value zero.

fn (array &MaskedArray[T]) prod[T]() MaskedValue[T]

prod reduces all unmasked values. An entirely masked array returns a masked multiplicative identity with value one.

fn (array &MaskedArray[T]) min[T]() MaskedValue[T]

min returns the smallest unmasked value. An entirely masked array returns a masked result whose value is zero and must be ignored.

fn (array &MaskedArray[T]) max[T]() MaskedValue[T]

max returns the largest unmasked value. An entirely masked array returns a masked result whose value is zero and must be ignored.

fn (array &MaskedArray[T]) argmin[T]() MaskedValue[int]

argmin returns the flat logical index of the first smallest unmasked value. An entirely masked array returns a masked result with index zero.

fn (array &MaskedArray[T]) argmax[T]() MaskedValue[int]

argmax returns the flat logical index of the first largest unmasked value. An entirely masked array returns a masked result with index zero.

fn (array &MaskedArray[T]) argmin_along_axis[T](axis int, keepdims bool) !MaskedArray[int]

argmin_along_axis returns the first minimum index in each axis slice. Slices with no unmasked values are marked in the output mask.

fn (array &MaskedArray[T]) argmax_along_axis[T](axis int, keepdims bool) !MaskedArray[int]

argmax_along_axis returns the first maximum index in each axis slice. Slices with no unmasked values are marked in the output mask.

fn (array &MaskedArray[T]) mean[T]() MaskedValue[f64]

mean reduces all unmasked values. An entirely masked array returns a masked NaN result.

fn (array &MaskedArray[T]) variance[T](ddof int) !MaskedValue[f64]

variance computes population or sample variance over unmasked values. ddof is subtracted from the valid count; insufficient data returns a masked NaN.

fn (array &MaskedArray[T]) std[T](ddof int) !MaskedValue[f64]

std computes population or sample standard deviation over unmasked values.

fn (array &MaskedArray[T]) quantile[T](q f64) !MaskedValue[f64]

quantile computes NumPy's default linearly interpolated quantile over all unmasked values. An entirely masked or empty array returns a masked NaN.

fn (array &MaskedArray[T]) quantile_with_method[T](q f64, method QuantileMethod) !MaskedValue[f64]

quantile_with_method computes a selected NumPy-compatible quantile over all unmasked values. An entirely masked or empty array returns a masked NaN.

fn (array &MaskedArray[T]) median[T]() MaskedValue[f64]

median computes the median of all unmasked values.

fn (array &MaskedArray[T]) percentile[T](percentile f64) !MaskedValue[f64]

percentile computes a linearly interpolated percentile over unmasked values.

fn (array &MaskedArray[T]) percentile_with_method[T](percentile f64, method QuantileMethod) !MaskedValue[f64]

percentile_with_method computes a selected percentile over unmasked values.

fn (array &MaskedArray[T]) quantile_along_axis[T](axis int, q f64, keepdims bool) !MaskedArray[f64]

quantile_along_axis computes one quantile per slice, optionally retaining the reduced axis with length one.

fn (array &MaskedArray[T]) quantile_along_axis_with_method[T](axis int, q f64, method QuantileMethod, keepdims bool) !MaskedArray[f64]

quantile_along_axis_with_method computes one selected quantile per slice.

fn (array &MaskedArray[T]) percentile_along_axis[T](axis int, percentile f64, keepdims bool) !MaskedArray[f64]

percentile_along_axis computes one percentile per axis slice.

fn (array &MaskedArray[T]) percentile_along_axis_with_method[T](axis int, percentile f64, method QuantileMethod, keepdims bool) !MaskedArray[f64]

percentile_along_axis_with_method computes a selected percentile per slice.

fn (array &MaskedArray[T]) quantile_along_axes[T](axes []int, q f64, keepdims bool) !MaskedArray[f64]

quantile_along_axes computes one quantile per slice over several axes. Slices with no valid values have a NaN payload and a true output mask.

fn (array &MaskedArray[T]) quantile_along_axes_with_method[T](axes []int, q f64, method QuantileMethod, keepdims bool) !MaskedArray[f64]

quantile_along_axes_with_method reduces multiple axes with a selected estimator. Slices with no valid values have a NaN payload and true mask.

fn (array &MaskedArray[T]) percentile_along_axes[T](axes []int, percentile f64, keepdims bool) !MaskedArray[f64]

percentile_along_axes computes one percentile per slice over several axes.

fn (array &MaskedArray[T]) percentile_along_axes_with_method[T](axes []int, percentile f64, method QuantileMethod, keepdims bool) !MaskedArray[f64]

percentile_along_axes_with_method reduces several axes with a selected estimator on the 0..100 percentile scale.

fn (array &MaskedArray[T]) median_along_axis[T](axis int, keepdims bool) !MaskedArray[f64]

median_along_axis computes the median of each unmasked axis slice.

fn (array &MaskedArray[T]) median_along_axes[T](axes []int, keepdims bool) !MaskedArray[f64]

median_along_axes computes medians over several axes.

fn (array &MaskedArray[T]) sum_along_axis[T](axis int, keepdims bool) !MaskedArray[T]

sum_along_axis reduces unmasked values along one axis. Output mask entries are true for slices containing no unmasked values.

fn (array &MaskedArray[T]) sum_along_axes[T](axes []int, keepdims bool) !MaskedArray[T]

sum_along_axes reduces unmasked values over several axes. Negative axes are supported; duplicate axes are rejected. An empty axes list preserves data.

fn (array &MaskedArray[T]) prod_along_axis[T](axis int, keepdims bool) !MaskedArray[T]

prod_along_axis multiplies unmasked values along one axis.

fn (array &MaskedArray[T]) prod_along_axes[T](axes []int, keepdims bool) !MaskedArray[T]

prod_along_axes multiplies unmasked values over several axes. Negative axes are supported; duplicate axes are rejected. An empty axes list preserves data.

fn (array &MaskedArray[T]) min_along_axis[T](axis int, keepdims bool) !MaskedArray[T]

min_along_axis finds the smallest unmasked value in each axis slice.

fn (array &MaskedArray[T]) min_along_axes[T](axes []int, keepdims bool) !MaskedArray[T]

min_along_axes finds minima across several axes. Empty slices are masked.

fn (array &MaskedArray[T]) max_along_axis[T](axis int, keepdims bool) !MaskedArray[T]

max_along_axis finds the largest unmasked value in each axis slice.

fn (array &MaskedArray[T]) max_along_axes[T](axes []int, keepdims bool) !MaskedArray[T]

max_along_axes finds maxima across several axes. Empty slices are masked.

fn (array &MaskedArray[T]) variance_along_axis[T](axis int, ddof int, keepdims bool) !MaskedArray[f64]

variance_along_axis computes variance along one axis, marking slices with insufficient valid values as masked NaN results.

fn (array &MaskedArray[T]) variance_along_axes[T](axes []int, ddof int, keepdims bool) !MaskedArray[f64]

variance_along_axes computes population or sample variance over several axes. Empty axes compute elementwise zero variance for valid values.

fn (array &MaskedArray[T]) std_along_axis[T](axis int, ddof int, keepdims bool) !MaskedArray[f64]

std_along_axis computes standard deviation along one axis.

fn (array &MaskedArray[T]) std_along_axes[T](axes []int, ddof int, keepdims bool) !MaskedArray[f64]

std_along_axes computes standard deviation over several axes.

fn (array &MaskedArray[T]) mean_along_axis[T](axis int, keepdims bool) !MaskedArray[f64]

mean_along_axis computes the mean of unmasked values per axis slice. Slices with no unmasked values carry a masked NaN result.

fn (array &MaskedArray[T]) mean_along_axes[T](axes []int, keepdims bool) !MaskedArray[f64]

mean_along_axes computes means over several axes. Negative axes are supported; duplicate axes are rejected. An empty axes list converts each unmasked value to f64 and preserves the mask.

fn (array &MaskedArray[T]) weighted_average[T, W](weights &Tensor[W]) !MaskedValue[f64]

weighted_average computes a weighted mean over valid values. Weights must broadcast to the values shape; masked observations do not contribute either their value or their weight. An entirely masked array returns masked NaN.

fn (array &MaskedArray[T]) weighted_average_along_axis[T, W](weights &Tensor[W], axis int, keepdims bool) !MaskedArray[f64]

weighted_average_along_axis computes weighted means per slice. Weights may broadcast to the values shape or be a vector matching the selected axis.

fn (array &MaskedArray[T]) weighted_average_along_axes[T, W](weights &Tensor[W], axes []int, keepdims bool) !MaskedArray[f64]

weighted_average_along_axes reduces several dimensions. Weights must broadcast to the values shape; empty slices are masked and zero-sum valid weights return an error.

fn (mut s TensorAxisIterator[T]) next[T]() ?(T, []int)

next exposes this operation as part of the public API.

type TensorDataType = bool
	| f32
	| f64
	| i16
	| i32
	| i64
	| i8
	| int
	| string
	| u16
	| u32
	| u64
	| u8

TensorDataType is a sum type that lists the possible types to be used to define storage