Struct Tensor 

pub struct Tensor<D: Device = Cpu, K: DTypeKind<D> = Float>(/* private fields */);

The reference-counted tensor handle. Cheap to clone (bumps an Arc).

Two generic parameters:

• D: Device — where the data lives (e.g. Cpu); selects the storage type.
• K: DTypeKind<D> — the kind (Float/Int/Bool), a compile-time marker. The concrete precision within a kind (f32 vs f64, …) is a runtime [DType] carried inside the tensor.

Float is the default kind so Tensor<Cpu> means a float tensor.

Implementations

impl<D: Device> Tensor<D, Float>

pub fn backward_into(&self, grads: &mut GradStore<D>) -> Result<()>

Accumulate gradients of self w.r.t. all leaf tensors that require grad into an existing GradStore.

Unlike Tensor::backward, this does not create a fresh store; leaf gradients are added onto whatever is already present. Calling it multiple times with different loss tensors (e.g. one per micro-batch) and then stepping the optimizer once implements gradient accumulation.

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

Compute gradients of self w.r.t. all leaf tensors that require grad.

pub fn sorted_nodes(&self) -> Vec<&Tensor<D, Float>>

Reverse-topological order of nodes reachable from grad-requiring leaves.

impl<D: Device> Tensor<D, Float>

Convenience accessors on a Float tensor for its autograd state.

pub fn detach(&self) -> Self

pub fn requires_grad(&self) -> bool

pub fn set_requires_grad(&self, mode: bool)

pub fn is_leaf(&self) -> bool

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

impl<D: Device> Tensor<D, Bool>

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

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

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

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

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

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

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

impl<D: Device> Tensor<D, Bool>

pub fn pick<K: PickDTypeKind<D>>( &self, on_true: &Tensor<D, K>, on_false: &Tensor<D, K>, ) -> Result<Tensor<D, K>>

pub fn pick_true<K: PickDTypeKind<D>>( &self, value: K::Scalar, on_false: &Tensor<D, K>, ) -> Result<Tensor<D, K>>

mask ? value : on_false with a scalar true-value.

pub fn pick_false<K: PickDTypeKind<D>>( &self, on_true: &Tensor<D, K>, value: K::Scalar, ) -> Result<Tensor<D, K>>

mask ? on_true : value with a scalar false-value.

impl<D: Device, K: DTypeKind<D>> Tensor<D, K>

pub fn cast<T: Cast<D, K>>(&self, dtype: T) -> Result<Tensor<D, T::Output>>

impl<D: Device, K: CastDTypeKind<D>> Tensor<D, K>

pub fn cast_float(&self, to: FloatDType) -> Result<Tensor<D, Float>>

pub fn cast_int(&self, to: IntDType) -> Result<Tensor<D, Int>>

pub fn cast_bool(&self, to: BoolDType) -> Result<Tensor<D, Bool>>

impl<D: Device> Tensor<D, Bool>

pub fn new(data: impl IntoTensor<D, Bool>, device: &D) -> Result<Self>

pub fn from_vec_bool<'a, S: Into<Shape>>( data: impl Into<Cow<'a, [bool]>>, shape: S, device: &D, ) -> Result<Self>

pub fn falses<S: Into<Shape>>( shape: S, options: impl Into<TensorCreationOptions<D, Bool>>, ) -> Result<Self>

pub fn trues<S: Into<Shape>>( shape: S, options: impl Into<TensorCreationOptions<D, Bool>>, ) -> Result<Self>

pub fn from_slice<S: Into<Shape>>( data: &[bool], shape: S, options: impl Into<TensorCreationOptions<D, Bool>>, ) -> Result<Self>

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

pub fn eye( n: usize, options: impl Into<TensorCreationOptions<D, Bool>>, ) -> Result<Self>

pub fn diag( diag: &[bool], options: impl Into<TensorCreationOptions<D, Bool>>, ) -> Result<Self>

pub fn tril( n: usize, diagonal: bool, options: impl Into<TensorCreationOptions<D, Bool>>, ) -> Result<Self>

