Struct Tensor 

pub struct Tensor<T: WithDType>(/* private fields */);

Implementations

impl<T: WithDType> Tensor<T>

pub fn dims0(&self) -> Result<()>

impl<T: WithDType> Tensor<T>

pub fn dims1(&self) -> Result<usize>

impl<T: WithDType> Tensor<T>

pub fn dims2(&self) -> Result<(usize, usize)>

impl<T: WithDType> Tensor<T>

pub fn dims3(&self) -> Result<(usize, usize, usize)>

impl<T: WithDType> Tensor<T>

pub fn dims4(&self) -> Result<(usize, usize, usize, usize)>

impl<T: WithDType> Tensor<T>

pub fn dims5(&self) -> Result<(usize, usize, usize, usize, usize)>

impl<T: WithDType> Tensor<T>

pub fn new<A: ToTensor<T>>(array: A) -> Result<Self>

Creates a new Tensor from any supported Rust array or slice.

use lumen_core::Tensor;

let a = Tensor::new(&[1, 2, 3]).unwrap();
println!("{}", a.shape());

pub fn full<S: Into<Shape>>(shape: S, value: T) -> Result<Self>

Creates an array full with a constant value.

use lumen_core::Tensor;

let a = Tensor::full((2, 2), 7).unwrap();
println!("{}", a);

pub fn empty<S: Into<Shape>>(shape: S) -> Result<Self>

Creates a new Tensor with un initialze value!

pub fn meta<S: Into<Shape>>(shape: S) -> Result<Self>

Creates a new Tensor no storage

impl<T: WithDType> Tensor<T>

pub fn zeros<S: Into<Shape>>(shape: S) -> Result<Self>

Creates an array of zeros with the given shape.

use lumen_core::Tensor;

let a = Tensor::<f32>::zeros((2, 3)).unwrap();
println!("{}", a);

pub fn zeros_like(&self) -> Result<Self>

Creates a zero-filled array with the same shape as self.

use lumen_core::Tensor;

let a = Tensor::<i32>::ones((2, 2)).unwrap();
let b = a.zeros_like().unwrap();
println!("{}", b);

pub fn ones<S: Into<Shape>>(shape: S) -> Result<Self>

Creates an array of ones with the given shape.

use lumen_core::Tensor;

let a = Tensor::<f64>::ones((3, 3)).unwrap();
println!("{}", a);

pub fn ones_like(&self) -> Result<Self>

Creates a one-filled array with the same shape as self.

impl<T: NumDType> Tensor<T>

pub fn arange(start: T, end: T) -> Result<Self>

Creates a 1-D array with values from start up to (but not including) end.

use lumen_core::Tensor;

let a = Tensor::arange(0., 5.).unwrap();
println!("{}", a);

impl<T: WithDType> Tensor<T>

pub fn from_vec<V: Into<Vec<T>>, S: Into<Shape>>( vec: V, shape: S, ) -> Result<Self>

Creates an array from a flat Vec<T> and explicit shape.

use lumen_core::Tensor;

let a = Tensor::from_vec(vec![1, 2, 3, 4], (2, 2)).unwrap();
println!("{}", a);

pub fn diag(diag: &[T]) -> Result<Self>

impl<T: NumDType> Tensor<T>

pub fn rand<S: Into<Shape>>(min: T, max: T, shape: S) -> Result<Self>

Creates an array with uniformly distributed random values in [min, max).

use lumen_core::Tensor;

let a = Tensor::<f32>::rand(0., 1., (2, 3)).unwrap();
println!("{}", a);

pub fn rand_like(&self, min: T, max: T) -> Result<Self>

Creates a random array with the same shape as self.

impl<F: FloatDType> Tensor<F>

pub fn linspace(start: F, stop: F, num: usize) -> Result<Self>

Generate a 1-D Tensor of num evenly spaced values over the interval [start, stop).

Example

let arr = Tensor::linspace(0.0, 1.0, 5).unwrap();
assert_eq!(arr.to_vec().unwrap(), [0.0, 0.2, 0.4, 0.6000000000000001, 0.8]);

impl<F: FloatDType> Tensor<F>

pub fn randn<S: Into<Shape>>(mean: F, std: F, shape: S) -> Result<Self>

Creates an array with normally distributed random values with given mean and std.

use lumen_core::Tensor;

let a = Tensor::<f64>::randn(0.0, 1.0, (2, 2)).unwrap();
println!("{}", a);

pub fn randn_like(&self, mean: F, std: F) -> Result<Self>

Creates a normal-distributed random array with the same shape as self.

impl<T: WithDType> Tensor<T>

pub fn eye(size: usize) -> Result<Self>

pub fn tril(size: usize, diagonal: bool) -> Result<Self>

pub fn triu(size: usize, diagonal: bool) -> Result<Self>

impl<T: FloatDType> Tensor<T>

pub fn new_var<A: ToTensor<T>>(array: A) -> Result<Self>

pub fn empty_var<S: Into<Shape>>(shape: S) -> Result<Self>

pub fn meta_var<S: Into<Shape>>(shape: S) -> Result<Self>

pub fn full_var<S: Into<Shape>>(shape: S, value: T) -> Result<Self>

pub fn zeros_var<S: Into<Shape>>(shape: S) -> Result<Self>

pub fn zeros_like_var(&self) -> Result<Self>

pub fn ones_var<S: Into<Shape>>(shape: S) -> Result<Self>

pub fn ones_like_var(&self) -> Result<Self>

