Struct DiffTensor

pub struct DiffTensor<T, B = Cpu, const DEVICE_ID: usize = 0, A = HptAllocator<B>>
where
    B: BackendTy + Buffer,
    A: Allocator,
{ /* private fields */ }

DiffTensor is a tensor that has a gradient.

Implementations

impl<T, const DEVICE: usize, A> DiffTensor<T, Cpu, DEVICE, A>

where A: Allocator + Send + Sync + 'static, A::Output: AllocatorOutputRetrive,

pub fn log_softmax( &self, axis: i64, ) -> Result<DiffTensor<<T as FloatOutUnary>::Output, Cpu, DEVICE, A>, TensorError>

where T: CommonBounds + Cast<<T as FloatOutUnary>::Output> + FloatOutUnary, <T as FloatOutUnary>::Output: CommonBounds + NormalOut<T, Output = <T as FloatOutUnary>::Output> + FloatOutUnary<Output = <T as FloatOutUnary>::Output> + Cast<T>, T::Vec: FloatOutUnary<Output = <<T as FloatOutUnary>::Output as TypeCommon>::Vec> + IntoVec<<<T as FloatOutUnary>::Output as TypeCommon>::Vec>, <<T as FloatOutUnary>::Output as TypeCommon>::Vec: FloatOutBinary<Output = <<T as FloatOutUnary>::Output as TypeCommon>::Vec> + FloatOutUnary<Output = <<T as FloatOutUnary>::Output as TypeCommon>::Vec>,

Applies the logsoftmax function along a specified axis.

The logsoftmax function normalizes the elements along the specified axis such that they sum to 1. It is commonly used in machine learning models, particularly for multi-class classification tasks. The logsoftmax function transforms each element x_i in the input tensor into a probability by computing:

logsoftmax(x_i) = log(exp(x_i) / sum(exp(x_j))) for all j along the specified axis

Arguments

• axis - The axis along which to apply the softmax function. The elements along this axis will be transformed into probabilities that sum to 1.

Returns

This function returns a Result containing a tensor with the softmax values computed along the specified axis.

impl<T, const DEVICE: usize, A> DiffTensor<T, Cpu, DEVICE, A>

where A: Allocator + Send + Sync + 'static, A::Output: AllocatorOutputRetrive,

pub fn softmax( &self, axis: i64, ) -> Result<DiffTensor<<T as FloatOutUnary>::Output, Cpu, DEVICE, A>, TensorError>

where T: CommonBounds + Cast<<T as FloatOutUnary>::Output> + FloatOutUnary, <T as FloatOutUnary>::Output: CommonBounds + NormalOut<T, Output = <T as FloatOutUnary>::Output> + FloatOutUnary<Output = <T as FloatOutUnary>::Output> + Cast<T>, T::Vec: FloatOutUnary<Output = <<T as FloatOutUnary>::Output as TypeCommon>::Vec>, <<T as FloatOutUnary>::Output as TypeCommon>::Vec: FloatOutBinary<Output = <<T as FloatOutUnary>::Output as TypeCommon>::Vec>,

Applies the softmax function along a specified axis.

The softmax function normalizes the elements along the specified axis such that they sum to 1. It is commonly used in machine learning models, particularly for multi-class classification tasks. The softmax function transforms each element x_i in the input tensor into a probability by computing:

softmax(x_i) = exp(x_i) / sum(exp(x_j)) for all j along the specified axis

Arguments

• axis - The axis along which to apply the softmax function. The elements along this axis will be transformed into probabilities that sum to 1.

Returns

This function returns a Result containing a tensor with the softmax values computed along the specified axis.

impl<T: Clone, const DEVICE: usize> DiffTensor<T, Cpu, DEVICE>

pub fn backward( &mut self, grad: Tensor<T, Cpu, DEVICE>, ) -> Result<(), TensorError>

Backward the gradient of the tensor

pub fn grad(&self) -> Option<Tensor<T, Cpu, DEVICE>>

Get the gradient of the tensor

impl<T, const DEVICE: usize, Al> DiffTensor<T, Cpu, DEVICE, Al>

where Al: Allocator,

pub fn new<A>(data: A) -> Self

where A: Into<Tensor<T, Cpu, DEVICE, Al>>,

Creates a new differentiable tensor from the provided data.

Trait Implementations