pub fn triu( n: usize, diagonal: bool, options: impl Into<TensorCreationOptions<D, Bool>>, ) -> Result<Self>

impl<D: Device> Tensor<D, Float>

pub fn new(data: impl IntoTensor<D, Float>, device: &D) -> Result<Self>

pub fn from_vec_f64<'a, S: Into<Shape>>( data: impl Into<Cow<'a, [f64]>>, shape: S, device: &D, ) -> Result<Self>

pub fn from_vec_f32<'a, S: Into<Shape>>( data: impl Into<Cow<'a, [f32]>>, shape: S, device: &D, ) -> Result<Self>

pub fn from_slice<S: Into<Shape>>( data: &[f64], shape: S, options: impl Into<TensorCreationOptions<D, Float>>, ) -> Result<Self>

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

pub fn randn<S: Into<Shape>>( mean: f64, std: f64, shape: S, options: impl Into<TensorCreationOptions<D, Float>>, ) -> Result<Self>

pub fn rand<S: Into<Shape>>( lo: f64, hi: f64, shape: S, options: impl Into<TensorCreationOptions<D, Float>>, ) -> Result<Self>

pub fn rand_like(&self, lo: f64, hi: f64) -> Result<Self>

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

pub fn eye( n: usize, options: impl Into<TensorCreationOptions<D, Float>>, ) -> Result<Self>

pub fn diag( diag: &[f64], options: impl Into<TensorCreationOptions<D, Float>>, ) -> Result<Self>

pub fn tril( n: usize, diagonal: bool, options: impl Into<TensorCreationOptions<D, Float>>, ) -> Result<Self>

pub fn triu( n: usize, diagonal: bool, options: impl Into<TensorCreationOptions<D, Float>>, ) -> Result<Self>

pub fn linspace( start: f64, stop: f64, n: usize, options: impl Into<TensorCreationOptions<D, Float>>, ) -> Result<Self>

impl<D: Device> Tensor<D, Int>

pub fn new(data: impl IntoTensor<D, Int>, device: &D) -> Result<Self>

pub fn from_vec_i64<'a, S: Into<Shape>>( data: impl Into<Cow<'a, [i64]>>, shape: S, device: &D, ) -> Result<Self>

pub fn from_vec_i32<'a, S: Into<Shape>>( data: impl Into<Cow<'a, [i32]>>, shape: S, device: &D, ) -> Result<Self>

pub fn from_vec_u32<'a, S: Into<Shape>>( data: impl Into<Cow<'a, [u32]>>, shape: S, device: &D, ) -> Result<Self>

pub fn from_vec_u8<'a, S: Into<Shape>>( data: impl Into<Cow<'a, [u8]>>, shape: S, device: &D, ) -> Result<Self>

pub fn from_slice<S: Into<Shape>>( data: &[i64], shape: S, options: impl Into<TensorCreationOptions<D, Int>>, ) -> Result<Self>

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

pub fn arange( start: i64, end: i64, step: i64, options: impl Into<TensorCreationOptions<D, Int>>, ) -> Result<Self>

pub fn eye( n: usize, options: impl Into<TensorCreationOptions<D, Int>>, ) -> Result<Self>

pub fn diag( diag: &[i64], options: impl Into<TensorCreationOptions<D, Int>>, ) -> Result<Self>

pub fn tril( n: usize, diagonal: bool, options: impl Into<TensorCreationOptions<D, Int>>, ) -> Result<Self>

pub fn triu( n: usize, diagonal: bool, options: impl Into<TensorCreationOptions<D, Int>>, ) -> Result<Self>

impl<D: Device, K: DTypeKind<D>> Tensor<D, K>

pub fn phantom<S: Into<Shape>>( shape: S, options: impl Into<TensorCreationOptions<D, K>>, ) -> Result<Self>

impl<D: Device, K: ConstructDTypeKind<D>> Tensor<D, K>

pub fn zeros<S: Into<Shape>>( shape: S, options: impl Into<TensorCreationOptions<D, K>>, ) -> Result<Self>