pub fn arange_var(start: T, end: T) -> Result<Self>

pub fn from_vec_var<V: Into<Vec<T>>, S: Into<Shape>>( vec: V, shape: S, ) -> Result<Self>

pub fn eye_var(size: usize) -> Result<Self>

pub fn tril_var(size: usize, diagonal: bool) -> Result<Self>

pub fn triu_var(size: usize, diagonal: bool) -> Result<Self>

pub fn diag_var(diag: &[T]) -> Result<Self>

pub fn linspace_var(start: T, stop: T, num: usize) -> Result<Self>

pub fn randn_var<S: Into<Shape>>(mean: T, std: T, shape: S) -> Result<Self>

pub fn rand_var<S: Into<Shape>>(min: T, max: T, shape: S) -> Result<Self>

impl Tensor<bool>

pub fn trues<S: Into<Shape>>(shape: S) -> Result<Self>

Creates a boolean array filled with true.

use lumen_core::Tensor;

let a = Tensor::trues((2, 2)).unwrap();
println!("{}", a);

pub fn falses<S: Into<Shape>>(shape: S) -> Result<Self>

Creates a boolean array filled with false.

impl<T: WithDType> Tensor<T>

pub fn indexes(&self, indexers: &[Indexer]) -> Result<Self>

pub fn get(&self, i: usize) -> Result<Self>

Returns the sub-tensor fixing the index at i on the first dimension.

use lumen_core::Tensor;
let tensor = Tensor::<f32>::new(&[[0f32, 1.], [2., 3.], [4., 5.]]).unwrap();
let t = tensor.get(0).unwrap();
assert_eq!(t.to_vec().unwrap(), &[0., 1.]);
let t = tensor.get(1).unwrap();
assert_eq!(t.to_vec().unwrap(), &[2., 3.]);

pub fn index_select<D: Dim>( &self, indexes: impl Into<IntTensor>, dim: D, ) -> Result<Self>

pub fn gather<D: Dim>( &self, indexes: impl Into<IntTensor>, dim: D, ) -> Result<Self>

Gather values across the target dimension.

Arguments

• self - The input tensor.
• indexes - The indices of elements to gather, this should have same number of dimensions as self and indexes.dims()[d] <= self.dims()[d] for all dimensions d != dim
• dim - the target dimension.

The resulting tensor has the same shape as indexes and use values from self indexed on dimension dim by the values in indexes.

impl<T: NumDType> Tensor<T>

pub fn index_add<D: Dim>( &self, indexes: impl Into<IntTensor>, source: &Tensor<T>, dim: D, ) -> Result<Self>

pub fn scatter_add<D: Dim>( &self, indexes: impl Into<IntTensor>, source: &Self, dim: D, ) -> Result<Self>

impl<T: WithDType> Tensor<T>

pub fn matrix_get(&self, row: usize, col: usize) -> Result<T>

pub fn matrix_set(&self, row: usize, col: usize, val: T) -> Result<()>

pub fn vector_get(&self, n: usize) -> Result<T>

impl<T: WithDType> Tensor<T>

pub fn iter(&self) -> Result<TensorIter<'_, T>>

impl<T: WithDType> Tensor<T>

pub fn squeeze<D: Dim>(&self, dim: D) -> Result<Self>

Creates a new tensor with the specified dimension removed if its size was one.

use lumen_core::{Tensor, DType, D};
let a = Tensor::<f32>::zeros((2, 3, 1)).unwrap();

let c = a.squeeze(2).unwrap();
assert_eq!(c.shape().dims(), &[2, 3]);

pub fn unsqueeze<D: Dim>(&self, dim: D) -> Result<Self>

Creates a new tensor with a dimension of size one inserted at the specified position.

use lumen_core::{Tensor, DType, D};
let a = Tensor::<f32>::zeros((2, 3)).unwrap();

let c = a.unsqueeze(0).unwrap();
assert_eq!(c.shape().dims(), &[1, 2, 3]);

let c = a.unsqueeze(D::Minus1).unwrap();
assert_eq!(c.shape().dims(), &[2, 3, 1]);

pub fn narrow<D: Dim>(&self, dim: D, start: usize, len: usize) -> Result<Self>

Returns a new tensor that is a narrowed version of the input, the dimension dim ranges from start to start + len.

use lumen_core::Tensor;
let a = Tensor::new(&[
    [0f32, 1., 2.],
    [3.  , 4., 5.],
    [6.  , 7., 8.]
]).unwrap();

let b = a.narrow(0, 1, 2).unwrap();
assert_eq!(b.shape().dims(), &[2, 3]);

let c = a.narrow(1, 1, 1).unwrap();
assert_eq!(c.shape().dims(), &[3, 1]);

pub fn slice<D: Dim>(&self, dim: D, slice: &Slice) -> Result<Self>

Returns a new tensor that is a narrowed version of the input, the dimension dim slice from start to start : end : step.

use lumen_core::{Tensor, DType, s, Slice};
let a = Tensor::<i32>::zeros((5, 5, 5)).unwrap();

let b = a.narrow(0, 1, 2).unwrap();
assert_eq!(b.shape().dims(), &[2, 5, 5]);

let c = a.slice(1, &s!(::2)).unwrap();
assert_eq!(c.shape().dims(), &[5, 3, 5]);

pub fn reshape<S: Into<Shape>>(&self, shape: S) -> Result<Self>