impl<T, U, const DEVICE: usize, A> Add<&DiffTensor<U, Cpu, DEVICE, A>> for &DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

fn add(self, rhs: &DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the + operation.

impl<T, U, const DEVICE: usize, A> Add<&DiffTensor<U, Cpu, DEVICE, A>> for DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

fn add(self, rhs: &DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the + operation.

impl<T, U, const DEVICE: usize, A> Add<DiffTensor<U, Cpu, DEVICE, A>> for &DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

fn add(self, rhs: DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the + operation.

impl<T, U, const DEVICE: usize, A> Add<DiffTensor<U, Cpu, DEVICE, A>> for DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

fn add(self, rhs: DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the + operation.

impl<T, const DEVICE: usize, Al> AdvancedOps for DiffTensor<T, Cpu, DEVICE, Al>

where T: NormalOut<bool, Output = T> + Cast<i64> + CommonBounds + PartialOrd, f64: Cast<T>, Al: Allocator + Send + Sync + 'static, Al::Output: AllocatorOutputRetrive,

type Meta = T

The type of the meta data

type Output = DiffTensor<T, Cpu, DEVICE, Al>

The type of the output tensor

type IndexOutput = Tensor<i64, Cpu, DEVICE, Al>

The type of the index tensor

fn pad( &self, pads: &[(i64, i64)], val: Self::Meta, ) -> Result<Self::Output, TensorError>

Pad the tensor

fn topk( &self, k: i64, dim: i64, largest: bool, sorted: bool, ) -> Result<(Self::IndexOutput, Self::Output), TensorError>

Topk the tensor

fn onehot( &self, _: usize, _: i64, _: Self::Meta, _: Self::Meta, ) -> Result<Self::Output, TensorError>

Onehot the tensor

fn dropout(&self, _: f64) -> Result<Self::Output, TensorError>

Gather the tensor Dropout the tensor

fn scatter( &self, _: &Self::IndexOutput, _: i64, _: &Self::Output, ) -> Result<Self::Output, TensorError>

Gather elements the tensor Scatter elements the tensor

impl<T: Clone, B, const DEVICE_ID: usize, A> Clone for DiffTensor<T, B, DEVICE_ID, A>

where B: BackendTy + Buffer + Clone, A: Allocator + Clone,

fn clone(&self) -> DiffTensor<T, B, DEVICE_ID, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: CommonBounds, const DEVICE: usize, Al> Concat for DiffTensor<T, Cpu, DEVICE, Al>

where Al: Allocator + Send + Sync + Clone + 'static, Al::Output: AllocatorOutputRetrive,

type Output = DiffTensor<T, Cpu, DEVICE, Al>

the output type of concat

fn concat( tensors: Vec<Self>, axis: usize, keepdims: bool, ) -> Result<Self::Output, TensorError>

Concatenates multiple tensors along a specified axis.

fn vstack(tensors: Vec<Self>) -> Result<Self::Output, TensorError>

Stacks multiple tensors vertically (along the first axis).

fn hstack(tensors: Vec<Self>) -> Result<Self::Output, TensorError>

Stacks multiple tensors horizontally (along the second axis).

fn dstack(tensors: Vec<Self>) -> Result<Self::Output, TensorError>

Stacks multiple tensors along the depth axis (third dimension).

impl<T, U, const DEVICE: usize, A> Div<&DiffTensor<U, Cpu, DEVICE, A>> for &DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<U>, U: CommonBounds, <T as FloatOutBinary<U>>::Output: CommonBounds + Cast<U> + Cast<<T as FloatOutBinary<U>>::Output> + FloatOutBinary<U>, T::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, <<T as FloatOutBinary<U>>::Output as FloatOutBinary<U>>::Output: CommonBounds + Cast<T>, <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<<T as FloatOutBinary<U>>::Output as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as FloatOutBinary<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

fn div(self, rhs: &DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the / operation.

impl<T, U, const DEVICE: usize, A> Div<&DiffTensor<U, Cpu, DEVICE, A>> for DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<U>, U: CommonBounds, <T as FloatOutBinary<U>>::Output: CommonBounds + Cast<U> + Cast<<T as FloatOutBinary<U>>::Output> + FloatOutBinary<U>, T::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, <<T as FloatOutBinary<U>>::Output as FloatOutBinary<U>>::Output: CommonBounds + Cast<T>, <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<<T as FloatOutBinary<U>>::Output as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as FloatOutBinary<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

fn div(self, rhs: &DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the / operation.

impl<T, U, const DEVICE: usize, A> Div<DiffTensor<U, Cpu, DEVICE, A>> for &DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<U>, U: CommonBounds, <T as FloatOutBinary<U>>::Output: CommonBounds + Cast<U> + Cast<<T as FloatOutBinary<U>>::Output> + FloatOutBinary<U>, T::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, <<T as FloatOutBinary<U>>::Output as FloatOutBinary<U>>::Output: CommonBounds + Cast<T>, <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<<T as FloatOutBinary<U>>::Output as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as FloatOutBinary<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

fn div(self, rhs: DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the / operation.

impl<T, U, const DEVICE: usize, A> Div<DiffTensor<U, Cpu, DEVICE, A>> for DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<U>, U: CommonBounds, <T as FloatOutBinary<U>>::Output: CommonBounds + Cast<U> + Cast<<T as FloatOutBinary<U>>::Output> + FloatOutBinary<U>, T::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, <<T as FloatOutBinary<U>>::Output as FloatOutBinary<U>>::Output: CommonBounds + Cast<T>, <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<<T as FloatOutBinary<U>>::Output as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as FloatOutBinary<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

fn div(self, rhs: DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the / operation.

impl<T: CommonBounds + NormalOut<Output = T> + Cmp<T, Output = bool>, const DEVICE: usize> IndexReduce for DiffTensor<T, Cpu, DEVICE>

type Output = Tensor<i64, Cpu, DEVICE>

The output tensor type.

fn argmax<S: Into<Axis>>( &self, axis: S, keep_dims: bool, ) -> Result<Self::Output, TensorError>

Returns the indices of the maximum values along the specified axis.

fn argmin<S: Into<Axis>>( &self, axis: S, keep_dims: bool, ) -> Result<Self::Output, TensorError>

Returns the indices of the minimum values along the specified axis.

impl<A, B, const DEVICE: usize, Al> Matmul<DiffTensor<B, Cpu, DEVICE, Al>> for DiffTensor<A, Cpu, DEVICE, Al>

where A: CommonBounds + NormalOut<B> + Cast<<A as NormalOut<B>>::Output> + NormalOut<<A as NormalOut<B>>::Output> + Cast<<A as NormalOut<<A as NormalOut<B>>::Output>>::Output>, B: CommonBounds + Cast<<A as NormalOut<B>>::Output> + Cast<<<A as NormalOut<B>>::Output as NormalOut<B>>::Output>, <A as NormalOut<B>>::Output: CommonBounds + NormalOut<A> + NormalOut<B> + Cast<<<A as NormalOut<B>>::Output as NormalOut<B>>::Output> + Cast<<A as NormalOut<<A as NormalOut<B>>::Output>>::Output>, <<A as NormalOut<B>>::Output as NormalOut<B>>::Output: CommonBounds + Cast<<A as NormalOut<<A as NormalOut<B>>::Output>>::Output> + Cast<A>, <A as NormalOut<<A as NormalOut<B>>::Output>>::Output: CommonBounds + Cast<B>, Al: Allocator + 'static + Send + Sync, Al::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<A as NormalOut<B>>::Output, Cpu, DEVICE, Al>

The output tensor type.

type OutputMeta = <A as NormalOut<B>>::Output

The output tensor data type.

type InplaceOutput = Tensor<<A as NormalOut<B>>::Output, Cpu, DEVICE, Al>

The inplace output tensor type.

fn matmul( &self, rhs: DiffTensor<B, Cpu, DEVICE, Al>, ) -> Result<Self::Output, TensorError>

Computes the matrix multiplication of two tensors.

fn matmul_<U>( &self, rhs: DiffTensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::InplaceOutput, TensorError>

where U: Borrow<Self::InplaceOutput> + BorrowMut<Self::InplaceOutput>,

Inplace version of matmul

impl<T, U, const DEVICE: usize, A> Mul<&DiffTensor<U, Cpu, DEVICE, A>> for &DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U> + NormalOut<U> + NormalOut<T>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, <<T as NormalOut<U>>::Output as NormalOut<U>>::Output: CommonBounds + Cast<T>, <<T as NormalOut<U>>::Output as NormalOut<T>>::Output: CommonBounds + Cast<U>, <<T as NormalOut<U>>::Output as TypeCommon>::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<<T as NormalOut<U>>::Output as NormalOut<U>>::Output as TypeCommon>::Vec> + NormalOut<<T as TypeCommon>::Vec, Output = <<<T as NormalOut<U>>::Output as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

fn mul(self, rhs: &DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the * operation.

impl<T, U, const DEVICE: usize, A> Mul<&DiffTensor<U, Cpu, DEVICE, A>> for DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U> + NormalOut<U> + NormalOut<T>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, <<T as NormalOut<U>>::Output as NormalOut<U>>::Output: CommonBounds + Cast<T>, <<T as NormalOut<U>>::Output as NormalOut<T>>::Output: CommonBounds + Cast<U>, <<T as NormalOut<U>>::Output as TypeCommon>::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<<T as NormalOut<U>>::Output as NormalOut<U>>::Output as TypeCommon>::Vec> + NormalOut<<T as TypeCommon>::Vec, Output = <<<T as NormalOut<U>>::Output as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

fn mul(self, rhs: &DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the * operation.

impl<T, U, const DEVICE: usize, A> Mul<DiffTensor<U, Cpu, DEVICE, A>> for &DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U> + NormalOut<U> + NormalOut<T>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, <<T as NormalOut<U>>::Output as NormalOut<U>>::Output: CommonBounds + Cast<T>, <<T as NormalOut<U>>::Output as NormalOut<T>>::Output: CommonBounds + Cast<U>, <<T as NormalOut<U>>::Output as TypeCommon>::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<<T as NormalOut<U>>::Output as NormalOut<U>>::Output as TypeCommon>::Vec> + NormalOut<<T as TypeCommon>::Vec, Output = <<<T as NormalOut<U>>::Output as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

fn mul(self, rhs: DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the * operation.

impl<T, U, const DEVICE: usize, A> Mul<DiffTensor<U, Cpu, DEVICE, A>> for DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U> + NormalOut<U> + NormalOut<T>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, <<T as NormalOut<U>>::Output as NormalOut<U>>::Output: CommonBounds + Cast<T>, <<T as NormalOut<U>>::Output as NormalOut<T>>::Output: CommonBounds + Cast<U>, <<T as NormalOut<U>>::Output as TypeCommon>::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<<T as NormalOut<U>>::Output as NormalOut<U>>::Output as TypeCommon>::Vec> + NormalOut<<T as TypeCommon>::Vec, Output = <<<T as NormalOut<U>>::Output as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

fn mul(self, rhs: DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the * operation.

impl<T, const DEVICE: usize, Al> Random for DiffTensor<T, Cpu, DEVICE, Al>

where T: CommonBounds + SampleUniform + Float + FloatConst, <T as SampleUniform>::Sampler: Sync, StandardNormal: Distribution<T>, Open01: Distribution<T>, Exp1: Distribution<T>, OpenClosed01: Distribution<T>, Standard: Distribution<T>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Meta = T

Associated type for meta-information or parameters relevant to distributions.

fn randn<S: Into<Shape>>(shape: S) -> Result<Self, TensorError>

Generates a random number array with a standard normal distribution (mean = 0, standard deviation = 1).

fn randn_like(&self) -> Result<Self, TensorError>

Generates a random number array with a standard normal distribution (mean = 0, standard deviation = 1), with the same shape as the calling instance.

fn rand<S: Into<Shape>>( shape: S, low: Self::Meta, high: Self::Meta, ) -> Result<Self, TensorError>

Generates a random number array with a uniform distribution between [0, 1).

fn rand_like( &self, low: Self::Meta, high: Self::Meta, ) -> Result<Self, TensorError>

Generates a random number array with a uniform distribution between [0, 1),

fn beta<S: Into<Shape>>( a: Self::Meta, b: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Beta distribution.

fn beta_like(&self, a: Self::Meta, b: Self::Meta) -> Result<Self, TensorError>

Generates a random number array following the Beta distribution, with the same shape as the calling instance.

fn chisquare<S: Into<Shape>>( df: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Chi-Squared distribution.

fn chisquare_like(&self, df: Self::Meta) -> Result<Self, TensorError>

Generates a random number array following the Chi-Squared distribution, with the same shape as the calling instance.

fn exponential<S: Into<Shape>>( lambda: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Exponential distribution.

fn exponential_like(&self, lambda: Self::Meta) -> Result<Self, TensorError>

Generates a random number array following the Exponential distribution, with the same shape as the calling instance.

fn gamma<S: Into<Shape>>( gamm_shape: Self::Meta, scale: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Gamma distribution.

fn gamma_like( &self, shape: Self::Meta, scale: Self::Meta, ) -> Result<Self, TensorError>

Generates a random number array following the Gamma distribution, with the same shape as the calling instance.

fn gumbel<S: Into<Shape>>( mu: Self::Meta, beta: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Gumbel distribution.

fn gumbel_like( &self, mu: Self::Meta, beta: Self::Meta, ) -> Result<Self, TensorError>

Generates a random number array following the Gumbel distribution, with the same shape as the calling instance.

fn lognormal<S: Into<Shape>>( mean: Self::Meta, std: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Log-Normal distribution.

fn lognormal_like( &self, mean: Self::Meta, std: Self::Meta, ) -> Result<Self, TensorError>

Generates a random number array following the Log-Normal distribution, with the same shape as the calling instance.

fn normal_gaussian<S: Into<Shape>>( mean: Self::Meta, std: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Normal (Gaussian) distribution.

fn normal_gaussian_like( &self, mean: Self::Meta, std: Self::Meta, ) -> Result<Self, TensorError>

Generates a random number array following the Normal (Gaussian) distribution, with the same shape as the calling instance.

fn pareto<S: Into<Shape>>( pareto_shape: Self::Meta, a: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Pareto distribution.

fn pareto_like( &self, pareto_shape: Self::Meta, a: Self::Meta, ) -> Result<Self, TensorError>

Generates a random number array following the Pareto distribution, with the same shape as the calling instance.

fn poisson<S: Into<Shape>>( lambda: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Poisson distribution.

fn poisson_like(&self, lambda: Self::Meta) -> Result<Self, TensorError>

Generates a random number array following the Poisson distribution, with the same shape as the calling instance.

fn weibull<S: Into<Shape>>( a: Self::Meta, b: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Weibull distribution.

fn weibull_like( &self, a: Self::Meta, b: Self::Meta, ) -> Result<Self, TensorError>

Generates a random number array following the Weibull distribution, with the same shape as the calling instance.

fn zipf<S: Into<Shape>>( n: u64, a: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Zipf distribution.

fn zipf_like(&self, n: u64, a: Self::Meta) -> Result<Self, TensorError>

Generates a random number array following the Zipf distribution, with the same shape as the calling instance.

fn triangular<S: Into<Shape>>( low: Self::Meta, high: Self::Meta, mode: Self::Meta, shape: S, ) -> Result<Self, TensorError>

Generates a random number array following the Triangular distribution.

fn triangular_like( &self, low: Self::Meta, high: Self::Meta, mode: Self::Meta, ) -> Result<Self, TensorError>

Generates a random number array following the Triangular distribution, with the same shape as the calling instance.

fn bernoulli<S: Into<Shape>>( shape: S, p: Self::Meta, ) -> Result<Self, TensorError>

where T: Cast<f64>, bool: Cast<T>,

Generates a bernoulli array with values true or false following the Bernoulli distribution.

impl<T, const DEVICE: usize, Al> RandomInt for DiffTensor<T, Cpu, DEVICE, Al>

where T: CommonBounds + SampleUniform, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Meta = T

Associated type for meta-information or parameters relevant to distributions.

fn randint<S: Into<Shape>>( low: Self::Meta, high: Self::Meta, shape: S, ) -> Result<Self, TensorError>

where <T as SampleUniform>::Sampler: Sync,

Generates a random integer array with values in the specified range.

fn randint_like( &self, low: Self::Meta, high: Self::Meta, ) -> Result<Self, TensorError>

where <T as SampleUniform>::Sampler: Sync,

Generates a random integer array with values in the specified range, with the same shape as the calling instance.

impl<T, U, const DEVICE: usize, A> Rem<&DiffTensor<U, Cpu, DEVICE, A>> for &DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T> + FloatOutBinary<U> + Cast<<T as NormalOut<U>>::Output> + NormalOut<<<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, <<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output: CommonBounds + NormalOutUnary, <<T as NormalOut<U>>::Output as NormalOut<<<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output>>::Output: FloatOutUnary + CommonBounds + Cast<U>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: &DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the % operation.

impl<T, U, const DEVICE: usize, A> Rem<&DiffTensor<U, Cpu, DEVICE, A>> for DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T> + FloatOutBinary<U> + Cast<<T as NormalOut<U>>::Output> + NormalOut<<<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, <<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output: CommonBounds + NormalOutUnary, <<T as NormalOut<U>>::Output as NormalOut<<<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output>>::Output: FloatOutUnary + CommonBounds + Cast<U>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: &DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the % operation.

impl<T, U, const DEVICE: usize, A> Rem<DiffTensor<U, Cpu, DEVICE, A>> for &DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T> + FloatOutBinary<U> + Cast<<T as NormalOut<U>>::Output> + NormalOut<<<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, <<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output: CommonBounds + NormalOutUnary, <<T as NormalOut<U>>::Output as NormalOut<<<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output>>::Output: FloatOutUnary + CommonBounds + Cast<U>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the % operation.

impl<T, U, const DEVICE: usize, A> Rem<DiffTensor<U, Cpu, DEVICE, A>> for DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T> + FloatOutBinary<U> + Cast<<T as NormalOut<U>>::Output> + NormalOut<<<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, <<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output: CommonBounds + NormalOutUnary, <<T as NormalOut<U>>::Output as NormalOut<<<T as NormalOut<U>>::Output as FloatOutBinary<U>>::Output>>::Output: FloatOutUnary + CommonBounds + Cast<U>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the % operation.

impl<T: CommonBounds, const DEVICE: usize, Al> ShapeManipulate for DiffTensor<T, Cpu, DEVICE, Al>

where Al: Allocator + 'static + Send + Sync, Al::Output: AllocatorOutputRetrive,

type Meta = T

tensor data type

type Output = DiffTensor<T, Cpu, DEVICE, Al>

the output type

fn squeeze<A: Into<Axis>>(&self, axes: A) -> Result<Self::Output, TensorError>

Removes dimensions of size 1 from the tensor along the specified axes.

fn unsqueeze<A: Into<Axis>>(&self, axes: A) -> Result<Self::Output, TensorError>

Adds a new dimension of size 1 to the tensor at the specified axes.

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

Reshapes the tensor into the specified shape without changing its data.

fn transpose(&self, axis1: i64, axis2: i64) -> Result<Self::Output, TensorError>

Swaps two axes of the tensor, effectively transposing the dimensions along the specified axes.

fn permute<A: Into<Axis>>(&self, axes: A) -> Result<Self::Output, TensorError>

Reorders the dimensions of the tensor according to the specified axes.

fn permute_inv<A: Into<Axis>>( &self, axes: A, ) -> Result<Self::Output, TensorError>

Reverses the permutation of the dimensions of the tensor according to the specified axes.

fn expand<S: Into<Shape>>(&self, shape: S) -> Result<Self::Output, TensorError>

Expands the tensor to a larger shape without copying data, using broadcasting.

fn t(&self) -> Result<Self::Output, TensorError>

Returns the transpose of the tensor by swapping the last two dimensions.

fn mt(&self) -> Result<Self::Output, TensorError>

reverse the dimensions of the tensor.

fn flip<A: Into<Axis>>(&self, axes: A) -> Result<Self::Output, TensorError>

Reverses the order of elements along the specified axes of the tensor.

fn fliplr(&self) -> Result<Self::Output, TensorError>

Reverses the order of elements along the last dimension (columns) of a 2D tensor (matrix).

fn flipud(&self) -> Result<Self::Output, TensorError>

Reverses the order of elements along the first dimension (rows) of a 2D tensor (matrix).

fn tile<S: Into<Axis>>(&self, repeats: S) -> Result<Self::Output, TensorError>

Repeats the tensor along the specified axes according to the given repetition values.

fn trim_zeros(&self, trim: &str) -> Result<Self::Output, TensorError>

where Self::Meta: PartialEq,

Removes leading or trailing zeros from the tensor based on the specified trim mode.

fn repeat(&self, repeats: usize, axes: i16) -> Result<Self::Output, TensorError>

Repeats the elements of the tensor along the specified axis a given number of times.

fn split( &self, indices_or_sections: &[i64], axis: i64, ) -> Result<Vec<Self>, TensorError>

Splits the tensor into multiple sub-tensors along the specified axis.

fn dsplit(&self, indices: &[i64]) -> Result<Vec<Self>, TensorError>

Splits the tensor into multiple sub-tensors along the depth axis (third dimension).

fn hsplit(&self, indices: &[i64]) -> Result<Vec<Self>, TensorError>

Splits the tensor into multiple sub-tensors along the horizontal axis (second dimension).

fn vsplit(&self, indices: &[i64]) -> Result<Vec<Self>, TensorError>

Splits the tensor into multiple sub-tensors along the vertical axis (first dimension).

fn swap_axes(&self, axis1: i64, axis2: i64) -> Result<Self::Output, TensorError>

Swaps two axes of the tensor, effectively transposing the data along the specified axes.

fn flatten<A>(&self, start: A, end: A) -> Result<Self::Output, TensorError>

where A: Into<Option<usize>>,

Flattens a range of dimensions into a single dimension.

impl<T, const DEVICE: usize, Al> Slice for DiffTensor<T, Cpu, DEVICE, Al>

where T: CommonBounds, Al: Allocator + 'static + Send + Sync, Al::Output: AllocatorOutputRetrive,

fn slice( &self, index: &[(i64, i64, i64)], ) -> Result<DiffTensor<T, Cpu, DEVICE, Al>, TensorError>

Extracts a slice of the tensor based on the provided indices.

impl<T, U, const DEVICE: usize, A> Sub<&DiffTensor<U, Cpu, DEVICE, A>> for &DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, Tensor<T, Cpu, DEVICE, A>: Neg<Output = Tensor<T, Cpu, DEVICE, A>>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

fn sub(self, rhs: &DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the - operation.

impl<T, U, const DEVICE: usize, A> Sub<&DiffTensor<U, Cpu, DEVICE, A>> for DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, Tensor<T, Cpu, DEVICE, A>: Neg<Output = Tensor<T, Cpu, DEVICE, A>>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

fn sub(self, rhs: &DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the - operation.

impl<T, U, const DEVICE: usize, A> Sub<DiffTensor<U, Cpu, DEVICE, A>> for &DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, Tensor<T, Cpu, DEVICE, A>: Neg<Output = Tensor<T, Cpu, DEVICE, A>>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

fn sub(self, rhs: DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the - operation.

impl<T, U, const DEVICE: usize, A> Sub<DiffTensor<U, Cpu, DEVICE, A>> for DiffTensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<<T as NormalOut<U>>::Output> + Cast<T> + Cast<U>, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, Tensor<T, Cpu, DEVICE, A>: Neg<Output = Tensor<T, Cpu, DEVICE, A>>, A: Allocator + 'static + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = DiffTensor<<T as NormalOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

fn sub(self, rhs: DiffTensor<U, Cpu, DEVICE, A>) -> Self::Output

Performs the - operation.

impl<T, C, const DEVICE: usize, Al> TensorCmp<T, C> for DiffTensor<T, Cpu, DEVICE, Al>

where T: CommonBounds + Cmp<C, Output = bool>, C: CommonBounds, T::Vec: SimdCmp<C::Vec>, <T::Vec as SimdCmp<C::Vec>>::Output: IntoVec<boolx16>, Al: Allocator + 'static, Al::Output: AllocatorOutputRetrive,

type RHS = DiffTensor<C, Cpu, DEVICE, Al>

right hand side tensor type

type Output = Tensor<bool, Cpu, DEVICE, Al>

output tensor type, normally a boolean tensor

type BoolVector = boolx16

a boolean simd vector

fn tensor_neq<D>(&self, rhs: D) -> Result<Self::Output, TensorError>

where D: Borrow<Self::RHS>,

check if two tensors are equal, return a bool tensor

fn tensor_eq<D>(&self, rhs: D) -> Result<Self::Output, TensorError>

where D: Borrow<Self::RHS>,

check if two tensors are equal, return a bool tensor

fn tensor_lt<D>(&self, rhs: D) -> Result<Self::Output, TensorError>

where D: Borrow<Self::RHS>,

check if two tensors are equal, return a bool tensor

fn tensor_gt<D>(&self, rhs: D) -> Result<Self::Output, TensorError>

where D: Borrow<Self::RHS>,

check if two tensors are equal, return a bool tensor

fn tensor_le<D>(&self, rhs: D) -> Result<Self::Output, TensorError>

where D: Borrow<Self::RHS>,

check if two tensors are equal, return a bool tensor

fn tensor_ge<D>(&self, rhs: D) -> Result<Self::Output, TensorError>

where D: Borrow<Self::RHS>,

check if two tensors are equal, return a bool tensor

impl<T: CommonBounds, const DEVICE: usize, Al> TensorCreator<T> for DiffTensor<T, Cpu, DEVICE, Al>

where Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = DiffTensor<T, Cpu, DEVICE, Al>

the output type of the creator

fn empty<S: Into<Shape>>(shape: S) -> Result<Self::Output, TensorError>

Creates a tensor with uninitialized elements of the specified shape.

fn zeros<S: Into<Shape>>(shape: S) -> Result<Self::Output, TensorError>

Creates a tensor filled with zeros of the specified shape.

fn ones<S: Into<Shape>>(shape: S) -> Result<Self::Output, TensorError>

where u8: Cast<T>,

Creates a tensor filled with ones of the specified shape.

fn empty_like(&self) -> Result<Self::Output, TensorError>

Creates a tensor with uninitialized elements, having the same shape as the input tensor.

fn zeros_like(&self) -> Result<Self::Output, TensorError>

Creates a tensor filled with zeros, having the same shape as the input tensor.

fn ones_like(&self) -> Result<Self::Output, TensorError>

where u8: Cast<T>,

Creates a tensor filled with ones, having the same shape as the input tensor.

fn full<S: Into<Shape>>(val: T, shape: S) -> Result<Self::Output, TensorError>

Creates a tensor filled with a specified value, with the specified shape.

fn full_like(&self, val: T) -> Result<Self::Output, TensorError>

Creates a tensor filled with a specified value, having the same shape as the input tensor.

fn arange<U>(start: U, end: U) -> Result<Self::Output, TensorError>

where usize: Cast<T>, U: Cast<i64> + Cast<T> + Copy,

Creates a tensor with values within a specified range.

fn arange_step(start: T, end: T, step: T) -> Result<Self::Output, TensorError>

where T: Cast<f64> + Cast<usize>, usize: Cast<T>,

Creates a tensor with values within a specified range with a given step size.

fn eye(n: usize, m: usize, k: usize) -> Result<Self::Output, TensorError>

Creates a 2D identity matrix with ones on a diagonal and zeros elsewhere.

fn linspace<U>( start: U, end: U, num: usize, include_end: bool, ) -> Result<Self::Output, TensorError>

where U: Cast<f64> + Cast<T> + Copy, usize: Cast<T>, f64: Cast<T>,

Creates a tensor with evenly spaced values between start and end.

fn logspace( start: T, end: T, num: usize, include_end: bool, base: T, ) -> Result<Self::Output, TensorError>

where T: Cast<f64> + Float + NormalOut<T, Output = T>, usize: Cast<T>, f64: Cast<T>,

Creates a tensor with logarithmically spaced values between start and end.

fn geomspace( start: T, end: T, n: usize, include_end: bool, ) -> Result<Self::Output, TensorError>

where f64: Cast<T>, usize: Cast<T>, T: Cast<f64>,

Creates a tensor with geometrically spaced values between start and end.

fn tri( n: usize, m: usize, k: i64, low_triangle: bool, ) -> Result<Self::Output, TensorError>

where u8: Cast<T>,

Creates a 2D triangular matrix of size n by m, with ones below or on the kth diagonal and zeros elsewhere.

fn tril(&self, k: i64) -> Result<Self::Output, TensorError>

where T: NormalOut<bool, Output = T> + Cast<T> + TypeCommon, T::Vec: NormalOut<boolx16, Output = T::Vec>,

Returns the lower triangular part of the matrix, with all elements above the kth diagonal set to zero.

fn triu(&self, k: i64) -> Result<Self::Output, TensorError>

where T: NormalOut<bool, Output = T> + Cast<T> + TypeCommon, T::Vec: NormalOut<boolx16, Output = T::Vec>,

Returns the upper triangular part of the matrix, with all elements below the kth diagonal set to zero.

fn identity(n: usize) -> Result<Self::Output, TensorError>

where u8: Cast<T>,

Creates a 2D identity matrix of size n by n.