pub fn ones<S: Into<Shape>>( shape: S, options: impl Into<TensorCreationOptions<D, K>>, ) -> Result<Self>

pub fn full<S: Into<Shape>>( shape: S, value: K::Scalar, options: impl Into<TensorCreationOptions<D, K>>, ) -> Result<Self>

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

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

impl<D: Device, K: BytesDTypeKind<D>> Tensor<D, K>

pub fn from_bytes<'a>( bytes: impl Into<Cow<'a, [u8]>>, shape: impl Into<Shape>, options: impl Into<TensorCreationOptions<D, K>>, ) -> Result<Self>

Create a tensor from raw little-endian bytes.

The byte slice length must equal shape.element_count() * dtype.size_in_bytes().

pub fn to_bytes(&self) -> Result<Vec<u8>>

Read raw little-endian bytes in logical (layout) order.

Always returns owned bytes (the internal RwLock prevents zero-copy borrowing at this level; the device trait internally uses Cow for contiguous-optimised paths).

impl<D: Device> Tensor<D, Float>

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

Read the single element of a scalar (0-d or 1-element) tensor.

impl<D: Device> Tensor<D, Int>

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

impl<D: Device> Tensor<D, Float>

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

impl<D: Device> Tensor<D, Int>

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

impl<D: Device> Tensor<D, Bool>

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

impl<D: Device> Tensor<D, Bool>

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

impl<D: Device, K: IndexingDTypeKind<D>> Tensor<D, K>

pub fn index_select<Dm: Dim>( &self, indices: &Tensor<D, Int>, dim: Dm, ) -> Result<Self>

Select slices along dim at the given 1-D indices.

pub fn gather<Dm: Dim>(&self, indices: &Tensor<D, Int>, dim: Dm) -> Result<Self>

Gather along dim using an index tensor of the same rank.

pub fn index_add<Dm: Dim>( &self, indices: &Tensor<D, Int>, src: &Tensor<D, K>, dim: Dm, ) -> Result<Self>

out = self; out[.., idx[i], ..] += src[.., i, ..].

pub fn scatter_add<Dm: Dim>( &self, indices: &Tensor<D, Int>, src: &Tensor<D, K>, dim: Dm, ) -> Result<Self>

out = self; out[.., idx[i,j,k], k] += src[i,j,k].

impl<D: Device, K: IndexingDTypeKind<D> + ShapeDTypeKind<D>> Tensor<D, K>

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

Apply a sequence of Indexers, one per dimension, in order.

• Indexer::Select / Indexer::SelectD: narrow + squeeze (removes dim).
• Indexer::Slice: narrow (step=1) or slice (step>1) — keeps dim.
• Indexer::Boolean: boolean mask → index_select — keeps dim.

impl<D: Device, K: ShapeDTypeKind<D>> Tensor<D, K>

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

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

let t = Tensor::<Cpu>::new(&[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]).unwrap();
let row1 = t.get(1).unwrap(); // [3.0, 4.0]

impl<D: Device, K: MatmulDTypeKind<D>> Tensor<D, K>

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

impl<D: Device> Tensor<D, Float>

pub fn softmax<Dm: Dim>(&self, dim: Dm) -> Result<Self>

Softmax over dim. Records Op::Softmax.

pub fn rms_norm(&self, weight: &Self, eps: f64) -> Result<Self>

RMSNorm over the last dim: x / sqrt(mean(x^2)+eps) * weight. Records Op::RmsNorm.

impl<D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>> Tensor<D, K>

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

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

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

pub fn add_scalar_(&self, rhs: K::Scalar) -> Result<()>

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

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

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

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

pub fn sub_scalar_(&self, rhs: K::Scalar) -> Result<()>

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

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

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

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

pub fn mul_scalar_(&self, rhs: K::Scalar) -> Result<()>

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

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

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

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

pub fn div_scalar_(&self, rhs: K::Scalar) -> Result<()>

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

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

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

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