Reshape returns a tensor with the target shape provided that the number of elements of the original tensor is the same. If the input tensor is contiguous, this is a view on the original data. Otherwise this uses a new storage and copies the data over, the returned tensor is always contiguous.

The shape can be specified using a tuple of usize and at most one () in which case the behavior is the same as when using -1 in PyTorch: this dimension size is adjusted so as to match the number of elements in the tensor.

use lumen_core::{Tensor, DType, D};
let a = Tensor::<f32>::zeros((2, 3)).unwrap();

let c = a.reshape((1, 6)).unwrap();
assert_eq!(c.shape().dims(), &[1, 6]);

pub fn transpose<D1: Dim, D2: Dim>(&self, dim1: D1, dim2: D2) -> Result<Self>

Returns a Tensor that is a transposed version of the input, the given dimensions are

pub fn transpose_last(&self) -> Result<Self>

pub fn permute<D: Dims>(&self, dims: D) -> Result<Self>

Returns a tensor with the same data as the input where the dimensions have been permuted. dims must be a permutation, i.e. include each dimension index exactly once.

use lumen_core::Tensor;
let tensor = Tensor::<u32>::arange(0u32, 120u32).unwrap().reshape((2, 3, 4, 5)).unwrap();
assert_eq!(tensor.dims(), &[2, 3, 4, 5]);
let tensor = tensor.permute((2, 3, 1, 0)).unwrap();
assert_eq!(tensor.dims(), &[4, 5, 3, 2]);

pub fn cat<A: AsRef<Tensor<T>>, D: Dim>(arrs: &[A], dim: D) -> Result<Self>

Concatenates two or more tensors along a particular dimension.

All tensors must of the same rank, and the output will have the same rank

use lumen_core::Tensor;
let a = Tensor::<f32>::zeros((2, 3)).unwrap();
let b = Tensor::<f32>::zeros((2, 3)).unwrap();

let c = Tensor::cat(&[&a, &b], 0).unwrap();
assert_eq!(c.dims(), &[4, 3]);

let c = Tensor::cat(&[&a, &b], 1).unwrap();
assert_eq!(c.dims(), &[2, 6]);

pub fn stack<A: AsRef<Tensor<T>>, D: Dim>(args: &[A], dim: D) -> Result<Self>

Stacks two or more tensors along a particular dimension.

All tensors must have the same rank, and the output has one additional rank

use lumen_core::Tensor;
let a = Tensor::<f32>::zeros((2, 3)).unwrap();
let b = Tensor::<f32>::zeros((2, 3)).unwrap();

let c = Tensor::stack(&[&a, &b], 0).unwrap();
assert_eq!(c.dims(), &[2, 2, 3]);

let c = Tensor::stack(&[&a, &b], 2).unwrap();
assert_eq!(c.dims(), &[2, 3, 2]);

pub fn split<D: Dim>(&self, dim: D) -> Result<Vec<Self>>

Splits a tensor along a specified dimension into multiple sub-tensors.

The tensor is split along the given dim into as many sub-tensors as the size of that dimension. Each sub-tensor has the same shape as the original tensor, except the size along dim becomes 1.

use lumen_core::Tensor;

let a = Tensor::new(&[[1, 2], [3, 4], [5, 6]]).unwrap();

// Split along axis 0 (rows)
let splits = a.split(0).unwrap();
assert_eq!(splits.len(), 3);
assert_eq!(splits[0].to_vec().unwrap(), [1, 2]);
assert_eq!(splits[1].to_vec().unwrap(), [3, 4]);
assert_eq!(splits[2].to_vec().unwrap(), [5, 6]);

// Split along axis 1 (columns)
let splits = a.split(1).unwrap();
assert_eq!(splits.len(), 2);
assert_eq!(splits[0].to_vec().unwrap(), [1, 3, 5]);
assert_eq!(splits[1].to_vec().unwrap(), [2, 4, 6]);

// 1D array
let b = Tensor::new(&[10, 20, 30]).unwrap();
let splits = b.split(0).unwrap();
assert_eq!(splits.len(), 3);
assert_eq!(splits[0].to_vec().unwrap(), [10]);
assert_eq!(splits[1].to_vec().unwrap(), [20]);
assert_eq!(splits[2].to_vec().unwrap(), [30]);

pub fn chunk<D: Dim>(&self, chunks: usize, dim: D) -> Result<Vec<Self>>

Split a tensor into the specified number of chunks, this may return less chunks than specified.

pub fn flatten<D1: Dim, D2: Dim>( &self, start_dim: D1, end_dim: D2, ) -> Result<Self>

Flattens the input tensor on the dimension indexes from start_dim to end_dim (both inclusive).

pub fn flatten_to<D: Dim>(&self, end_dim: D) -> Result<Self>

Flattens the input tensor on the dimension indexes from 0 to end_dim (inclusive).

pub fn flatten_from<D: Dim>(&self, start_dim: D) -> Result<Self>

Flattens the input tensor on the dimension indexes from start_dim (inclusive) to the last dimension.

pub fn flatten_all(&self) -> Result<Self>

Flattens the input tensor by reshaping it into a one dimension tensor.

use lumen_core::Tensor;
let arr = Tensor::new(&[[0f32, 1.], [2., 3.], [4., 5.]]).unwrap();
let arr = arr.flatten_all().unwrap();
let len = arr.dims1().unwrap();
assert_eq!(len, 6);
assert_eq!(arr.to_vec().unwrap(), [0., 1., 2., 3., 4., 5.]);

pub fn repeat<S: Into<Shape>>(&self, shape: S) -> Result<Self>

Repeat this tensor along the specified dimensions.

pub fn repeat_dim<D: Dim>(&self, dim: D, times: usize) -> Result<Self>

Repeat this tensor along the specified dimension with specified times

impl<T: NumDType> Tensor<T>

pub fn add_tensor(&self, rhs: &Self) -> Result<Self>

pub fn add_scalar(&self, rhs: T) -> Result<Self>

pub fn scalar_add(lhs: T, rhs: &Tensor<T>) -> Result<Tensor<T>>

pub fn add(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Self>

pub fn mul_tensor(&self, rhs: &Self) -> Result<Self>

pub fn mul_scalar(&self, rhs: T) -> Result<Self>

pub fn scalar_mul(lhs: T, rhs: &Tensor<T>) -> Result<Tensor<T>>

pub fn mul(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Self>

pub fn sub_tensor(&self, rhs: &Self) -> Result<Self>

pub fn sub_scalar(&self, rhs: T) -> Result<Self>

pub fn scalar_sub(lhs: T, rhs: &Tensor<T>) -> Result<Tensor<T>>

pub fn sub(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Self>

pub fn div_tensor(&self, rhs: &Self) -> Result<Self>

pub fn div_scalar(&self, rhs: T) -> Result<Self>

pub fn scalar_div(lhs: T, rhs: &Tensor<T>) -> Result<Tensor<T>>

pub fn div(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Self>

pub fn minimum_tensor(&self, rhs: &Self) -> Result<Self>

pub fn minimum_scalar(&self, rhs: T) -> Result<Self>

pub fn scalar_minimum(lhs: T, rhs: &Tensor<T>) -> Result<Tensor<T>>

pub fn minimum(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Self>

pub fn maximum_tensor(&self, rhs: &Self) -> Result<Self>

pub fn maximum_scalar(&self, rhs: T) -> Result<Self>

pub fn scalar_maximum(lhs: T, rhs: &Tensor<T>) -> Result<Tensor<T>>

pub fn maximum(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Self>

pub fn clamp(&self, min: T, max: T) -> Result<Self>

impl<T: NumDType> Tensor<T>

pub fn add_(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Self>

pub fn sub_(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Self>

pub fn mul_(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Self>

pub fn div_(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Self>

impl<T: NumDType> Tensor<T>

pub fn eq(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Tensor<bool>>

pub fn ne(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Tensor<bool>>

pub fn le(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Tensor<bool>>

pub fn ge(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Tensor<bool>>

pub fn lt(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Tensor<bool>>

pub fn gt(&self, rhs: impl Into<TensorOrScalar<T>>) -> Result<Tensor<bool>>

pub fn cmp( &self, rhs: impl Into<TensorOrScalar<T>>, op: CmpOp, ) -> Result<Tensor<bool>>

impl Tensor<bool>

pub fn and(&self, rhs: impl Into<TensorOrScalar<bool>>) -> Result<Tensor<bool>>

pub fn or(&self, rhs: impl Into<TensorOrScalar<bool>>) -> Result<Tensor<bool>>

pub fn xor(&self, rhs: impl Into<TensorOrScalar<bool>>) -> Result<Tensor<bool>>

pub fn not(&self) -> Result<Tensor<bool>>

impl<T: NumDType> Tensor<T>

pub fn affine(&self, mul: T, add: T) -> Result<Self>

pub fn affine_assign(&self, mul: T, add: T) -> Result<()>

impl<T: WithDType> Tensor<T>

pub fn map<F, O>(&self, f: F) -> Result<Tensor<O>>

where O: WithDType, F: Fn(T) -> O,

pub fn map_assign<F>(&self, f: F) -> Result<()>

where F: Fn(T) -> T,

impl<T: NumDType + Neg<Output = T>> Tensor<T>

pub fn neg(&self) -> Result<Self>

impl<F: FloatDType> Tensor<F>

pub fn floor(&self) -> Result<Self>

pub fn ceil(&self) -> Result<Self>

pub fn round(&self) -> Result<Self>

pub fn exp(&self) -> Result<Self>

pub fn ln(&self) -> Result<Self>

pub fn sin(&self) -> Result<Self>

pub fn cos(&self) -> Result<Self>

pub fn tanh(&self) -> Result<Self>

pub fn sqrt(&self) -> Result<Self>

pub fn sqr(&self) -> Result<Self>

pub fn abs(&self) -> Result<Self>

pub fn recip(&self) -> Result<Self>

pub fn gelu(&self) -> Result<Self>

pub fn gelu_erf(&self) -> Result<Self>

pub fn erf(&self) -> Result<Self>

pub fn relu(&self) -> Result<Self>

pub fn silu(&self) -> Result<Self>

pub fn sigmoid(&self) -> Result<Self>

pub fn leaky_relu(&self, negative_slope: F) -> Result<Self>

impl<F: FloatDType> Tensor<F>

pub fn pow(&self, e: F) -> Result<Self>

impl<T: NumDType> Tensor<T>

pub fn matmul(&self, rhs: &Self) -> Result<Self>

Returns the matrix-multiplication of the input tensor with the other provided tensor.

Arguments

• self - A tensor with dimensions b1, b2, ..., bi, m, k.
• rhs - A tensor with dimensions b1, b2, ..., bi, k, n.

The resulting tensor has dimensions b1, b2, ..., bi, m, n.

impl<T: NumDType> Tensor<T>

pub fn sum<D: Dim>(&self, axis: D) -> Result<Self>

pub fn sum_keepdim<D: Dim>(&self, axis: D) -> Result<Self>

pub fn sum_all(&self) -> Result<Self>

pub fn min<D: Dim>(&self, axis: D) -> Result<Self>

pub fn min_keepdim<D: Dim>(&self, axis: D) -> Result<Self>

pub fn min_all(&self) -> Result<Self>

pub fn max<D: Dim>(&self, axis: D) -> Result<Self>

pub fn max_keepdim<D: Dim>(&self, axis: D) -> Result<Self>

pub fn max_all(&self) -> Result<Self>

pub fn mean<D: Dim>(&self, axis: D) -> Result<Self>

pub fn mean_keepdim<D: Dim>(&self, axis: D) -> Result<Self>

pub fn mean_all(&self) -> Result<Self>

pub fn var_keepdim<D: Dim>(&self, axis: D) -> Result<Self>

pub fn var_unbiased_keepdim<D: Dim>(&self, axis: D) -> Result<Self>

pub fn var<D: Dim>(&self, axis: D) -> Result<Self>

pub fn var_unbiased<D: Dim>(&self, axis: D) -> Result<Self>

pub fn var_all(&self) -> Result<Self>

pub fn var_unbiased_all(&self) -> Result<Self>

pub fn argmin_keepdim<D: Dim>(&self, axis: D) -> Result<Tensor<u32>>

pub fn argmin<D: Dim>(&self, axis: D) -> Result<Tensor<u32>>

pub fn argmax_keepdim<D: Dim>(&self, axis: D) -> Result<Tensor<u32>>

pub fn argmax<D: Dim>(&self, axis: D) -> Result<Tensor<u32>>

impl Tensor<bool>

pub fn all(&self) -> Result<bool>

pub fn any(&self) -> Result<bool>

pub fn all_axis<D: Dim>(&self, axis: D) -> Result<Tensor<bool>>

pub fn any_axis<D: Dim>(&self, axis: D) -> Result<Tensor<bool>>

impl<T: WithDType> Tensor<T>

pub fn broadcast_as<S: Into<Shape>>(&self, shape: S) -> Result<Self>

Broadcast the input tensor to the target shape. This returns an error if the input shape is not compatible with the target shape.

If the input shape is i_1, i_2, ... i_k, the target shape has to have k dimensions or more and shape j_1, ..., j_l, t_1, t_2, ..., t_k. The dimensions j_1 to j_l can have any value, the dimension t_a must be equal to i_a if i_a is different from 1. If i_a is equal to 1, any value can be used.

impl<T: NumDType> Tensor<T>

pub fn broadcast_add(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_mul(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_sub(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_div(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_maximum(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_minimum(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_eq(&self, rhs: &Self) -> Result<Tensor<bool>>

pub fn broadcast_ne(&self, rhs: &Self) -> Result<Tensor<bool>>

pub fn broadcast_lt(&self, rhs: &Self) -> Result<Tensor<bool>>

pub fn broadcast_le(&self, rhs: &Self) -> Result<Tensor<bool>>

pub fn broadcast_gt(&self, rhs: &Self) -> Result<Tensor<bool>>

pub fn broadcast_ge(&self, rhs: &Self) -> Result<Tensor<bool>>

impl<T: WithDType> Tensor<T>

pub fn contiguous(&self) -> Result<Tensor<T>>

pub fn copy(&self) -> Result<Self>

pub fn copy_from(&self, source: &Self) -> Result<()>

pub fn assign(&self, source: impl Into<TensorOrScalar<T>>) -> Result<()>

impl<From: WithDType> Tensor<From>

pub fn cast<To: WithDType>(&self) -> Result<Tensor<To>>

where From: DTypeConvert<To>,

impl Tensor<bool>

pub fn if_else<T: WithDType>( &self, true_val: impl Into<TensorOrScalar<T>>, false_val: impl Into<TensorOrScalar<T>>, ) -> Result<Tensor<T>>

pub fn true_count(&self) -> Result<usize>

pub fn false_count(&self) -> Result<usize>

impl<T: WithDType> Tensor<T>

pub fn masked_fill( &self, mask: &Tensor<bool>, value: impl Into<TensorOrScalar<T>>, ) -> Result<Tensor<T>>

impl<T: WithDType> Tensor<T>

pub fn is_scalar(&self) -> bool

pub fn check_scalar(&self) -> Result<()>

pub fn to_scalar(&self) -> Result<T>

pub fn set_scalar(&self, val: T) -> Result<()>

pub fn storage_ref<'a>( &'a self, start_offset: usize, ) -> Result<StorageRef<'a, T>>

pub fn storage_mut<'a>( &'a self, start_offset: usize, ) -> Result<StorageMut<'a, T>>

pub fn storage_ptr(&self, start_offset: usize) -> Result<*mut T>

pub fn is_meta(&self) -> bool

impl<T: WithDType> Tensor<T>

pub fn id(&self) -> TensorId

pub fn shape(&self) -> &Shape

pub fn dtype(&self) -> DType

pub fn layout(&self) -> &Layout

pub fn dims(&self) -> &[usize]

pub fn dim<D: Dim>(&self, dim: D) -> Result<usize>

pub fn storage_read(&self) -> Result<RwLockReadGuard<'_, Storage<T>>>

pub fn storage_write(&self) -> Result<RwLockWriteGuard<'_, Storage<T>>>

pub fn element_count(&self) -> usize

pub fn is_contiguous(&self) -> bool

pub fn rank(&self) -> usize

pub fn to_vec(&self) -> Result<Vec<T>>

pub fn storage_indices(&self) -> StorageIndices<'_>

Returns an iterator over storage indices.

This iterator yields the linear (flat) indices as they are laid out in the underlying storage buffer. The order depends on the memory layout (e.g., row-major / column-major / with strides).

Example for shape = (2, 2) in row-major layout: yields: 0, 1, 2, 3

pub fn dim_coordinates(&self) -> DimCoordinates

Returns an iterator over dimension coordinates.

This iterator yields the multi-dimensional coordinates (e.g., [i, j, k, ...]) of each element in the array, independent of the physical storage layout.

Example for shape = (2, 2): yields: [0, 0], [0, 1], [1, 0], [1, 1]

pub fn dims_coordinates<const N: usize>(&self) -> Result<DimNCoordinates<N>>

pub fn dim2_coordinates(&self) -> Result<DimNCoordinates<2>>

pub fn dim3_coordinates(&self) -> Result<DimNCoordinates<3>>

pub fn dim4_coordinates(&self) -> Result<DimNCoordinates<4>>

pub fn dim5_coordinates(&self) -> Result<DimNCoordinates<5>>

impl<T: NumDType> Tensor<T>

pub fn allclose(&self, other: &Self, rtol: f64, atol: f64) -> Result<bool>

impl<T: FloatDType> Tensor<T>

pub fn detach(&self) -> Self

pub fn requires_grad(&self) -> bool

pub fn set_requires_grad(&self, mode: bool)

pub fn op(&self) -> Option<&Op<T>>

pub fn is_leaf(&self) -> bool

impl<T: FloatDType> Tensor<T>

pub fn backward(&self) -> Result<GradStore<T>>

pub fn sorted_nodes(&self) -> Vec<&Tensor<T>>

Trait Implementations

impl Add<&Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<f32>) -> Self::Output

Performs the + operation.

impl Add<&Tensor<f64>> for f64

type Output = Tensor<f64>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<f64>) -> Self::Output

Performs the + operation.

impl Add<&Tensor<i32>> for i32

type Output = Tensor<i32>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<i32>) -> Self::Output

Performs the + operation.

impl Add<&Tensor<u32>> for u32

type Output = Tensor<u32>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<u32>) -> Self::Output

Performs the + operation.

impl Add<&Tensor<u8>> for u8

type Output = Tensor<u8>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<u8>) -> Self::Output

Performs the + operation.

impl<'a, T: NumDType, R: Into<TensorOrScalar<T>>> Add<R> for &Tensor<T>

Add

type Output = Tensor<T>

The resulting type after applying the + operator.

fn add(self, rhs: R) -> Self::Output

Performs the + operation.

impl<'a, T: NumDType, R> Add<R> for Tensor<T>

where R: Into<TensorOrScalar<T>>,

type Output = Tensor<T>

The resulting type after applying the + operator.

fn add(self, rhs: R) -> Self::Output

Performs the + operation.

impl Add<Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<f32>) -> Self::Output

Performs the + operation.

impl Add<Tensor<f64>> for f64

type Output = Tensor<f64>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<f64>) -> Self::Output

Performs the + operation.

impl Add<Tensor<i32>> for i32

type Output = Tensor<i32>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<i32>) -> Self::Output

Performs the + operation.

impl Add<Tensor<u32>> for u32

type Output = Tensor<u32>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<u32>) -> Self::Output

Performs the + operation.

impl Add<Tensor<u8>> for u8

type Output = Tensor<u8>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<u8>) -> Self::Output

Performs the + operation.

impl<T: WithDType> AsRef<Tensor<T>> for Tensor<T>

fn as_ref(&self) -> &Tensor<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, R: Into<TensorOrScalar<bool>>> BitAnd<R> for &Tensor<bool>

Bool

type Output = Tensor<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: R) -> Self::Output

Performs the & operation.

impl<'a, R: Into<TensorOrScalar<bool>>> BitAnd<R> for Tensor<bool>

type Output = Tensor<bool>

The resulting type after applying the & operator.

fn bitand(self, rhs: R) -> Self::Output

Performs the & operation.

impl<'a, R: Into<TensorOrScalar<bool>>> BitOr<R> for &Tensor<bool>

type Output = Tensor<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: R) -> Self::Output

Performs the | operation.

impl<'a, R: Into<TensorOrScalar<bool>>> BitOr<R> for Tensor<bool>

type Output = Tensor<bool>

The resulting type after applying the | operator.

fn bitor(self, rhs: R) -> Self::Output

Performs the | operation.

impl<'a, R: Into<TensorOrScalar<bool>>> BitXor<R> for &Tensor<bool>

type Output = Tensor<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: R) -> Self::Output

Performs the ^ operation.

impl<'a, R: Into<TensorOrScalar<bool>>> BitXor<R> for Tensor<bool>

type Output = Tensor<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: R) -> Self::Output

Performs the ^ operation.

impl<T: Clone + WithDType> Clone for Tensor<T>

fn clone(&self) -> Tensor<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: WithDType> Debug for Tensor<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: WithDType> Display for Tensor<T>

where DisplayOp: Display<T>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<&Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<f32>) -> Self::Output

Performs the / operation.

impl Div<&Tensor<f64>> for f64

type Output = Tensor<f64>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<f64>) -> Self::Output

Performs the / operation.

impl Div<&Tensor<i32>> for i32

type Output = Tensor<i32>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<i32>) -> Self::Output

Performs the / operation.

impl Div<&Tensor<u32>> for u32

type Output = Tensor<u32>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<u32>) -> Self::Output

Performs the / operation.

impl Div<&Tensor<u8>> for u8

type Output = Tensor<u8>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<u8>) -> Self::Output