pub fn maximum_scalar_(&self, rhs: K::Scalar) -> Result<()>

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

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

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

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

pub fn minimum_scalar_(&self, rhs: K::Scalar) -> Result<()>

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

impl<D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>> Tensor<D, K>

pub fn eq(&self, rhs: &Self) -> Result<Tensor<D, Bool>>

pub fn eq_scalar(&self, rhs: K::Scalar) -> Result<Tensor<D, Bool>>

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

pub fn ne(&self, rhs: &Self) -> Result<Tensor<D, Bool>>

pub fn ne_scalar(&self, rhs: K::Scalar) -> Result<Tensor<D, Bool>>

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

pub fn lt(&self, rhs: &Self) -> Result<Tensor<D, Bool>>

pub fn lt_scalar(&self, rhs: K::Scalar) -> Result<Tensor<D, Bool>>

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

pub fn le(&self, rhs: &Self) -> Result<Tensor<D, Bool>>

pub fn le_scalar(&self, rhs: K::Scalar) -> Result<Tensor<D, Bool>>

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

pub fn gt(&self, rhs: &Self) -> Result<Tensor<D, Bool>>

pub fn gt_scalar(&self, rhs: K::Scalar) -> Result<Tensor<D, Bool>>

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

pub fn ge(&self, rhs: &Self) -> Result<Tensor<D, Bool>>

pub fn ge_scalar(&self, rhs: K::Scalar) -> Result<Tensor<D, Bool>>

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

impl<D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>> Tensor<D, K>

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

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

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

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

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

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

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

pub fn affine_(&self, mul: K::Scalar, add: K::Scalar) -> Result<()>

pub fn pow(&self, exp: K::Scalar) -> Result<Self>

pub fn pow_(&self, exp: K::Scalar) -> Result<()>

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

pub fn clamp_( &self, min: Option<K::Scalar>, max: Option<K::Scalar>, ) -> Result<()>

pub fn sub_scalar_lhs(&self, lhs: K::Scalar) -> Result<Self>

scalar - self (scalar on the left).

pub fn div_scalar_lhs(&self, lhs: K::Scalar) -> Result<Self>

scalar / self (scalar on the left).

impl<D: Device> Tensor<D, Float>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn leaky_relu_(&self, negative_slope: f64) -> Result<()>

impl<D: Device, K: ReduceDTypeKind<D>> Tensor<D, K>

pub fn argmin<Dm: Dim>(&self, dim: Dm) -> Result<Tensor<D, Int>>

pub fn argmin_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Tensor<D, Int>>

pub fn argmax<Dm: Dim>(&self, dim: Dm) -> Result<Tensor<D, Int>>

pub fn argmax_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Tensor<D, Int>>

impl<D: Device> Tensor<D, Float>

pub fn mean<Dm: Dim>(&self, dim: Dm) -> Result<Self>

pub fn mean_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Self>

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

pub fn var<Dm: Dim>(&self, dim: Dm) -> Result<Self>

pub fn var_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Self>

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

pub fn var_unbiased<Dm: Dim>(&self, dim: Dm) -> Result<Self>

pub fn var_unbiased_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Self>

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

impl<D: Device, K: ReduceDTypeKind<D>> Tensor<D, K>

pub fn sum<Dm: Dim>(&self, dim: Dm) -> Result<Self>

pub fn sum_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Self>

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

pub fn max<Dm: Dim>(&self, dim: Dm) -> Result<Self>

pub fn max_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Self>

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

pub fn min<Dm: Dim>(&self, dim: Dm) -> Result<Self>

pub fn min_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Self>

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

pub fn prod<Dm: Dim>(&self, dim: Dm) -> Result<Self>

pub fn prod_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Self>

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

pub fn sum_dims<Ds: Dims>(&self, dims: Ds, keepdim: bool) -> Result<Self>

impl<D: Device> Tensor<D, Float>

pub fn std<Dm: Dim>(&self, dim: Dm) -> Result<Self>

Standard deviation along dim.

pub fn std_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Self>

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