Performs the / operation.

impl<'a, T: NumDType, R: Into<TensorOrScalar<T>>> Div<R> for &Tensor<T>

Div

type Output = Tensor<T>

The resulting type after applying the / operator.

fn div(self, rhs: R) -> Self::Output

Performs the / operation.

impl<'a, T: NumDType, R: Into<TensorOrScalar<T>>> Div<R> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

fn div(self, rhs: R) -> Self::Output

Performs the / operation.

impl Div<Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<f32>) -> Self::Output

Performs the / operation.

impl Div<Tensor<f64>> for f64

type Output = Tensor<f64>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<f64>) -> Self::Output

Performs the / operation.

impl Div<Tensor<i32>> for i32

type Output = Tensor<i32>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<i32>) -> Self::Output

Performs the / operation.

impl Div<Tensor<u32>> for u32

type Output = Tensor<u32>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<u32>) -> Self::Output

Performs the / operation.

impl Div<Tensor<u8>> for u8

type Output = Tensor<u8>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<u8>) -> Self::Output

Performs the / operation.

impl<T: WithDType> From<&Tensor<T>> for TensorOrScalar<T>

fn from(value: &Tensor<T>) -> Self

Converts to this type from the input type.

impl From<&Tensor<bool>> for DynTensor

fn from(t: &Tensor<bool>) -> Self

Converts to this type from the input type.

impl From<&Tensor<bool>> for Indexer

fn from(value: &Tensor<bool>) -> Self

Converts to this type from the input type.

impl From<&Tensor<f32>> for DynTensor

fn from(t: &Tensor<f32>) -> Self

Converts to this type from the input type.

impl From<&Tensor<f32>> for FloatTensor

fn from(value: &Tensor<f32>) -> Self

Converts to this type from the input type.

impl From<&Tensor<f64>> for DynTensor

fn from(t: &Tensor<f64>) -> Self

Converts to this type from the input type.

impl From<&Tensor<f64>> for FloatTensor

fn from(value: &Tensor<f64>) -> Self

Converts to this type from the input type.

impl From<&Tensor<i32>> for DynTensor

fn from(t: &Tensor<i32>) -> Self

Converts to this type from the input type.

impl From<&Tensor<i32>> for IntTensor

fn from(value: &Tensor<i32>) -> Self

Converts to this type from the input type.

impl From<&Tensor<u32>> for DynTensor

fn from(t: &Tensor<u32>) -> Self

Converts to this type from the input type.

impl From<&Tensor<u32>> for IntTensor

fn from(value: &Tensor<u32>) -> Self

Converts to this type from the input type.

impl From<&Tensor<u8>> for DynTensor