pub fn logsumexp<Dm: Dim>(&self, dim: Dm) -> Result<Self>

Log-sum-exp along dim, numerically stable.

pub fn logsumexp_keepdim<Dm: Dim>(&self, dim: Dm) -> Result<Self>

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

impl<D: Device, K: ShapeDTypeKind<D>> Tensor<D, K>

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

Deep-copy the tensor data to independent storage (records Op::Copy for Float).

pub fn copy_(&mut self, src: &Self) -> Result<()>

Copy the data from src into self in-place, preserving [TensorId].

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

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

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

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

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

pub fn slice<Dm: Dim>( &self, dim: Dm, start: usize, end: usize, step: usize, ) -> Result<Self>

Slice along dim with start, end, and step.

Returns a view (no copy) when possible. For step == 1 this is equivalent to narrow; for step > 1 the backward pass is not yet supported on autograd tensors.

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

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

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

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

Materialize a contiguous copy (records Op::Copy for Float).

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

Concatenate tensors along dim (materializes new storage).

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

Flatten dims start_dim..=end_dim into one.

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

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

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

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

Stack tensors along a new axis at dim (unsqueeze each + cat).

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

Split into individual slices along dim (one per index).

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

Split into chunks roughly equal pieces along dim.

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

Tile self by times along dim.

impl<D: Device, K: DTypeKind<D>> Tensor<D, K>

pub fn to_device<D2: Device>(&self, device: &D2) -> Result<Tensor<D2, K>>

where K: TransferDTypeKind<D, D2>,

Move the tensor to another device.

• Same device: returns this handle unchanged (shared Arc, O(1)) — generic code can call this unconditionally.
• Cross device: deep-copies the data (to_bytes/from_bytes), dtype unchanged, result contiguous. For Float tensors the autograd graph is severed (the result is a leaf) but requires_grad is preserved.
• Meta tensors (no storage) error with Error::MetaTensor.

pub fn cpu(&self) -> Result<Tensor<Cpu, K>>

where K: TransferDTypeKind<D, Cpu>,

Convenience for to_device(&Cpu).

impl<D: Device, K: DTypeKind<D>> Tensor<D, K>

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

impl<D: Device, K: DTypeKind<D>> Tensor<D, K>

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

impl<D: Device, K: DTypeKind<D>> Tensor<D, K>

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

impl<D: Device, K: DTypeKind<D>> Tensor<D, K>

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

impl<D: Device, K: DTypeKind<D>> Tensor<D, K>

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

impl<D: Device, K: DTypeKind<D>> Tensor<D, K>

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

impl<D: Device, K: DTypeKind<D>> Tensor<D, K>

pub fn id(&self) -> TensorId

pub fn dtype(&self) -> K::DType

pub fn device(&self) -> &D

pub fn layout(&self) -> &Layout

pub fn shape(&self) -> &Shape

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

pub fn rank(&self) -> usize

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

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

pub fn element_count(&self) -> usize

pub fn is_contiguous(&self) -> bool

pub fn is_meta(&self) -> bool

A meta tensor carries shape but no storage.

pub fn storage(&self) -> Result<&Arc<RwLock<K::Storage>>>

Access the underlying storage, erroring on a meta tensor.

Trait Implementations

impl<D: Device> Add<&Tensor<D, Int>> for i64

type Output = Tensor<D, Int>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<D: Device> Add<&Tensor<D>> for f64

type Output = Tensor<D>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<D, K, R> Add<R> for &Tensor<D, K>

where D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>, R: Into<TensorOrScalar<D, K>>,

type Output = Tensor<D, K>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<D, K, R> Add<R> for Tensor<D, K>

where D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>, R: Into<TensorOrScalar<D, K>>,

type Output = Tensor<D, K>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<D: Device> Add<Tensor<D, Int>> for i64

type Output = Tensor<D, Int>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<D: Device> Add<Tensor<D>> for f64

type Output = Tensor<D>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<D: Device> AddAssign<&Tensor<D, Int>> for Tensor<D, Int>

where Int: NumericDTypeKind<D> + ShapeDTypeKind<D>,

fn add_assign(&mut self, rhs: &Tensor<D, Int>)

Performs the += operation.

impl<D: Device> AddAssign<&Tensor<D>> for Tensor<D, Float>

where Float: NumericDTypeKind<D> + ShapeDTypeKind<D>,

fn add_assign(&mut self, rhs: &Tensor<D, Float>)

Performs the += operation.

impl<D: Device, K: DTypeKind<D>> AsRef<Tensor<D, K>> for Tensor<D, K>

fn as_ref(&self) -> &Tensor<D, K>

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

impl<D: Device, K: DTypeKind<D>> Clone for Tensor<D, K>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Device> Display for Tensor<D, Float>

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

Formats the value using the given formatter.

impl<D: Device> Display for Tensor<D, Int>

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

Formats the value using the given formatter.

impl<D: Device> Display for Tensor<D, Bool>

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

Formats the value using the given formatter.

impl<D: Device> Div<&Tensor<D>> for f64

type Output = Tensor<D>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<D, K, R> Div<R> for &Tensor<D, K>

where D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>, R: Into<TensorOrScalar<D, K>>,

type Output = Tensor<D, K>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<D, K, R> Div<R> for Tensor<D, K>

where D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>, R: Into<TensorOrScalar<D, K>>,

type Output = Tensor<D, K>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<D: Device> Div<Tensor<D>> for f64

type Output = Tensor<D>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<D: Device> DivAssign<&Tensor<D, Int>> for Tensor<D, Int>

where Int: NumericDTypeKind<D> + ShapeDTypeKind<D>,

fn div_assign(&mut self, rhs: &Tensor<D, Int>)

Performs the /= operation.

impl<D: Device> DivAssign<&Tensor<D>> for Tensor<D, Float>

where Float: NumericDTypeKind<D> + ShapeDTypeKind<D>,

fn div_assign(&mut self, rhs: &Tensor<D, Float>)

Performs the /= operation.

impl<D: Device, K: DTypeKind<D>> Eq for Tensor<D, K>

impl<D: Device> From<&Tensor<D, Bool>> for Indexer<D>

fn from(value: &Tensor<D, Bool>) -> Self

Converts to this type from the input type.

impl<D: Device> From<Tensor<D, Bool>> for DynTensor<D>

fn from(t: Tensor<D, Bool>) -> Self

Converts to this type from the input type.

impl<D: Device> From<Tensor<D, Bool>> for Indexer<D>

fn from(value: Tensor<D, Bool>) -> Self

Converts to this type from the input type.

impl<D: Device> From<Tensor<D, Int>> for DynTensor<D>

fn from(t: Tensor<D, Int>) -> Self

Converts to this type from the input type.

impl<D: Device> From<Tensor<D>> for DynTensor<D>

fn from(t: Tensor<D, Float>) -> Self

Converts to this type from the input type.

impl<D: Device, K: DTypeKind<D>> Hash for Tensor<D, K>

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<D: Device> Index<&Tensor<D>> for GradStore<D>

type Output = Tensor<D>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

where I1: Into<Indexer<D>>, I2: Into<Indexer<D>>, D: Device, K: IndexingDTypeKind<D> + ShapeDTypeKind<D>,

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

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

where I1: Into<Indexer<D>>, I2: Into<Indexer<D>>, I3: Into<Indexer<D>>, D: Device, K: IndexingDTypeKind<D> + ShapeDTypeKind<D>,

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

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

where I1: Into<Indexer<D>>, I2: Into<Indexer<D>>, I3: Into<Indexer<D>>, I4: Into<Indexer<D>>, D: Device, K: IndexingDTypeKind<D> + ShapeDTypeKind<D>,

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

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

where I1: Into<Indexer<D>>, I2: Into<Indexer<D>>, I3: Into<Indexer<D>>, I4: Into<Indexer<D>>, I5: Into<Indexer<D>>, D: Device, K: IndexingDTypeKind<D> + ShapeDTypeKind<D>,

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