fn from(t: &Tensor<u8>) -> Self

Converts to this type from the input type.

impl From<&Tensor<u8>> for IntTensor

fn from(value: &Tensor<u8>) -> Self

Converts to this type from the input type.

impl<T: WithDType> From<Tensor<T>> for TensorOrScalar<T>

fn from(value: Tensor<T>) -> Self

Converts to this type from the input type.

impl From<Tensor<bool>> for DynTensor

fn from(t: Tensor<bool>) -> Self

Converts to this type from the input type.

impl From<Tensor<bool>> for Indexer

fn from(value: Tensor<bool>) -> Self

Converts to this type from the input type.

impl From<Tensor<f32>> for DynTensor

fn from(t: Tensor<f32>) -> Self

Converts to this type from the input type.

impl From<Tensor<f32>> for FloatTensor

fn from(value: Tensor<f32>) -> Self

Converts to this type from the input type.

impl From<Tensor<f64>> for DynTensor

fn from(t: Tensor<f64>) -> Self

Converts to this type from the input type.

impl From<Tensor<f64>> for FloatTensor

fn from(value: Tensor<f64>) -> Self

Converts to this type from the input type.

impl From<Tensor<i32>> for DynTensor

fn from(t: Tensor<i32>) -> Self

Converts to this type from the input type.

impl From<Tensor<i32>> for IntTensor

fn from(value: Tensor<i32>) -> Self

Converts to this type from the input type.

impl From<Tensor<u32>> for DynTensor

fn from(t: Tensor<u32>) -> Self

Converts to this type from the input type.

impl From<Tensor<u32>> for IntTensor

fn from(value: Tensor<u32>) -> Self

Converts to this type from the input type.

impl From<Tensor<u8>> for DynTensor

fn from(t: Tensor<u8>) -> Self

Converts to this type from the input type.

impl From<Tensor<u8>> for IntTensor

fn from(value: Tensor<u8>) -> Self

Converts to this type from the input type.

impl<T: WithDType> Hash for Tensor<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: FloatDType> Index<&Tensor<T>> for GradStore<T>

type Output = Tensor<T>

The returned type after indexing.

fn index(&self, index: &Tensor<T>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<I: Into<Indexer>, D: WithDType> IndexOp<(I,), D> for Tensor<D>

fn index(&self, (index): (I,)) -> Result<Tensor<D>>

impl<I1, I2, D: WithDType> IndexOp<(I1, I2), D> for Tensor<D>

where I1: Into<Indexer>, I2: Into<Indexer>,

fn index(&self, (I1, I2): (I1, I2)) -> Result<Tensor<D>>

impl<I1, I2, I3, D: WithDType> IndexOp<(I1, I2, I3), D> for Tensor<D>

where I1: Into<Indexer>, I2: Into<Indexer>, I3: Into<Indexer>,

fn index(&self, (I1, I2, I3): (I1, I2, I3)) -> Result<Tensor<D>>

impl<I1, I2, I3, I4, D: WithDType> IndexOp<(I1, I2, I3, I4), D> for Tensor<D>

where I1: Into<Indexer>, I2: Into<Indexer>, I3: Into<Indexer>, I4: Into<Indexer>,

fn index(&self, (I1, I2, I3, I4): (I1, I2, I3, I4)) -> Result<Tensor<D>>

impl<I1, I2, I3, I4, I5, D: WithDType> IndexOp<(I1, I2, I3, I4, I5), D> for Tensor<D>

where I1: Into<Indexer>, I2: Into<Indexer>, I3: Into<Indexer>, I4: Into<Indexer>, I5: Into<Indexer>,

fn index(&self, (I1, I2, I3, I4, I5): (I1, I2, I3, I4, I5)) -> Result<Tensor<D>>

impl<I: Into<Indexer>, D: WithDType> IndexOp<I, D> for Tensor<D>

fn index(&self, index: I) -> Result<Tensor<D>>

impl<I: Into<Indexer>, D: WithDType> IndexOp<Vec<I>, D> for Tensor<D>

fn index(&self, index: Vec<I>) -> Result<Tensor<D>>

impl Mul<&Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<f32>) -> Self::Output

Performs the * operation.

impl Mul<&Tensor<f64>> for f64

type Output = Tensor<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<f64>) -> Self::Output

Performs the * operation.

impl Mul<&Tensor<i32>> for i32

type Output = Tensor<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<i32>) -> Self::Output

Performs the * operation.

impl Mul<&Tensor<u32>> for u32

type Output = Tensor<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<u32>) -> Self::Output

Performs the * operation.

impl Mul<&Tensor<u8>> for u8

type Output = Tensor<u8>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<u8>) -> Self::Output

Performs the * operation.

impl<'a, T: NumDType, R: Into<TensorOrScalar<T>>> Mul<R> for &Tensor<T>

Mul

type Output = Tensor<T>

The resulting type after applying the * operator.

fn mul(self, rhs: R) -> Self::Output

Performs the * operation.

impl<'a, T: NumDType, R: Into<TensorOrScalar<T>>> Mul<R> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

fn mul(self, rhs: R) -> Self::Output

Performs the * operation.

impl Mul<Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<f32>) -> Self::Output

Performs the * operation.

impl Mul<Tensor<f64>> for f64

type Output = Tensor<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<f64>) -> Self::Output

Performs the * operation.

impl Mul<Tensor<i32>> for i32

type Output = Tensor<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<i32>) -> Self::Output

Performs the * operation.

impl Mul<Tensor<u32>> for u32

type Output = Tensor<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<u32>) -> Self::Output

Performs the * operation.

impl Mul<Tensor<u8>> for u8

type Output = Tensor<u8>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<u8>) -> Self::Output

Performs the * operation.

impl<T: WithDType> PartialEq for Tensor<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<&Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<f32>) -> Self::Output

Performs the - operation.

impl Sub<&Tensor<f64>> for f64

type Output = Tensor<f64>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<f64>) -> Self::Output

Performs the - operation.

impl Sub<&Tensor<i32>> for i32

type Output = Tensor<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<i32>) -> Self::Output

Performs the - operation.

impl Sub<&Tensor<u32>> for u32

type Output = Tensor<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<u32>) -> Self::Output

Performs the - operation.

impl Sub<&Tensor<u8>> for u8

type Output = Tensor<u8>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<u8>) -> Self::Output

Performs the - operation.

impl<'a, T: NumDType, R: Into<TensorOrScalar<T>>> Sub<R> for &Tensor<T>

Sub

type Output = Tensor<T>

The resulting type after applying the - operator.

fn sub(self, rhs: R) -> Self::Output

Performs the - operation.

impl<'a, T: NumDType, R: Into<TensorOrScalar<T>>> Sub<R> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

fn sub(self, rhs: R) -> Self::Output

Performs the - operation.

impl Sub<Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<f32>) -> Self::Output

Performs the - operation.

impl Sub<Tensor<f64>> for f64

type Output = Tensor<f64>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<f64>) -> Self::Output

Performs the - operation.

impl Sub<Tensor<i32>> for i32

type Output = Tensor<i32>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<i32>) -> Self::Output

Performs the - operation.

impl Sub<Tensor<u32>> for u32

type Output = Tensor<u32>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<u32>) -> Self::Output

Performs the - operation.

impl Sub<Tensor<u8>> for u8

type Output = Tensor<u8>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<u8>) -> Self::Output

Performs the - operation.

impl TryFrom<DynTensor> for Tensor<bool>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: DynTensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<DynTensor> for Tensor<f32>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: DynTensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<DynTensor> for Tensor<f64>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: DynTensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<DynTensor> for Tensor<i32>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: DynTensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<DynTensor> for Tensor<u32>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: DynTensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<DynTensor> for Tensor<u8>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: DynTensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: WithDType> Eq for Tensor<T>