impl<I1, D, K> IndexOp<(I1,), D, K> for Tensor<D, K>

where I1: Into<Indexer<D>>, D: Device, K: IndexingDTypeKind<D> + ShapeDTypeKind<D>,

fn i(&self, (I1): (I1,)) -> Result<Tensor<D, K>>

impl<I, D, K> IndexOp<I, D, K> for Tensor<D, K>

where I: Into<Indexer<D>>, D: Device, K: IndexingDTypeKind<D> + ShapeDTypeKind<D>,

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

impl<I, D, K> IndexOp<Vec<I>, D, K> for Tensor<D, K>

where I: Into<Indexer<D>>, D: Device, K: IndexingDTypeKind<D> + ShapeDTypeKind<D>,

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

impl<D: Device> Mul<&Tensor<D, Int>> for i64

type Output = Tensor<D, Int>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<D: Device> Mul<&Tensor<D>> for f64

type Output = Tensor<D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<D, K, R> Mul<R> for &Tensor<D, K>

where D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>, R: Into<TensorOrScalar<D, K>>,

type Output = Tensor<D, K>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<D, K, R> Mul<R> for Tensor<D, K>

where D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>, R: Into<TensorOrScalar<D, K>>,

type Output = Tensor<D, K>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<D: Device> Mul<Tensor<D, Int>> for i64

type Output = Tensor<D, Int>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<D: Device> Mul<Tensor<D>> for f64

type Output = Tensor<D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<D: Device> MulAssign<&Tensor<D, Int>> for Tensor<D, Int>

where Int: NumericDTypeKind<D> + ShapeDTypeKind<D>,

fn mul_assign(&mut self, rhs: &Tensor<D, Int>)

Performs the *= operation.

impl<D: Device> MulAssign<&Tensor<D>> for Tensor<D, Float>

where Float: NumericDTypeKind<D> + ShapeDTypeKind<D>,

fn mul_assign(&mut self, rhs: &Tensor<D, Float>)

Performs the *= operation.

impl<D: Device> Neg for &Tensor<D, Float>

where Float: NumericDTypeKind<D> + ShapeDTypeKind<D>,

type Output = Tensor<D>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<D: Device> Neg for Tensor<D, Float>

where Float: NumericDTypeKind<D> + ShapeDTypeKind<D>,

type Output = Tensor<D>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<D: Device> Neg for &Tensor<D, Int>

where Int: NumericDTypeKind<D> + ShapeDTypeKind<D>,

type Output = Tensor<D, Int>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<D: Device> Neg for Tensor<D, Int>

where Int: NumericDTypeKind<D> + ShapeDTypeKind<D>,

type Output = Tensor<D, Int>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<D: Device, K: DTypeKind<D>> PartialEq for Tensor<D, K>

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

Equality operator ==.

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

Inequality operator !=.

impl<D: Device> Sub<&Tensor<D>> for f64

type Output = Tensor<D>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<D, K, R> Sub<R> for &Tensor<D, K>

where D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>, R: Into<TensorOrScalar<D, K>>,

type Output = Tensor<D, K>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<D, K, R> Sub<R> for Tensor<D, K>

where D: Device, K: NumericDTypeKind<D> + ShapeDTypeKind<D>, R: Into<TensorOrScalar<D, K>>,

type Output = Tensor<D, K>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<D: Device> Sub<Tensor<D>> for f64

type Output = Tensor<D>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<D: Device> SubAssign<&Tensor<D, Int>> for Tensor<D, Int>

where Int: NumericDTypeKind<D> + ShapeDTypeKind<D>,

fn sub_assign(&mut self, rhs: &Tensor<D, Int>)

Performs the -= operation.

impl<D: Device> SubAssign<&Tensor<D>> for Tensor<D, Float>

where Float: NumericDTypeKind<D> + ShapeDTypeKind<D>,

fn sub_assign(&mut self, rhs: &Tensor<D, Float>)

Performs the -= operation.