Struct Tensor 

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

Tensor is alias of N-dimensional array.

Properties

• data: The pointer to the data.
• layout: The layout of the tensor. We can get strides, shape, ndim, size from it.
• parent: The parent tensor of the tensor. parent is always the root tensor (not a view).
• mem_layout: std::alloc::layout, use for deallocate the memory and find cache in the allocator.

Implementations

impl<T, A2, const DEVICE: usize> Tensor<T, Cpu, DEVICE, A2>

where T: CommonBounds + Eval, <T as Eval>::Output: CommonBounds, T::Vec: Eval<Output = <<T as Eval>::Output as TypeCommon>::Vec>, A2: Allocator, A2::Output: AllocatorOutputRetrive,

pub fn is_inf( &self, ) -> Result<Tensor<<T as Eval>::Output, Cpu, DEVICE, A2>, TensorError>

Checks for infinity (inf) values in the tensor.

This method returns a new tensor where each element indicates whether the corresponding element in the input tensor is an infinity value (+inf or -inf). The output tensor will contain boolean-like values (1 for inf, 0 for non-inf).

Returns

This function returns a Result containing a tensor of type _Tensor<<T as Eval>::Output>, where each element is either 1 (if the corresponding element is inf) or 0 (if it is not).

pub fn is_nan( &self, ) -> Result<Tensor<<T as Eval>::Output, Cpu, DEVICE, A2>, TensorError>

Checks for NaN (Not-a-Number) values in the tensor.

This method returns a new tensor where each element indicates whether the corresponding element in the input tensor is a NaN value. The output tensor will contain boolean-like values (1 for NaN, 0 for non-NaN).

Returns

This function returns a Result containing a tensor of type _Tensor<<T as Eval>::Output>, where each element is either 1 (if the corresponding element is NaN) or 0 (if it is not).

impl<T: CommonBounds, const DEVICE: usize, A> Tensor<T, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

pub unsafe fn from_raw<S: Into<Shape>>( data: *mut T, shape: S, ) -> Result<Self, TensorError>

create a new tensor from a raw pointer and a shape.

Note

It is safer to call forget to get the pointer back because the forget method will track the reference count

Safety

• The pointer must be valid for the lifetime of the tensor.
• The pointer must be aligned and properly sized.
• The shape must be valid.

Note

It is the user’s responsibility to manage the lifetime of the data. Hpt won’t drop the data even if the tensor is dropped.

pub fn astype<U>(&self) -> Result<Tensor<U, Cpu, DEVICE, A>, TensorError>

where U: CommonBounds, T: Cast<U>,

cast the tensor to the new type

pub fn allclose( &self, other: &Tensor<T, Cpu, DEVICE, A>, rtol: T, atol: T, ) -> bool

where T: Eval<Output = bool> + Cmp<Output = bool>,

check if two tensors are close to each other

pub unsafe fn forget(self) -> Result<(*mut u8, Layout), TensorError>

Forget the tensor, return the raw pointer of the data

Safety

• The user must ensure the tensor is not used after forgetting

pub unsafe fn forget_copy(&self) -> Result<(*mut u8, Layout), TensorError>

clone the tensor and return the cloned tensor data

impl<T, const DEVICE: usize, Al> Tensor<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 tensor from the provided data.

Trait Implementations

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for Complex32

where T: CommonBounds, Complex32: NormalOut<T>, <Complex32 as NormalOut<T>>::Output: CommonBounds, <Complex32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f32> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for Complex64

where T: CommonBounds, Complex64: NormalOut<T>, <Complex64 as NormalOut<T>>::Output: CommonBounds, <Complex64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f64> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for bf16

where T: CommonBounds, bf16: NormalOut<T>, <bf16 as NormalOut<T>>::Output: CommonBounds, <bf16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bf16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bf16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: NormalOut<T>, <bool as NormalOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bool as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for f16

where T: CommonBounds, f16: NormalOut<T>, <f16 as NormalOut<T>>::Output: CommonBounds, <f16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for f32

where T: CommonBounds, f32: NormalOut<T>, <f32 as NormalOut<T>>::Output: CommonBounds, <f32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for f64

where T: CommonBounds, f64: NormalOut<T>, <f64 as NormalOut<T>>::Output: CommonBounds, <f64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: NormalOut<T>, <i16 as NormalOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: NormalOut<T>, <i32 as NormalOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: NormalOut<T>, <i64 as NormalOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: NormalOut<T>, <i8 as NormalOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: NormalOut<T>, <u16 as NormalOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: NormalOut<T>, <u32 as NormalOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: NormalOut<T>, <u64 as NormalOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<&Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: NormalOut<T>, <u8 as NormalOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Complex<f32>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex32>, <T as NormalOut<Complex32>>::Output: CommonBounds + Cast<<T as NormalOut<Complex32>>::Output>, T::Vec: NormalOut<<Complex32 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f32>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Complex<f32>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex32>, <T as NormalOut<Complex32>>::Output: CommonBounds + Cast<<T as NormalOut<Complex32>>::Output>, T::Vec: NormalOut<<Complex32 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f32>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Complex<f64>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex64>, <T as NormalOut<Complex64>>::Output: CommonBounds + Cast<<T as NormalOut<Complex64>>::Output>, T::Vec: NormalOut<<Complex64 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f64>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Complex<f64>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex64>, <T as NormalOut<Complex64>>::Output: CommonBounds + Cast<<T as NormalOut<Complex64>>::Output>, T::Vec: NormalOut<<Complex64 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f64>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for Complex32

where T: CommonBounds, Complex32: NormalOut<T>, <Complex32 as NormalOut<T>>::Output: CommonBounds, <Complex32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f32> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for Complex64

where T: CommonBounds, Complex64: NormalOut<T>, <Complex64 as NormalOut<T>>::Output: CommonBounds, <Complex64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f64> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for bf16

where T: CommonBounds, bf16: NormalOut<T>, <bf16 as NormalOut<T>>::Output: CommonBounds, <bf16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bf16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bf16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: NormalOut<T>, <bool as NormalOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bool as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for f16

where T: CommonBounds, f16: NormalOut<T>, <f16 as NormalOut<T>>::Output: CommonBounds, <f16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for f32

where T: CommonBounds, f32: NormalOut<T>, <f32 as NormalOut<T>>::Output: CommonBounds, <f32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for f64

where T: CommonBounds, f64: NormalOut<T>, <f64 as NormalOut<T>>::Output: CommonBounds, <f64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: NormalOut<T>, <i16 as NormalOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: NormalOut<T>, <i32 as NormalOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: NormalOut<T>, <i64 as NormalOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: NormalOut<T>, <i8 as NormalOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: NormalOut<T>, <u16 as NormalOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: NormalOut<T>, <u32 as NormalOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: NormalOut<T>, <u64 as NormalOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: NormalOut<T>, <u8 as NormalOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<bf16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bf16>, <T as NormalOut<bf16>>::Output: CommonBounds + Cast<<T as NormalOut<bf16>>::Output>, T::Vec: NormalOut<<bf16 as TypeCommon>::Vec, Output = <<T as NormalOut<bf16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bf16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<bf16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bf16>, <T as NormalOut<bf16>>::Output: CommonBounds + Cast<<T as NormalOut<bf16>>::Output>, T::Vec: NormalOut<<bf16 as TypeCommon>::Vec, Output = <<T as NormalOut<bf16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bf16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<bool> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bool>, <T as NormalOut<bool>>::Output: CommonBounds + Cast<<T as NormalOut<bool>>::Output>, T::Vec: NormalOut<<bool as TypeCommon>::Vec, Output = <<T as NormalOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<bool> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bool>, <T as NormalOut<bool>>::Output: CommonBounds + Cast<<T as NormalOut<bool>>::Output>, T::Vec: NormalOut<<bool as TypeCommon>::Vec, Output = <<T as NormalOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<f16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f16>, <T as NormalOut<f16>>::Output: CommonBounds + Cast<<T as NormalOut<f16>>::Output>, T::Vec: NormalOut<<f16 as TypeCommon>::Vec, Output = <<T as NormalOut<f16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<f16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f16>, <T as NormalOut<f16>>::Output: CommonBounds + Cast<<T as NormalOut<f16>>::Output>, T::Vec: NormalOut<<f16 as TypeCommon>::Vec, Output = <<T as NormalOut<f16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<f32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f32>, <T as NormalOut<f32>>::Output: CommonBounds + Cast<<T as NormalOut<f32>>::Output>, T::Vec: NormalOut<<f32 as TypeCommon>::Vec, Output = <<T as NormalOut<f32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<f32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f32>, <T as NormalOut<f32>>::Output: CommonBounds + Cast<<T as NormalOut<f32>>::Output>, T::Vec: NormalOut<<f32 as TypeCommon>::Vec, Output = <<T as NormalOut<f32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<f64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f64>, <T as NormalOut<f64>>::Output: CommonBounds + Cast<<T as NormalOut<f64>>::Output>, T::Vec: NormalOut<<f64 as TypeCommon>::Vec, Output = <<T as NormalOut<f64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<f64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f64>, <T as NormalOut<f64>>::Output: CommonBounds + Cast<<T as NormalOut<f64>>::Output>, T::Vec: NormalOut<<f64 as TypeCommon>::Vec, Output = <<T as NormalOut<f64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<i16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i16>, <T as NormalOut<i16>>::Output: CommonBounds + Cast<<T as NormalOut<i16>>::Output>, T::Vec: NormalOut<<i16 as TypeCommon>::Vec, Output = <<T as NormalOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<i16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i16>, <T as NormalOut<i16>>::Output: CommonBounds + Cast<<T as NormalOut<i16>>::Output>, T::Vec: NormalOut<<i16 as TypeCommon>::Vec, Output = <<T as NormalOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<i32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i32>, <T as NormalOut<i32>>::Output: CommonBounds + Cast<<T as NormalOut<i32>>::Output>, T::Vec: NormalOut<<i32 as TypeCommon>::Vec, Output = <<T as NormalOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<i32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i32>, <T as NormalOut<i32>>::Output: CommonBounds + Cast<<T as NormalOut<i32>>::Output>, T::Vec: NormalOut<<i32 as TypeCommon>::Vec, Output = <<T as NormalOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<i64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i64>, <T as NormalOut<i64>>::Output: CommonBounds + Cast<<T as NormalOut<i64>>::Output>, T::Vec: NormalOut<<i64 as TypeCommon>::Vec, Output = <<T as NormalOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<i64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i64>, <T as NormalOut<i64>>::Output: CommonBounds + Cast<<T as NormalOut<i64>>::Output>, T::Vec: NormalOut<<i64 as TypeCommon>::Vec, Output = <<T as NormalOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<i8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i8>, <T as NormalOut<i8>>::Output: CommonBounds + Cast<<T as NormalOut<i8>>::Output>, T::Vec: NormalOut<<i8 as TypeCommon>::Vec, Output = <<T as NormalOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<i8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i8>, <T as NormalOut<i8>>::Output: CommonBounds + Cast<<T as NormalOut<i8>>::Output>, T::Vec: NormalOut<<i8 as TypeCommon>::Vec, Output = <<T as NormalOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<u16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u16>, <T as NormalOut<u16>>::Output: CommonBounds + Cast<<T as NormalOut<u16>>::Output>, T::Vec: NormalOut<<u16 as TypeCommon>::Vec, Output = <<T as NormalOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<u16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u16>, <T as NormalOut<u16>>::Output: CommonBounds + Cast<<T as NormalOut<u16>>::Output>, T::Vec: NormalOut<<u16 as TypeCommon>::Vec, Output = <<T as NormalOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<u32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u32>, <T as NormalOut<u32>>::Output: CommonBounds + Cast<<T as NormalOut<u32>>::Output>, T::Vec: NormalOut<<u32 as TypeCommon>::Vec, Output = <<T as NormalOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<u32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u32>, <T as NormalOut<u32>>::Output: CommonBounds + Cast<<T as NormalOut<u32>>::Output>, T::Vec: NormalOut<<u32 as TypeCommon>::Vec, Output = <<T as NormalOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<u64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u64>, <T as NormalOut<u64>>::Output: CommonBounds + Cast<<T as NormalOut<u64>>::Output>, T::Vec: NormalOut<<u64 as TypeCommon>::Vec, Output = <<T as NormalOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<u64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u64>, <T as NormalOut<u64>>::Output: CommonBounds + Cast<<T as NormalOut<u64>>::Output>, T::Vec: NormalOut<<u64 as TypeCommon>::Vec, Output = <<T as NormalOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<u8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u8>, <T as NormalOut<u8>>::Output: CommonBounds + Cast<<T as NormalOut<u8>>::Output>, T::Vec: NormalOut<<u8 as TypeCommon>::Vec, Output = <<T as NormalOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const DEVICE: usize, A> Add<u8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u8>, <T as NormalOut<u8>>::Output: CommonBounds + Cast<<T as NormalOut<u8>>::Output>, T::Vec: NormalOut<<u8 as TypeCommon>::Vec, Output = <<T as NormalOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, U, const DEVICE: usize, A> AddAssign<&Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T>, A: Allocator, A::Output: AllocatorOutputRetrive,

fn add_assign(&mut self, rhs: &Tensor<U, Cpu, DEVICE, A>)

Performs the += operation.

impl<T, U, const DEVICE: usize, A> AddAssign<Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T>, A: Allocator, A::Output: AllocatorOutputRetrive,

fn add_assign(&mut self, rhs: Tensor<U, Cpu, DEVICE, A>)

Performs the += operation.

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

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

type Meta = T

The type of the meta data

type Output = Tensor<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>

Pads a tensor with a given constant value. For each dimension, adds padding at the start and end as specified by pads.

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

Returns the k largest or smallest elements along a specified dimension, and their indices.

fn onehot( &self, depth: usize, axis: i64, true_val: Self::Meta, false_val: Self::Meta, ) -> Result<Self::Output, TensorError>

Creates a one-hot tensor from the input tensor.

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

Writes values from src tensor into a new tensor at the indices specified by indices along dimension axis.

impl<T, const DEVICE: usize, A> BitAnd<&Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: BitWiseOut<T>, <bool as BitWiseOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<bool as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<&Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: BitWiseOut<T>, <i16 as BitWiseOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<&Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: BitWiseOut<T>, <i32 as BitWiseOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<&Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: BitWiseOut<T>, <i64 as BitWiseOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<&Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: BitWiseOut<T>, <i8 as BitWiseOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<&Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: BitWiseOut<T>, <u16 as BitWiseOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<&Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: BitWiseOut<T>, <u32 as BitWiseOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<&Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: BitWiseOut<T>, <u64 as BitWiseOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<&Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: BitWiseOut<T>, <u8 as BitWiseOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, U, const DEVICE: usize, A> BitAnd<&Tensor<U, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, U, const DEVICE: usize, A> BitAnd<&Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: BitWiseOut<T>, <bool as BitWiseOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<bool as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: BitWiseOut<T>, <i16 as BitWiseOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: BitWiseOut<T>, <i32 as BitWiseOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: BitWiseOut<T>, <i64 as BitWiseOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: BitWiseOut<T>, <i8 as BitWiseOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: BitWiseOut<T>, <u16 as BitWiseOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: BitWiseOut<T>, <u32 as BitWiseOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: BitWiseOut<T>, <u64 as BitWiseOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: BitWiseOut<T>, <u8 as BitWiseOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the & operation.

impl<T, U, const DEVICE: usize, A> BitAnd<Tensor<U, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, U, const DEVICE: usize, A> BitAnd<Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<bool> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<bool>, <T as BitWiseOut<bool>>::Output: CommonBounds, T::Vec: BitWiseOut<<bool as TypeCommon>::Vec, Output = <<T as BitWiseOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<bool> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<bool>, <T as BitWiseOut<bool>>::Output: CommonBounds, T::Vec: BitWiseOut<<bool as TypeCommon>::Vec, Output = <<T as BitWiseOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<i16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i16>, <T as BitWiseOut<i16>>::Output: CommonBounds, T::Vec: BitWiseOut<<i16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<i16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i16>, <T as BitWiseOut<i16>>::Output: CommonBounds, T::Vec: BitWiseOut<<i16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<i32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i32>, <T as BitWiseOut<i32>>::Output: CommonBounds, T::Vec: BitWiseOut<<i32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<i32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i32>, <T as BitWiseOut<i32>>::Output: CommonBounds, T::Vec: BitWiseOut<<i32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<i64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i64>, <T as BitWiseOut<i64>>::Output: CommonBounds, T::Vec: BitWiseOut<<i64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<i64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i64>, <T as BitWiseOut<i64>>::Output: CommonBounds, T::Vec: BitWiseOut<<i64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<i8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i8>, <T as BitWiseOut<i8>>::Output: CommonBounds, T::Vec: BitWiseOut<<i8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<i8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i8>, <T as BitWiseOut<i8>>::Output: CommonBounds, T::Vec: BitWiseOut<<i8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<u16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u16>, <T as BitWiseOut<u16>>::Output: CommonBounds, T::Vec: BitWiseOut<<u16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<u16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u16>, <T as BitWiseOut<u16>>::Output: CommonBounds, T::Vec: BitWiseOut<<u16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<u32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u32>, <T as BitWiseOut<u32>>::Output: CommonBounds, T::Vec: BitWiseOut<<u32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<u32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u32>, <T as BitWiseOut<u32>>::Output: CommonBounds, T::Vec: BitWiseOut<<u32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<u64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u64>, <T as BitWiseOut<u64>>::Output: CommonBounds, T::Vec: BitWiseOut<<u64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<u64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u64>, <T as BitWiseOut<u64>>::Output: CommonBounds, T::Vec: BitWiseOut<<u64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<u8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u8>, <T as BitWiseOut<u8>>::Output: CommonBounds, T::Vec: BitWiseOut<<u8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitAnd<u8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u8>, <T as BitWiseOut<u8>>::Output: CommonBounds, T::Vec: BitWiseOut<<u8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const DEVICE: usize, A> BitOr<&Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: BitWiseOut<T>, <bool as BitWiseOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<bool as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<&Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: BitWiseOut<T>, <i16 as BitWiseOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<&Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: BitWiseOut<T>, <i32 as BitWiseOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<&Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: BitWiseOut<T>, <i64 as BitWiseOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<&Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: BitWiseOut<T>, <i8 as BitWiseOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<&Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: BitWiseOut<T>, <u16 as BitWiseOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<&Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: BitWiseOut<T>, <u32 as BitWiseOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<&Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: BitWiseOut<T>, <u64 as BitWiseOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<&Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: BitWiseOut<T>, <u8 as BitWiseOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, U, const DEVICE: usize, A> BitOr<&Tensor<U, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, U, const DEVICE: usize, A> BitOr<&Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: BitWiseOut<T>, <bool as BitWiseOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<bool as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: BitWiseOut<T>, <i16 as BitWiseOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: BitWiseOut<T>, <i32 as BitWiseOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: BitWiseOut<T>, <i64 as BitWiseOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: BitWiseOut<T>, <i8 as BitWiseOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: BitWiseOut<T>, <u16 as BitWiseOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: BitWiseOut<T>, <u32 as BitWiseOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: BitWiseOut<T>, <u64 as BitWiseOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: BitWiseOut<T>, <u8 as BitWiseOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the | operation.

impl<T, U, const DEVICE: usize, A> BitOr<Tensor<U, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, U, const DEVICE: usize, A> BitOr<Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<bool> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<bool>, <T as BitWiseOut<bool>>::Output: CommonBounds, T::Vec: BitWiseOut<<bool as TypeCommon>::Vec, Output = <<T as BitWiseOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<bool> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<bool>, <T as BitWiseOut<bool>>::Output: CommonBounds, T::Vec: BitWiseOut<<bool as TypeCommon>::Vec, Output = <<T as BitWiseOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<i16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i16>, <T as BitWiseOut<i16>>::Output: CommonBounds, T::Vec: BitWiseOut<<i16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<i16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i16>, <T as BitWiseOut<i16>>::Output: CommonBounds, T::Vec: BitWiseOut<<i16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<i32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i32>, <T as BitWiseOut<i32>>::Output: CommonBounds, T::Vec: BitWiseOut<<i32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<i32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i32>, <T as BitWiseOut<i32>>::Output: CommonBounds, T::Vec: BitWiseOut<<i32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<i64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i64>, <T as BitWiseOut<i64>>::Output: CommonBounds, T::Vec: BitWiseOut<<i64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<i64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i64>, <T as BitWiseOut<i64>>::Output: CommonBounds, T::Vec: BitWiseOut<<i64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<i8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i8>, <T as BitWiseOut<i8>>::Output: CommonBounds, T::Vec: BitWiseOut<<i8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<i8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i8>, <T as BitWiseOut<i8>>::Output: CommonBounds, T::Vec: BitWiseOut<<i8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<u16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u16>, <T as BitWiseOut<u16>>::Output: CommonBounds, T::Vec: BitWiseOut<<u16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<u16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u16>, <T as BitWiseOut<u16>>::Output: CommonBounds, T::Vec: BitWiseOut<<u16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<u32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u32>, <T as BitWiseOut<u32>>::Output: CommonBounds, T::Vec: BitWiseOut<<u32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<u32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u32>, <T as BitWiseOut<u32>>::Output: CommonBounds, T::Vec: BitWiseOut<<u32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<u64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u64>, <T as BitWiseOut<u64>>::Output: CommonBounds, T::Vec: BitWiseOut<<u64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<u64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u64>, <T as BitWiseOut<u64>>::Output: CommonBounds, T::Vec: BitWiseOut<<u64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<u8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u8>, <T as BitWiseOut<u8>>::Output: CommonBounds, T::Vec: BitWiseOut<<u8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitOr<u8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u8>, <T as BitWiseOut<u8>>::Output: CommonBounds, T::Vec: BitWiseOut<<u8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const DEVICE: usize, A> BitXor<&Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: BitWiseOut<T>, <bool as BitWiseOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<bool as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<&Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: BitWiseOut<T>, <i16 as BitWiseOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<&Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: BitWiseOut<T>, <i32 as BitWiseOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<&Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: BitWiseOut<T>, <i64 as BitWiseOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<&Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: BitWiseOut<T>, <i8 as BitWiseOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<&Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: BitWiseOut<T>, <u16 as BitWiseOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<&Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: BitWiseOut<T>, <u32 as BitWiseOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<&Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: BitWiseOut<T>, <u64 as BitWiseOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<&Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: BitWiseOut<T>, <u8 as BitWiseOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, U, const DEVICE: usize, A> BitXor<&Tensor<U, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, U, const DEVICE: usize, A> BitXor<&Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: BitWiseOut<T>, <bool as BitWiseOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<bool as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: BitWiseOut<T>, <i16 as BitWiseOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: BitWiseOut<T>, <i32 as BitWiseOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: BitWiseOut<T>, <i64 as BitWiseOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: BitWiseOut<T>, <i8 as BitWiseOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: BitWiseOut<T>, <u16 as BitWiseOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: BitWiseOut<T>, <u32 as BitWiseOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: BitWiseOut<T>, <u64 as BitWiseOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: BitWiseOut<T>, <u8 as BitWiseOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the ^ operation.

impl<T, U, const DEVICE: usize, A> BitXor<Tensor<U, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, U, const DEVICE: usize, A> BitXor<Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<bool> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<bool>, <T as BitWiseOut<bool>>::Output: CommonBounds, T::Vec: BitWiseOut<<bool as TypeCommon>::Vec, Output = <<T as BitWiseOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<bool> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<bool>, <T as BitWiseOut<bool>>::Output: CommonBounds, T::Vec: BitWiseOut<<bool as TypeCommon>::Vec, Output = <<T as BitWiseOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<i16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i16>, <T as BitWiseOut<i16>>::Output: CommonBounds, T::Vec: BitWiseOut<<i16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<i16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i16>, <T as BitWiseOut<i16>>::Output: CommonBounds, T::Vec: BitWiseOut<<i16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<i32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i32>, <T as BitWiseOut<i32>>::Output: CommonBounds, T::Vec: BitWiseOut<<i32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<i32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i32>, <T as BitWiseOut<i32>>::Output: CommonBounds, T::Vec: BitWiseOut<<i32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<i64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i64>, <T as BitWiseOut<i64>>::Output: CommonBounds, T::Vec: BitWiseOut<<i64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<i64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i64>, <T as BitWiseOut<i64>>::Output: CommonBounds, T::Vec: BitWiseOut<<i64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<i8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i8>, <T as BitWiseOut<i8>>::Output: CommonBounds, T::Vec: BitWiseOut<<i8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<i8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i8>, <T as BitWiseOut<i8>>::Output: CommonBounds, T::Vec: BitWiseOut<<i8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<u16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u16>, <T as BitWiseOut<u16>>::Output: CommonBounds, T::Vec: BitWiseOut<<u16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<u16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u16>, <T as BitWiseOut<u16>>::Output: CommonBounds, T::Vec: BitWiseOut<<u16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<u32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u32>, <T as BitWiseOut<u32>>::Output: CommonBounds, T::Vec: BitWiseOut<<u32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<u32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u32>, <T as BitWiseOut<u32>>::Output: CommonBounds, T::Vec: BitWiseOut<<u32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<u64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u64>, <T as BitWiseOut<u64>>::Output: CommonBounds, T::Vec: BitWiseOut<<u64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<u64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u64>, <T as BitWiseOut<u64>>::Output: CommonBounds, T::Vec: BitWiseOut<<u64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<u8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u8>, <T as BitWiseOut<u8>>::Output: CommonBounds, T::Vec: BitWiseOut<<u8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const DEVICE: usize, A> BitXor<u8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u8>, <T as BitWiseOut<u8>>::Output: CommonBounds, T::Vec: BitWiseOut<<u8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, B, const DEVICE: usize, A> CPUTensorCreator for Tensor<T, B, DEVICE, A>

where T: CommonBounds + AnyBitPattern, B: BackendTy + Buffer, A: Allocator, Tensor<T, Cpu, DEVICE, A::CpuAllocator>: TensorCreator<Output = Tensor<T, Cpu, DEVICE, A::CpuAllocator>>,

type Output = Tensor<T, Cpu, DEVICE, <A as Allocator>::CpuAllocator>

the output type of the creator

type Meta = T

the meta type of the tensor

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

Creates a tensor with uninitialized elements of the specified shape.

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

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

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

the output type of concat

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

Concatenates a sequence of tensors along the specified axis.

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

Stacks tensors vertically (along axis 0). This is equivalent to concatenation along the first axis.

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

Stacks tensors horizontally (along axis 1 for 2D+ tensors, or axis 0 for 1D tensors).

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

Stacks tensors along the third axis (depth). Input tensors are promoted to 3D if necessary.

impl<T, const DEVICE: usize, Al> Contiguous for Tensor<T, Cpu, DEVICE, Al>

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

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

Returns the tensor as a contiguous tensor.

impl<T, const DEVICE: usize> Conv<T> for Tensor<T, Cpu, DEVICE>

where T: CommonBounds + Cast<T> + NormalOut<Output = T> + Conv2dMicroKernel + MatmulMicroKernel + Cast<<T as NormalOutPromote>::Intermediate>, <T as NormalOutPromote>::Intermediate: CommonBounds + Cast<T>, T::Vec: VecTrait<T> + Copy + Send + Sync + NormalOut<Output = T::Vec>, bool: Cast<T>,

type Output = Tensor<T, Cpu, DEVICE>

the output type of the conv operation

fn conv2d( &self, kernels: &Self::Output, bias: Option<&Self::Output>, steps: [i64; 2], padding: [(i64, i64); 2], dilation: [i64; 2], post_scalar: Option<fn(T) -> T>, post_vec: Option<fn(T::Vec) -> T::Vec>, ) -> Result<Self::Output, TensorError>

Performs a 2D convolution operation with support for stride, padding, dilation, and activation functions.

fn conv2d_group( &self, kernels: &Self::Output, bias: Option<&Self::Output>, steps: [i64; 2], padding: [(i64, i64); 2], dilation: [i64; 2], groups: i64, post_scalar: Option<fn(T) -> T>, post_vec: Option<fn(T::Vec) -> T::Vec>, ) -> Result<Self::Output, TensorError>

Performs a grouped 2D convolution operation, which divides input channels into groups and performs separate convolutions on each group.

fn dwconv2d( &self, kernels: &Self::Output, bias: Option<&Self::Output>, steps: [i64; 2], padding: [(i64, i64); 2], dilation: [i64; 2], post_scalar: Option<fn(T) -> T>, post_vec: Option<fn(T::Vec) -> T::Vec>, ) -> Result<Self::Output, TensorError>

Performs a depthwise 2D convolution operation with support for stride, padding, dilation, and activation functions.

fn conv2d_transpose( &self, kernels: &Self::Output, steps: [i64; 2], padding: [(i64, i64); 2], output_padding: [i64; 2], dilation: [i64; 2], post_scalar: Option<fn(T) -> T>, post_vec: Option<fn(T::Vec) -> T::Vec>, ) -> Result<Self::Output, TensorError>

Performs a transpose 2D convolution operation with support for stride, padding, dilation, and activation functions.

impl<T, const DEVICE: usize, A> ConvBatchNorm<T> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + Conv2dMicroKernel + MatmulMicroKernel + FloatOutBinary<Output = T> + FloatOutUnary<Output = T>, T::Vec: FloatOutBinary<Output = T::Vec> + FloatOutUnary<Output = T::Vec>, A: Allocator + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = Tensor<T, Cpu, DEVICE, A>

the output type of the conv operation

fn batchnorm_conv2d( &self, kernels: &Self::Output, mean: &Self::Output, var: &Self::Output, gamma: &Self::Output, beta: &Self::Output, bias: Option<&Self::Output>, eps: T, steps: [i64; 2], padding: [(i64, i64); 2], dilation: [i64; 2], post_scalar: Option<fn(T) -> T>, post_vec: Option<fn(T::Vec) -> T::Vec>, ) -> Result<Self::Output, TensorError>

Performs a 2D convolution operation followed by batch normalization in a single fused operation for improved performance.

impl<T: CommonBounds, const DEVICE: usize, Al> CumulativeOps for Tensor<T, Cpu, DEVICE, Al>

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

fn cumsum<A: Into<Option<i64>>>(&self, axis: A) -> Result<Self, TensorError>

Computes the cumulative sum of tensor elements along a specified axis.

fn cumprod<A: Into<Option<i64>>>(&self, axis: A) -> Result<Self, TensorError>

Computes the cumulative product of tensor elements along a specified axis.

impl<T, B: BackendTy + Buffer, const DEVICE: usize, Al> Debug for Tensor<T, B, DEVICE, Al>

where T: CommonBounds + Cast<f64>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

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

Formats the value using the given formatter.

impl<T, const DEVICE: usize, Al> Display for Tensor<T, Cpu, DEVICE, Al>

where T: CommonBounds + Cast<f64>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

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

Formats the value using the given formatter.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for Complex32

where T: CommonBounds, Complex32: FloatOutBinary<T>, <Complex32 as FloatOutBinary<T>>::Output: CommonBounds, <Complex32 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<Complex32 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f32> as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for Complex64

where T: CommonBounds, Complex64: FloatOutBinary<T>, <Complex64 as FloatOutBinary<T>>::Output: CommonBounds, <Complex64 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<Complex64 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f64> as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for bf16

where T: CommonBounds, bf16: FloatOutBinary<T>, <bf16 as FloatOutBinary<T>>::Output: CommonBounds, <bf16 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<bf16 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bf16 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: FloatOutBinary<T>, <bool as FloatOutBinary<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<bool as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for f16

where T: CommonBounds, f16: FloatOutBinary<T>, <f16 as FloatOutBinary<T>>::Output: CommonBounds, <f16 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<f16 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f16 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for f32

where T: CommonBounds, f32: FloatOutBinary<T>, <f32 as FloatOutBinary<T>>::Output: CommonBounds, <f32 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<f32 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f32 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for f64

where T: CommonBounds, f64: FloatOutBinary<T>, <f64 as FloatOutBinary<T>>::Output: CommonBounds, <f64 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<f64 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f64 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: FloatOutBinary<T>, <i16 as FloatOutBinary<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<i16 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: FloatOutBinary<T>, <i32 as FloatOutBinary<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<i32 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: FloatOutBinary<T>, <i64 as FloatOutBinary<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<i64 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: FloatOutBinary<T>, <i8 as FloatOutBinary<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<i8 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: FloatOutBinary<T>, <u16 as FloatOutBinary<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<u16 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: FloatOutBinary<T>, <u32 as FloatOutBinary<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<u32 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: FloatOutBinary<T>, <u64 as FloatOutBinary<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<u64 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<&Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: FloatOutBinary<T>, <u8 as FloatOutBinary<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<u8 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where T: CommonBounds + FloatOutBinary<U>, U: CommonBounds, <T as FloatOutBinary<U>>::Output: CommonBounds, T::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

where T: CommonBounds + FloatOutBinary<U>, U: CommonBounds, <T as FloatOutBinary<U>>::Output: CommonBounds, T::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Complex<f32>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<Complex32>, <T as FloatOutBinary<Complex32>>::Output: CommonBounds, T::Vec: FloatOutBinary<<Complex32 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<Complex32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<Complex<f32>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Complex<f32>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<Complex32>, <T as FloatOutBinary<Complex32>>::Output: CommonBounds, T::Vec: FloatOutBinary<<Complex32 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<Complex32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<Complex<f32>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Complex<f64>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<Complex64>, <T as FloatOutBinary<Complex64>>::Output: CommonBounds, T::Vec: FloatOutBinary<<Complex64 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<Complex64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<Complex<f64>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Complex<f64>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<Complex64>, <T as FloatOutBinary<Complex64>>::Output: CommonBounds, T::Vec: FloatOutBinary<<Complex64 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<Complex64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<Complex<f64>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for Complex32

where T: CommonBounds, Complex32: FloatOutBinary<T>, <Complex32 as FloatOutBinary<T>>::Output: CommonBounds, <Complex32 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<Complex32 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f32> as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for Complex64

where T: CommonBounds, Complex64: FloatOutBinary<T>, <Complex64 as FloatOutBinary<T>>::Output: CommonBounds, <Complex64 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<Complex64 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f64> as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for bf16

where T: CommonBounds, bf16: FloatOutBinary<T>, <bf16 as FloatOutBinary<T>>::Output: CommonBounds, <bf16 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<bf16 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bf16 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: FloatOutBinary<T>, <bool as FloatOutBinary<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<bool as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for f16

where T: CommonBounds, f16: FloatOutBinary<T>, <f16 as FloatOutBinary<T>>::Output: CommonBounds, <f16 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<f16 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f16 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for f32

where T: CommonBounds, f32: FloatOutBinary<T>, <f32 as FloatOutBinary<T>>::Output: CommonBounds, <f32 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<f32 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f32 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for f64

where T: CommonBounds, f64: FloatOutBinary<T>, <f64 as FloatOutBinary<T>>::Output: CommonBounds, <f64 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<f64 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f64 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: FloatOutBinary<T>, <i16 as FloatOutBinary<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<i16 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: FloatOutBinary<T>, <i32 as FloatOutBinary<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<i32 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: FloatOutBinary<T>, <i64 as FloatOutBinary<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<i64 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: FloatOutBinary<T>, <i8 as FloatOutBinary<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<i8 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: FloatOutBinary<T>, <u16 as FloatOutBinary<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<u16 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: FloatOutBinary<T>, <u32 as FloatOutBinary<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<u32 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: FloatOutBinary<T>, <u64 as FloatOutBinary<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<u64 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: FloatOutBinary<T>, <u8 as FloatOutBinary<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: FloatOutBinary<<T as TypeCommon>::Vec, Output = <<u8 as FloatOutBinary<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as FloatOutBinary<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where T: CommonBounds + FloatOutBinary<U>, U: CommonBounds, <T as FloatOutBinary<U>>::Output: CommonBounds, T::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

where T: CommonBounds + FloatOutBinary<U>, U: CommonBounds, <T as FloatOutBinary<U>>::Output: CommonBounds, T::Vec: FloatOutBinary<<U as TypeCommon>::Vec, Output = <<T as FloatOutBinary<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<bf16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<bf16>, <T as FloatOutBinary<bf16>>::Output: CommonBounds, T::Vec: FloatOutBinary<<bf16 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<bf16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<bf16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<bf16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<bf16>, <T as FloatOutBinary<bf16>>::Output: CommonBounds, T::Vec: FloatOutBinary<<bf16 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<bf16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<bf16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<bool> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<bool>, <T as FloatOutBinary<bool>>::Output: CommonBounds, T::Vec: FloatOutBinary<<bool as TypeCommon>::Vec, Output = <<T as FloatOutBinary<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<bool> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<bool>, <T as FloatOutBinary<bool>>::Output: CommonBounds, T::Vec: FloatOutBinary<<bool as TypeCommon>::Vec, Output = <<T as FloatOutBinary<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<f16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<f16>, <T as FloatOutBinary<f16>>::Output: CommonBounds, T::Vec: FloatOutBinary<<f16 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<f16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<f16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<f16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<f16>, <T as FloatOutBinary<f16>>::Output: CommonBounds, T::Vec: FloatOutBinary<<f16 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<f16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<f16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<f32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<f32>, <T as FloatOutBinary<f32>>::Output: CommonBounds, T::Vec: FloatOutBinary<<f32 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<f32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<f32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<f32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<f32>, <T as FloatOutBinary<f32>>::Output: CommonBounds, T::Vec: FloatOutBinary<<f32 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<f32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<f32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<f64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<f64>, <T as FloatOutBinary<f64>>::Output: CommonBounds, T::Vec: FloatOutBinary<<f64 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<f64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<f64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<f64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<f64>, <T as FloatOutBinary<f64>>::Output: CommonBounds, T::Vec: FloatOutBinary<<f64 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<f64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<f64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<i16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<i16>, <T as FloatOutBinary<i16>>::Output: CommonBounds, T::Vec: FloatOutBinary<<i16 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<i16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<i16>, <T as FloatOutBinary<i16>>::Output: CommonBounds, T::Vec: FloatOutBinary<<i16 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<i32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<i32>, <T as FloatOutBinary<i32>>::Output: CommonBounds, T::Vec: FloatOutBinary<<i32 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<i32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<i32>, <T as FloatOutBinary<i32>>::Output: CommonBounds, T::Vec: FloatOutBinary<<i32 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<i64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<i64>, <T as FloatOutBinary<i64>>::Output: CommonBounds, T::Vec: FloatOutBinary<<i64 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<i64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<i64>, <T as FloatOutBinary<i64>>::Output: CommonBounds, T::Vec: FloatOutBinary<<i64 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<i8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<i8>, <T as FloatOutBinary<i8>>::Output: CommonBounds, T::Vec: FloatOutBinary<<i8 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<i8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<i8>, <T as FloatOutBinary<i8>>::Output: CommonBounds, T::Vec: FloatOutBinary<<i8 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<u16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<u16>, <T as FloatOutBinary<u16>>::Output: CommonBounds, T::Vec: FloatOutBinary<<u16 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<u16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<u16>, <T as FloatOutBinary<u16>>::Output: CommonBounds, T::Vec: FloatOutBinary<<u16 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<u32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<u32>, <T as FloatOutBinary<u32>>::Output: CommonBounds, T::Vec: FloatOutBinary<<u32 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<u32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<u32>, <T as FloatOutBinary<u32>>::Output: CommonBounds, T::Vec: FloatOutBinary<<u32 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<u64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<u64>, <T as FloatOutBinary<u64>>::Output: CommonBounds, T::Vec: FloatOutBinary<<u64 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<u64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<u64>, <T as FloatOutBinary<u64>>::Output: CommonBounds, T::Vec: FloatOutBinary<<u64 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<u8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<u8>, <T as FloatOutBinary<u8>>::Output: CommonBounds, T::Vec: FloatOutBinary<<u8 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, A> Div<u8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + FloatOutBinary<u8>, <T as FloatOutBinary<u8>>::Output: CommonBounds, T::Vec: FloatOutBinary<<u8 as TypeCommon>::Vec, Output = <<T as FloatOutBinary<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const DEVICE: usize, Al> EvalReduce for Tensor<T, Cpu, DEVICE, Al>

where Al: Allocator + Send + Sync + 'static, Al::Output: AllocatorOutputRetrive, T: CommonBounds, _Tensor<T, Cpu, DEVICE, Al>: EvalReduce<BoolOutput = _Tensor<bool, Cpu, DEVICE, Al>>,

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

The boolean tensor type.

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

Test if all elements are true along the specified dimensions

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

Test if any elements are true along the specified dimensions

impl FFTOps for Tensor<Complex32>

fn fft( &self, n: usize, axis: i64, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the Fast Fourier Transform (FFT) of the tensor along a specified axis.

fn ifft( &self, n: usize, axis: i64, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the inverse Fast Fourier Transform (IFFT) of the tensor along a specified axis.

fn fft2<S: Into<Shape>>( &self, s: S, axis1: i64, axis2: i64, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the 2D Fast Fourier Transform (FFT2) of the tensor.

fn ifft2<S: Into<Shape>>( &self, s: S, axis1: i64, axis2: i64, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the 2D inverse Fast Fourier Transform (IFFT2) of the tensor.

fn fftn<A: Into<Axis>, S: Into<Shape>>( &self, s: S, axes: A, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the N-dimensional Fast Fourier Transform (FFTN) of the tensor.

fn ifftn<A: Into<Axis>, S: Into<Shape>>( &self, s: S, axes: A, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the N-dimensional inverse Fast Fourier Transform (IFFTN) of the tensor.

impl FFTOps for Tensor<Complex64>

fn fft( &self, n: usize, axis: i64, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the Fast Fourier Transform (FFT) of the tensor along a specified axis.

fn ifft( &self, n: usize, axis: i64, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the inverse Fast Fourier Transform (IFFT) of the tensor along a specified axis.

fn fft2<S: Into<Shape>>( &self, s: S, axis1: i64, axis2: i64, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the 2D Fast Fourier Transform (FFT2) of the tensor.

fn ifft2<S: Into<Shape>>( &self, s: S, axis1: i64, axis2: i64, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the 2D inverse Fast Fourier Transform (IFFT2) of the tensor.

fn fftn<A: Into<Axis>, S: Into<Shape>>( &self, s: S, axes: A, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the N-dimensional Fast Fourier Transform (FFTN) of the tensor.

fn ifftn<A: Into<Axis>, S: Into<Shape>>( &self, s: S, axes: A, norm: Option<&str>, ) -> Result<Self, TensorError>

Computes the N-dimensional inverse Fast Fourier Transform (IFFTN) of the tensor.

impl<T, B, const DEVICE: usize, Al> FloatBinOps<Tensor<B, Cpu, DEVICE, Al>> for Tensor<T, Cpu, DEVICE, Al>

where B: CommonBounds, T: FloatOutBinary<B> + CommonBounds, <T as FloatOutBinary<B>>::Output: CommonBounds, T::Vec: FloatOutBinary<B::Vec, Output = <<T as FloatOutBinary<B>>::Output as TypeCommon>::Vec>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary<B>>::Output, Cpu, DEVICE, Al>

The output tensor type.

type OutputMeta = <T as FloatOutBinary<B>>::Output

The output tensor data type.

type InplaceOutput = Tensor<<T as FloatOutBinary<B>>::Output, Cpu, DEVICE, Al>

The inplace output tensor type.

fn hypot<C>(&self, rhs: C) -> Result<Self::Output, TensorError>

where C: Into<Tensor<B, Cpu, DEVICE, Al>>,

Compute sqrt(x^2 + y^2) for all elements

fn hypot_<C, U>(&self, rhs: C, out: U) -> Result<Self::Output, TensorError>

where C: Into<Tensor<B, Cpu, DEVICE, Al>>, U: BorrowMut<Self::InplaceOutput>,

hypot with specified output tensor

fn div_<C, U>(&self, rhs: C, out: U) -> Result<Self::Output, TensorError>

where C: Into<Tensor<B, Cpu, DEVICE, Al>>, U: BorrowMut<Self::InplaceOutput>,

division with specified output tensor

fn pow<C>(&self, rhs: C) -> Result<Self::Output, TensorError>

where C: Into<Tensor<B, Cpu, DEVICE, Al>>,

Power of self and rhs

fn pow_<C, U>(&self, rhs: C, out: U) -> Result<Self::Output, TensorError>

where C: Into<Tensor<B, Cpu, DEVICE, Al>>, U: BorrowMut<Self::InplaceOutput>,

Power of self and rhs with specified output tensor

impl<T, const DEVICE: usize, A> FloatOutPooling for Tensor<T, Cpu, DEVICE, A>

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

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

the output type is the same as the input type

fn avgpool2d<S: Into<Shape>>( &self, kernels_shape: S, steps: [i64; 2], padding: [(i64, i64); 2], dilation: [i64; 2], ) -> Result<Self::Output, TensorError>

Performs a 2D average pooling operation on the input tensor, computing the average value from each window.

fn adaptive_avgpool2d( &self, output_size: [i64; 2], ) -> Result<Self::Output, TensorError>

Performs an adaptive avg pooling operation on the input tensor, automatically determining the kernel size and stride to produce the specified output dimensions.

impl<T, const DEVICE: usize, Al> FloatReduce<T> for Tensor<T, Cpu, DEVICE, Al>

where T: CommonBounds, _Tensor<T, Cpu, DEVICE, Al>: FloatReduce<T, Output = _Tensor<<T as FloatOutBinary>::Output, Cpu, DEVICE, Al>>, Al: Allocator + Send + Sync + 'static, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutBinary>::Output, Cpu, DEVICE, Al>

The output tensor type.

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

Compute the mean of elements along the specified dimensions

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

Compute the L2 norm (Euclidean norm) along the specified dimensions

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

Compute the L3 norm (Euclidean norm) along the specified dimensions

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

Compute log(sum(exp(x_i))) along the specified dimensions.

impl<T, const DEVICE: usize, Al> FloatUnaryOps for Tensor<T, Cpu, DEVICE, Al>

where T: CommonBounds, <T as FloatOutUnary>::Output: CommonBounds, f64: Cast<<T as FloatOutUnary>::Output>, T::Vec: FloatOutUnary<Output = <<T as FloatOutUnary>::Output as TypeCommon>::Vec>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as FloatOutUnary>::Output, Cpu, DEVICE, Al>

output tensor type

type InplaceOutput = Tensor<<T as FloatOutUnary>::Output, Cpu, DEVICE, Al>

output tensor type for inplace operation

type OutputMeta = <T as FloatOutUnary>::Output

output tensor data type

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

Computes sine element-wise.

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

Computes cosine element-wise.

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

Computes tangent element-wise.

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

Computes arcsine element-wise.

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

Computes arccosine element-wise.

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

Computes arctangent element-wise.

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

Computes hyperbolic sine element-wise.

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

Computes hyperbolic cosine element-wise.

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

Computes hyperbolic tangent element-wise.

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

Computes the element-wise asinh of the tensor.

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

Computes the element-wise acosh of the tensor.

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

Computes the element-wise atanh of the tensor.

fn sin_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

sin method with output tensor, this method will write the result to the output tensor

fn cos_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

cos method with output tensor, this method will write the result to the output tensor

fn tan_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

tan method with output tensor, this method will write the result to the output tensor

fn asin_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

asin method with output tensor, this method will write the result to the output tensor

fn acos_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

acos method with output tensor, this method will write the result to the output tensor

fn atan_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

atan method with output tensor, this method will write the result to the output tensor

fn sinh_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

sinh method with output tensor, this method will write the result to the output tensor

fn cosh_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

cosh method with output tensor, this method will write the result to the output tensor

fn tanh_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

tanh method with output tensor, this method will write the result to the output tensor

fn asinh_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

asinh method with output tensor, this method will write the result to the output tensor

fn acosh_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

acosh method with output tensor, this method will write the result to the output tensor

fn atanh_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

atanh method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise exponential of the tensor.

fn exp_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

exp method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise base-2 exponential of the tensor.

fn exp2_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

exp2 method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise square root of the tensor.

fn sqrt_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

sqrt method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise reciprocal of the tensor.

fn recip_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

recip method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise natural logarithm of the tensor.

fn ln_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

ln method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise base-2 logarithm of the tensor.

fn log2_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

log2 method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise base-10 logarithm of the tensor.

fn log10_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

log10 method with output tensor, this method will write the result to the output tensor

fn celu<V: Cast<Self::OutputMeta>>( &self, alpha: V, ) -> Result<Self::Output, TensorError>

Computes the element-wise Continuously Differentiable Exponential Linear Unit (CELU) activation function.

fn celu_<V, U>(&self, alpha: V, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>, V: Cast<Self::OutputMeta>,

celu method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise sigmoid activation function of the tensor.

fn sigmoid_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

sigmoid method with output tensor, this method will write the result to the output tensor

fn elu<V: Cast<Self::OutputMeta>>( &self, alpha: V, ) -> Result<Self::Output, TensorError>

Computes the element-wise Exponential Linear Unit (ELU) activation function.

fn elu_<V, U>(&self, alpha: V, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>, V: Cast<Self::OutputMeta>,

elu method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise error function (erf) of the tensor.

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

Computes the element-wise Gaussian Error Linear Unit (GELU) activation function.

fn gelu_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

gelu method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise Scaled Exponential Linear Unit (SELU) activation function.

fn selu_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

selu method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise Hard Sigmoid activation function.

fn hard_sigmoid_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

hard_sigmoid method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise Hard Swish activation function.

fn hard_swish_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

hard_swish method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise Softplus activation function.

fn softplus_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

Softplus method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise Softsign activation function.

fn softsign_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

softsign method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise Mish activation function.

fn mish_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

mish method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise cube root of the tensor.

fn cbrt_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

cbrt method with output tensor, this method will write the result to the output tensor

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

Computes sine and cosine element-wise.

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

Computes the element-wise base-10 exponential of the tensor.

fn exp10_<U>(&self, out: U) -> Result<Self::InplaceOutput, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

exp10 method with output tensor, this method will write the result to the output tensor

fn sincos_<U, O>( &self, outs: (U, O), ) -> Result<(Self::Output, Self::Output), TensorError>

where U: BorrowMut<Self::InplaceOutput>, O: BorrowMut<Self::InplaceOutput>,

sincos method with output tensor, this method will write the result to the output tensor

fn erf_<U>(&self, out: U) -> Result<Self::InplaceOutput, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

erf method with output tensor, this method will write the result to the output tensor

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[Complex<f32>; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[Complex32; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize> From<&[[[[[[[[Complex<f64>; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE>

fn from(data: &[[[[[[[[Complex64; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[bool; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[bool; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[f16; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[f16; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[f32; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[f32; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[f64; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[f64; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[i16; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[i16; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[i32; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[i32; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[i64; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[i64; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[i8; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[i8; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[u16; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[u16; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[u32; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[u32; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[u64; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[u64; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<&[[[[[[[[u8; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[[u8; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[Complex<f32>; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[Complex32; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize> From<&[[[[[[[Complex<f64>; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE>

fn from(data: &[[[[[[[Complex64; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[bool; S]; R]; Q]; P]; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[bool; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[f16; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[f16; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[f32; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[f32; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[f64; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[f64; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[i16; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[i16; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[i32; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[i32; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[i64; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[i64; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[i8; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[i8; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[u16; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[u16; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[u32; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[u32; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[u64; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[u64; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<&[[[[[[[u8; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[[u8; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[Complex<f32>; R]; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[Complex32; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize> From<&[[[[[[Complex<f64>; R]; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE>

fn from(data: &[[[[[[Complex64; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[bool; R]; Q]; P]; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[bool; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[f16; R]; Q]; P]; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[f16; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[f32; R]; Q]; P]; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[f32; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[f64; R]; Q]; P]; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[f64; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[i16; R]; Q]; P]; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[i16; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[i32; R]; Q]; P]; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[i32; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[i64; R]; Q]; P]; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[i64; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[i8; R]; Q]; P]; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[i8; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[u16; R]; Q]; P]; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[u16; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[u32; R]; Q]; P]; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[u32; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[u64; R]; Q]; P]; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[u64; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<&[[[[[[u8; R]; Q]; P]; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[[u8; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[Complex<f32>; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[Complex32; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize> From<&[[[[[Complex<f64>; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE>

fn from(data: &[[[[[Complex64; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[bool; Q]; P]; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[bool; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[f16; Q]; P]; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[f16; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[f32; Q]; P]; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[f32; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[f64; Q]; P]; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[f64; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[i16; Q]; P]; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[i16; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[i32; Q]; P]; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[i32; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[i64; Q]; P]; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[i64; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[i8; Q]; P]; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[i8; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[u16; Q]; P]; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[u16; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[u32; Q]; P]; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[u32; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[u64; Q]; P]; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[u64; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<&[[[[[u8; Q]; P]; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[[u8; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[Complex<f32>; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[Complex32; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize> From<&[[[[Complex<f64>; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE>

fn from(data: &[[[[Complex64; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[bool; P]; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[bool; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[f16; P]; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[f16; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[f32; P]; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[f32; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[f64; P]; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[f64; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[i16; P]; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[i16; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[i32; P]; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[i32; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[i64; P]; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[i64; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[i8; P]; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[i8; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[u16; P]; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[u16; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[u32; P]; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[u32; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[u64; P]; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[u64; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<&[[[[u8; P]; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[[u8; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[Complex<f32>; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[Complex32; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize> From<&[[[Complex<f64>; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE>

fn from(data: &[[[Complex64; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[bool; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[bool; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[f16; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[f16; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[f32; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[f32; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[f64; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[f64; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[i16; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[i16; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[i32; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[i32; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[i64; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[i64; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[i8; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[i8; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[u16; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[u16; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[u32; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[u32; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[u64; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[u64; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<&[[[u8; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[[u8; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[Complex<f32>; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[Complex32; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize> From<&[[Complex<f64>; M]; N]> for Tensor<Complex64, Cpu, DEVICE>

fn from(data: &[[Complex64; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[bool; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[bool; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[f16; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[f16; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[f32; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[f32; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[f64; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[f64; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[i16; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[i16; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[i32; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[i32; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[i64; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[i64; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[i8; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[i8; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[u16; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[u16; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[u32; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[u32; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[u64; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[u64; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<&[[u8; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[[u8; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[Complex<f32>; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[Complex32; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize> From<&[Complex<f64>; N]> for Tensor<Complex64, Cpu, DEVICE>

fn from(data: &[Complex64; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[bool; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[bool; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[f16; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[f16; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[f32; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[f32; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[f64; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[f64; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[i16; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[i16; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[i32; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[i32; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[i64; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[i64; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[i8; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[i8; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[u16; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[u16; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[u32; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[u32; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[u64; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[u64; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<&[u8; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: &[u8; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[Complex<f32>; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[Complex32; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[Complex<f64>; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[Complex64; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[bool; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[bool; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[f16; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[f16; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[f32; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[f32; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[f32; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[f32; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[f64; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[f64; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[f64; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[f64; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[i16; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[i16; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[i32; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[i32; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[i64; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[i64; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[i8; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[i8; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[u16; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[u16; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[u32; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[u32; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[u64; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[u64; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const T: usize, const DEVICE: usize, A> From<[[[[[[[[u8; T]; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[[u8; T]; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[Complex<f32>; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[Complex32; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[Complex<f64>; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[Complex64; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[bool; S]; R]; Q]; P]; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[bool; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[f16; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[f16; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[f32; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[f32; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[f32; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[f32; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[f64; S]; R]; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[f64; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[f64; S]; R]; Q]; P]; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[f64; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[i16; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[i16; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[i32; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[i32; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[i64; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[i64; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[i8; S]; R]; Q]; P]; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[i8; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[u16; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[u16; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[u32; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[u32; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[u64; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[u64; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const S: usize, const DEVICE: usize, A> From<[[[[[[[u8; S]; R]; Q]; P]; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[[u8; S]; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[Complex<f32>; R]; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[Complex32; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[Complex<f64>; R]; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[Complex64; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[bool; R]; Q]; P]; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[bool; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[f16; R]; Q]; P]; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[f16; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[f32; R]; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[f32; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[f32; R]; Q]; P]; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[f32; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[f64; R]; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[f64; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[f64; R]; Q]; P]; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[f64; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[i16; R]; Q]; P]; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[i16; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[i32; R]; Q]; P]; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[i32; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[i64; R]; Q]; P]; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[i64; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[i8; R]; Q]; P]; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[i8; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[u16; R]; Q]; P]; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[u16; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[u32; R]; Q]; P]; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[u32; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[u64; R]; Q]; P]; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[u64; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const R: usize, const DEVICE: usize, A> From<[[[[[[u8; R]; Q]; P]; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[[u8; R]; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[Complex<f32>; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[Complex32; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[Complex<f64>; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[Complex64; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[bool; Q]; P]; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[bool; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[f16; Q]; P]; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[f16; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[f32; Q]; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[f32; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[f32; Q]; P]; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[f32; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[f64; Q]; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[f64; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[f64; Q]; P]; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[f64; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[i16; Q]; P]; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[i16; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[i32; Q]; P]; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[i32; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[i64; Q]; P]; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[i64; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[i8; Q]; P]; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[i8; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[u16; Q]; P]; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[u16; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[u32; Q]; P]; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[u32; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[u64; Q]; P]; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[u64; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const Q: usize, const DEVICE: usize, A> From<[[[[[u8; Q]; P]; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[[u8; Q]; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[Complex<f32>; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[Complex32; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[Complex<f64>; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[Complex64; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[bool; P]; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[bool; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[f16; P]; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[f16; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[f32; P]; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[f32; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[f32; P]; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[f32; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[f64; P]; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[f64; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[f64; P]; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[f64; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[i16; P]; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[i16; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[i32; P]; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[i32; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[i64; P]; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[i64; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[i8; P]; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[i8; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[u16; P]; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[u16; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[u32; P]; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[u32; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[u64; P]; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[u64; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const P: usize, const DEVICE: usize, A> From<[[[[u8; P]; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[[u8; P]; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[Complex<f32>; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[Complex32; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[Complex<f64>; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[Complex64; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[bool; O]; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[bool; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[f16; O]; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[f16; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[f32; O]; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[f32; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[f32; O]; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[f32; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[f64; O]; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[f64; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[f64; O]; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[f64; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[i16; O]; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[i16; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[i32; O]; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[i32; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[i64; O]; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[i64; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[i8; O]; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[i8; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[u16; O]; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[u16; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[u32; O]; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[u32; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[u64; O]; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[u64; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const O: usize, const DEVICE: usize, A> From<[[[u8; O]; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[[u8; O]; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[Complex<f32>; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[Complex32; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[Complex<f64>; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[Complex64; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[bool; M]; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[bool; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[f16; M]; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[f16; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[f32; M]; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[f32; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[f32; M]; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[f32; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[f64; M]; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[f64; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[f64; M]; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[f64; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[i16; M]; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[i16; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[i32; M]; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[i32; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[i64; M]; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[i64; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[i8; M]; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[i8; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[u16; M]; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[u16; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[u32; M]; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[u32; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[u64; M]; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[u64; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const M: usize, const DEVICE: usize, A> From<[[u8; M]; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [[u8; M]; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[Complex<f32>; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [Complex32; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[Complex<f64>; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [Complex64; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[bool; N]> for Tensor<bool, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [bool; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[f16; N]> for Tensor<f16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [f16; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[f32; N]> for Tensor<Complex32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [f32; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[f32; N]> for Tensor<f32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [f32; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[f64; N]> for Tensor<Complex64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [f64; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[f64; N]> for Tensor<f64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [f64; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[i16; N]> for Tensor<i16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [i16; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[i32; N]> for Tensor<i32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [i32; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[i64; N]> for Tensor<i64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [i64; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[i8; N]> for Tensor<i8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [i8; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[u16; N]> for Tensor<u16, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [u16; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[u32; N]> for Tensor<u32, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [u32; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[u64; N]> for Tensor<u64, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [u64; N]) -> Self

Converts to this type from the input type.

impl<const N: usize, const DEVICE: usize, A> From<[u8; N]> for Tensor<u8, Cpu, DEVICE, A>

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn from(data: [u8; N]) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<Complex<f32>>> for Tensor<Complex32, Cpu, DEVICE>

fn from(data: Vec<Complex32>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<Complex<f64>>> for Tensor<Complex64, Cpu, DEVICE>

fn from(data: Vec<Complex64>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<bool>> for Tensor<bool, Cpu, DEVICE>

fn from(data: Vec<bool>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<f16>> for Tensor<f16, Cpu, DEVICE>

fn from(data: Vec<f16>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<f32>> for Tensor<f32, Cpu, DEVICE>

fn from(data: Vec<f32>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<f64>> for Tensor<f64, Cpu, DEVICE>

fn from(data: Vec<f64>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<i16>> for Tensor<i16, Cpu, DEVICE>

fn from(data: Vec<i16>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<i32>> for Tensor<i32, Cpu, DEVICE>

fn from(data: Vec<i32>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<i64>> for Tensor<i64, Cpu, DEVICE>

fn from(data: Vec<i64>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<i8>> for Tensor<i8, Cpu, DEVICE>

fn from(data: Vec<i8>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<u16>> for Tensor<u16, Cpu, DEVICE>

fn from(data: Vec<u16>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<u32>> for Tensor<u32, Cpu, DEVICE>

fn from(data: Vec<u32>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<u64>> for Tensor<u64, Cpu, DEVICE>

fn from(data: Vec<u64>) -> Self

Converts to this type from the input type.

impl<const DEVICE: usize> From<Vec<u8>> for Tensor<u8, Cpu, DEVICE>

fn from(data: Vec<u8>) -> Self

Converts to this type from the input type.

impl<T: CommonBounds, const DEVICE: usize> FromSafeTensors for Tensor<T, Cpu, DEVICE>

fn from_safe_tensors(data: &SafeTensors<'_>, tensor_name: &str) -> Self

impl<A, B, A2, const DEVICE: usize> Gemm<&Tensor<B, Cpu, DEVICE, A2>> for Tensor<A, Cpu, DEVICE, A2>

where A: CommonBounds + NormalOut<B> + Cast<<A as NormalOut<B>>::Output>, B: CommonBounds + Cast<<A as NormalOut<B>>::Output>, <A as NormalOut<B>>::Output: CommonBounds, A2: Allocator, A2::Output: AllocatorOutputRetrive,

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

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, A2>

The inplace output tensor type.

fn gemm( &self, rhs: &Tensor<B, Cpu, DEVICE, A2>, alpha: Self::OutputMeta, beta: Self::OutputMeta, conj_dst: bool, conj_lhs: bool, conj_rhs: bool, ) -> Result<Self::Output, TensorError>

Perform gemm (general matrix multiplication) of two tensors. The behavior depends on the dimensions of the input tensors:

fn gemm_<U>( &self, rhs: &Tensor<B, Cpu, DEVICE, A2>, alpha: Self::OutputMeta, beta: Self::OutputMeta, conj_dst: bool, conj_lhs: bool, conj_rhs: bool, out: U, ) -> Result<Self::Output, TensorError>

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

gemm (general matrix multiplication) with specified output tensor

impl<A, B, A2, const DEVICE: usize> Gemm<Tensor<B, Cpu, DEVICE, A2>> for Tensor<A, Cpu, DEVICE, A2>

where A: CommonBounds + NormalOut<B> + Cast<<A as NormalOut<B>>::Output>, B: CommonBounds + Cast<<A as NormalOut<B>>::Output>, <A as NormalOut<B>>::Output: CommonBounds, A2: Allocator, A2::Output: AllocatorOutputRetrive,

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

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, A2>

The inplace output tensor type.

fn gemm( &self, rhs: Tensor<B, Cpu, DEVICE, A2>, alpha: Self::OutputMeta, beta: Self::OutputMeta, conj_dst: bool, conj_lhs: bool, conj_rhs: bool, ) -> Result<Self::Output, TensorError>

Perform gemm (general matrix multiplication) of two tensors. The behavior depends on the dimensions of the input tensors:

fn gemm_<U>( &self, rhs: Tensor<B, Cpu, DEVICE, A2>, alpha: Self::OutputMeta, beta: Self::OutputMeta, conj_dst: bool, conj_lhs: bool, conj_rhs: bool, out: U, ) -> Result<Self::Output, TensorError>

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

gemm (general matrix multiplication) with specified output tensor

impl<T, const DEVICE: usize, Al> HardMax<T> for Tensor<T, Cpu, DEVICE, Al>

where T: CommonBounds + Cmp<Output = bool>, <T as TypeCommon>::Vec: SimdCmp, <T::Vec as SimdCmp>::Output: IntoVec<T::Vec>, bool: NormalOut<T> + Cast<T>, Al: Allocator + Send + Sync + 'static, Al::Output: AllocatorOutputRetrive,

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

The type of the output tensor

fn hardmax(&self, axis: i64) -> Result<Self::Output, TensorError>

Applies the hardmax function to the input tensor along the specified dimension.

impl<T: CommonBounds + NormalOut<Output = T> + Cmp<T, Output = bool>, const DEVICE: usize> IndexReduce for Tensor<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>

Return the indices of the maximum values along the specified dimensions

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

Return the indices of the minimum values along the specified dimensions

impl<const DEVICE: usize, A> Into<Tensor<Complex<f32>, Cpu, DEVICE, A>> for Complex32

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<Complex32, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<Complex<f64>, Cpu, DEVICE, A>> for Complex64

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<Complex64, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<T, const DEVICE: usize, A> Into<Tensor<T, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds, A: Allocator,

fn into(self) -> Tensor<T, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<bf16, Cpu, DEVICE, A>> for bf16

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<bf16, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<bool, Cpu, DEVICE, A>> for bool

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<bool, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<f16, Cpu, DEVICE, A>> for f16

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<f16, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<f32, Cpu, DEVICE, A>> for f32

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<f32, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<f64, Cpu, DEVICE, A>> for f64

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<f64, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<i16, Cpu, DEVICE, A>> for i16

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<i16, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<i32, Cpu, DEVICE, A>> for i32

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<i32, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<i64, Cpu, DEVICE, A>> for i64

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<i64, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<i8, Cpu, DEVICE, A>> for i8

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<i8, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<u16, Cpu, DEVICE, A>> for u16

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<u16, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<u32, Cpu, DEVICE, A>> for u32

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<u32, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<u64, Cpu, DEVICE, A>> for u64

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<u64, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<const DEVICE: usize, A> Into<Tensor<u8, Cpu, DEVICE, A>> for u8

where A: Allocator, A::Output: AllocatorOutputRetrive,

fn into(self) -> Tensor<u8, Cpu, DEVICE, A>

Converts this type into the (usually inferred) input type.

impl<T, const DEVICE: usize, Al> Matmul<&Tensor<T, Cpu, DEVICE, Al>> for Tensor<T, Cpu, DEVICE, Al>

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

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

The output tensor type.

type OutputMeta = T

The output tensor data type.

type InplaceOutput = Tensor<T, Cpu, DEVICE, Al>

The inplace output tensor type.

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

Perform matrix multiplication of two tensors. The behavior depends on the dimensions of the input tensors:

fn matmul_<U>( &self, rhs: &Tensor<T, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

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

matrix multiplication with specified output tensor

impl<T, const DEVICE: usize, Al> Matmul for Tensor<T, Cpu, DEVICE, Al>

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

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

The output tensor type.

type OutputMeta = T

The output tensor data type.

type InplaceOutput = Tensor<T, Cpu, DEVICE, Al>

The inplace output tensor type.

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

Perform matrix multiplication of two tensors. The behavior depends on the dimensions of the input tensors:

fn matmul_<U>( &self, rhs: Tensor<T, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

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

matrix multiplication with specified output tensor

impl<T, A, const DEVICE: usize> MatmulPost<&Tensor<T, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + MatmulMicroKernel, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<T, Cpu, DEVICE, A>

The output tensor type.

type OutputMeta = T

The output tensor data type.

type InplaceOutput = Tensor<T, Cpu, DEVICE, A>

The inplace output tensor type.

fn matmul_post( &self, rhs: &Tensor<T, Cpu, DEVICE, A>, post_op: fn(T) -> T, post_op_vec: fn(T::Vec) -> T::Vec, ) -> Result<Self::Output, TensorError>

Same as matmul but will perform post operation before writing final result to the memory.

fn matmul_post_<U>( &self, rhs: &Tensor<T, Cpu, DEVICE, A>, post_op: fn(T) -> T, post_op_vec: fn(T::Vec) -> T::Vec, out: U, ) -> Result<Self::InplaceOutput, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

matrix multiplication with specified output tensor and post operation

impl<T, A, const DEVICE: usize> MatmulPost for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + MatmulMicroKernel, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<T, Cpu, DEVICE, A>

The output tensor type.

type OutputMeta = T

The output tensor data type.

type InplaceOutput = Tensor<T, Cpu, DEVICE, A>

The inplace output tensor type.

fn matmul_post( &self, rhs: Tensor<T, Cpu, DEVICE, A>, post_op: fn(T) -> T, post_op_vec: fn(T::Vec) -> T::Vec, ) -> Result<Self::Output, TensorError>

Same as matmul but will perform post operation before writing final result to the memory.

fn matmul_post_<U>( &self, rhs: Tensor<T, Cpu, DEVICE, A>, post_op: fn(T) -> T, post_op_vec: fn(T::Vec) -> T::Vec, out: U, ) -> Result<Self::InplaceOutput, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

matrix multiplication with specified output tensor and post operation

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for Complex32

where T: CommonBounds, Complex32: NormalOut<T>, <Complex32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <Complex32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f32> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for Complex64

where T: CommonBounds, Complex64: NormalOut<T>, <Complex64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <Complex64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f64> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for bf16

where T: CommonBounds, bf16: NormalOut<T>, <bf16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <bf16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bf16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bf16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: NormalOut<T>, <bool as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <bool as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bool as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for f16

where T: CommonBounds, f16: NormalOut<T>, <f16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for f32

where T: CommonBounds, f32: NormalOut<T>, <f32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for f64

where T: CommonBounds, f64: NormalOut<T>, <f64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: NormalOut<T>, <i16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: NormalOut<T>, <i32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: NormalOut<T>, <i64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: NormalOut<T>, <i8 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: NormalOut<T>, <u16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: NormalOut<T>, <u32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: NormalOut<T>, <u64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<&Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: NormalOut<T>, <u8 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Complex<f32>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex32>, <T as NormalOut<Complex32>>::Output: CommonBounds, T::Vec: NormalOut<<Complex32 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f32>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Complex<f32>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex32>, <T as NormalOut<Complex32>>::Output: CommonBounds, T::Vec: NormalOut<<Complex32 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f32>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Complex<f64>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex64>, <T as NormalOut<Complex64>>::Output: CommonBounds, T::Vec: NormalOut<<Complex64 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f64>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Complex<f64>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex64>, <T as NormalOut<Complex64>>::Output: CommonBounds, T::Vec: NormalOut<<Complex64 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f64>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for Complex32

where T: CommonBounds, Complex32: NormalOut<T>, <Complex32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <Complex32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f32> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for Complex64

where T: CommonBounds, Complex64: NormalOut<T>, <Complex64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <Complex64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f64> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for bf16

where T: CommonBounds, bf16: NormalOut<T>, <bf16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <bf16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bf16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bf16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: NormalOut<T>, <bool as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <bool as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bool as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for f16

where T: CommonBounds, f16: NormalOut<T>, <f16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for f32

where T: CommonBounds, f32: NormalOut<T>, <f32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for f64

where T: CommonBounds, f64: NormalOut<T>, <f64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: NormalOut<T>, <i16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: NormalOut<T>, <i32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: NormalOut<T>, <i64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: NormalOut<T>, <i8 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: NormalOut<T>, <u16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: NormalOut<T>, <u32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: NormalOut<T>, <u64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: NormalOut<T>, <u8 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<bf16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bf16>, <T as NormalOut<bf16>>::Output: CommonBounds, T::Vec: NormalOut<<bf16 as TypeCommon>::Vec, Output = <<T as NormalOut<bf16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bf16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<bf16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bf16>, <T as NormalOut<bf16>>::Output: CommonBounds, T::Vec: NormalOut<<bf16 as TypeCommon>::Vec, Output = <<T as NormalOut<bf16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bf16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<bool> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bool>, <T as NormalOut<bool>>::Output: CommonBounds, T::Vec: NormalOut<<bool as TypeCommon>::Vec, Output = <<T as NormalOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<bool> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bool>, <T as NormalOut<bool>>::Output: CommonBounds, T::Vec: NormalOut<<bool as TypeCommon>::Vec, Output = <<T as NormalOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<f16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f16>, <T as NormalOut<f16>>::Output: CommonBounds, T::Vec: NormalOut<<f16 as TypeCommon>::Vec, Output = <<T as NormalOut<f16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<f16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f16>, <T as NormalOut<f16>>::Output: CommonBounds, T::Vec: NormalOut<<f16 as TypeCommon>::Vec, Output = <<T as NormalOut<f16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<f32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f32>, <T as NormalOut<f32>>::Output: CommonBounds, T::Vec: NormalOut<<f32 as TypeCommon>::Vec, Output = <<T as NormalOut<f32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<f32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f32>, <T as NormalOut<f32>>::Output: CommonBounds, T::Vec: NormalOut<<f32 as TypeCommon>::Vec, Output = <<T as NormalOut<f32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<f64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f64>, <T as NormalOut<f64>>::Output: CommonBounds, T::Vec: NormalOut<<f64 as TypeCommon>::Vec, Output = <<T as NormalOut<f64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<f64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f64>, <T as NormalOut<f64>>::Output: CommonBounds, T::Vec: NormalOut<<f64 as TypeCommon>::Vec, Output = <<T as NormalOut<f64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<i16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i16>, <T as NormalOut<i16>>::Output: CommonBounds, T::Vec: NormalOut<<i16 as TypeCommon>::Vec, Output = <<T as NormalOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<i16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i16>, <T as NormalOut<i16>>::Output: CommonBounds, T::Vec: NormalOut<<i16 as TypeCommon>::Vec, Output = <<T as NormalOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<i32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i32>, <T as NormalOut<i32>>::Output: CommonBounds, T::Vec: NormalOut<<i32 as TypeCommon>::Vec, Output = <<T as NormalOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<i32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i32>, <T as NormalOut<i32>>::Output: CommonBounds, T::Vec: NormalOut<<i32 as TypeCommon>::Vec, Output = <<T as NormalOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<i64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i64>, <T as NormalOut<i64>>::Output: CommonBounds, T::Vec: NormalOut<<i64 as TypeCommon>::Vec, Output = <<T as NormalOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<i64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i64>, <T as NormalOut<i64>>::Output: CommonBounds, T::Vec: NormalOut<<i64 as TypeCommon>::Vec, Output = <<T as NormalOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<i8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i8>, <T as NormalOut<i8>>::Output: CommonBounds, T::Vec: NormalOut<<i8 as TypeCommon>::Vec, Output = <<T as NormalOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<i8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i8>, <T as NormalOut<i8>>::Output: CommonBounds, T::Vec: NormalOut<<i8 as TypeCommon>::Vec, Output = <<T as NormalOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<u16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u16>, <T as NormalOut<u16>>::Output: CommonBounds, T::Vec: NormalOut<<u16 as TypeCommon>::Vec, Output = <<T as NormalOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<u16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u16>, <T as NormalOut<u16>>::Output: CommonBounds, T::Vec: NormalOut<<u16 as TypeCommon>::Vec, Output = <<T as NormalOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<u32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u32>, <T as NormalOut<u32>>::Output: CommonBounds, T::Vec: NormalOut<<u32 as TypeCommon>::Vec, Output = <<T as NormalOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<u32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u32>, <T as NormalOut<u32>>::Output: CommonBounds, T::Vec: NormalOut<<u32 as TypeCommon>::Vec, Output = <<T as NormalOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<u64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u64>, <T as NormalOut<u64>>::Output: CommonBounds, T::Vec: NormalOut<<u64 as TypeCommon>::Vec, Output = <<T as NormalOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<u64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u64>, <T as NormalOut<u64>>::Output: CommonBounds, T::Vec: NormalOut<<u64 as TypeCommon>::Vec, Output = <<T as NormalOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<u8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u8>, <T as NormalOut<u8>>::Output: CommonBounds, T::Vec: NormalOut<<u8 as TypeCommon>::Vec, Output = <<T as NormalOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const DEVICE: usize, A> Mul<u8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u8>, <T as NormalOut<u8>>::Output: CommonBounds, T::Vec: NormalOut<<u8 as TypeCommon>::Vec, Output = <<T as NormalOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, U, const DEVICE: usize, A> MulAssign<&Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T>, A: Allocator, A::Output: AllocatorOutputRetrive,

fn mul_assign(&mut self, rhs: &Tensor<U, Cpu, DEVICE, A>)

Performs the *= operation.

impl<T, U, const DEVICE: usize, A> MulAssign<Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T>, A: Allocator, A::Output: AllocatorOutputRetrive,

fn mul_assign(&mut self, rhs: Tensor<U, Cpu, DEVICE, A>)

Performs the *= operation.

impl<T, const DEVICE: usize, Al> Neg for &Tensor<T, Cpu, DEVICE, Al>

where T: CommonBounds, Tensor<<T as NormalOut>::Output, Cpu, DEVICE, Al>: TensorLike<<T as NormalOut>::Output>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut>::Output, Cpu, DEVICE, Al>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, const DEVICE: usize, Al> Neg for Tensor<T, Cpu, DEVICE, Al>

where T: CommonBounds, Tensor<<T as NormalOut>::Output, Cpu, DEVICE, Al>: TensorLike<<T as NormalOut>::Output>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut>::Output, Cpu, DEVICE, Al>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A, B, const DEVICE: usize, Al> NormalBinOps<&Tensor<B, Cpu, DEVICE, Al>> for &Tensor<A, Cpu, DEVICE, Al>

where A: CommonBounds + NormalOut<B>, B: CommonBounds, <A as NormalOut<B>>::Output: CommonBounds + Cast<<A as NormalOut<B>>::Output>, A::Vec: NormalOut<B::Vec, Output = <<A as NormalOut<B>>::Output as TypeCommon>::Vec>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<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 add_<U>( &self, rhs: &Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

add with specified output tensor

fn sub_<U>( &self, rhs: &Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

subtract with specified output tensor

fn mul_<U>( &self, rhs: &Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

multiply with specified output tensor

fn rem_<U>( &self, rhs: &Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

rem with specified output tensor

impl<A, B, const DEVICE: usize, Al> NormalBinOps<&Tensor<B, Cpu, DEVICE, Al>> for Tensor<A, Cpu, DEVICE, Al>

where A: CommonBounds + NormalOut<B>, B: CommonBounds, <A as NormalOut<B>>::Output: CommonBounds + Cast<<A as NormalOut<B>>::Output>, A::Vec: NormalOut<B::Vec, Output = <<A as NormalOut<B>>::Output as TypeCommon>::Vec>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<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 add_<U>( &self, rhs: &Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

add with specified output tensor

fn sub_<U>( &self, rhs: &Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

subtract with specified output tensor

fn mul_<U>( &self, rhs: &Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

multiply with specified output tensor

fn rem_<U>( &self, rhs: &Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

rem with specified output tensor

impl<A, B, const DEVICE: usize, Al> NormalBinOps<Tensor<B, Cpu, DEVICE, Al>> for &Tensor<A, Cpu, DEVICE, Al>

where A: CommonBounds + NormalOut<B>, B: CommonBounds, <A as NormalOut<B>>::Output: CommonBounds + Cast<<A as NormalOut<B>>::Output>, A::Vec: NormalOut<B::Vec, Output = <<A as NormalOut<B>>::Output as TypeCommon>::Vec>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<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 add_<U>( &self, rhs: Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

add with specified output tensor

fn sub_<U>( &self, rhs: Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

subtract with specified output tensor

fn mul_<U>( &self, rhs: Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

multiply with specified output tensor

fn rem_<U>( &self, rhs: Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

rem with specified output tensor

impl<A, B, const DEVICE: usize, Al> NormalBinOps<Tensor<B, Cpu, DEVICE, Al>> for Tensor<A, Cpu, DEVICE, Al>

where A: CommonBounds + NormalOut<B>, B: CommonBounds, <A as NormalOut<B>>::Output: CommonBounds + Cast<<A as NormalOut<B>>::Output>, A::Vec: NormalOut<B::Vec, Output = <<A as NormalOut<B>>::Output as TypeCommon>::Vec>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<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 add_<U>( &self, rhs: Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

add with specified output tensor

fn sub_<U>( &self, rhs: Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

subtract with specified output tensor

fn mul_<U>( &self, rhs: Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

multiply with specified output tensor

fn rem_<U>( &self, rhs: Tensor<B, Cpu, DEVICE, Al>, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

rem with specified output tensor

impl<T, const DEVICE: usize, Al> NormalEvalReduce<T> for Tensor<T, Cpu, DEVICE, Al>

where T: CommonBounds + Eval<Output = bool> + Cast<bool>, T::Vec: Eval, <T::Vec as Eval>::Output: SimdSelect<T::Vec>, Al: Allocator + Send + Sync + 'static, Al::Output: AllocatorOutputRetrive,

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

the output tensor type.

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

Compute the sum of elements along the specified dimensions, treating NaNs as zero

fn nansum_<S: Into<Axis>, O>( &self, axes: S, keep_dims: bool, init_out: bool, out: O, ) -> Result<Self::Output, TensorError>

where O: BorrowMut<Self::Output>,

Compute the sum of elements along the specified dimensions, treating NaNs as zero with out with specified output tensor

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

Compute the product of elements along the specified dimensions, treating NaNs as one

impl<T, const DEVICE: usize, A> NormalPooling for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds, bool: Cast<T>, i64: Cast<T>, A: Allocator + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = Tensor<T, Cpu, DEVICE, A>

the output type is the same as the input type

fn maxpool2d<S: Into<Shape>>( &self, kernels_shape: S, steps: [i64; 2], padding: [(i64, i64); 2], dilation: [i64; 2], ) -> Result<Self::Output, TensorError>

Performs a 2D max pooling operation on the input tensor, selecting the maximum value from each window.

fn adaptive_maxpool2d( &self, output_size: [i64; 2], ) -> Result<Self::Output, TensorError>

Performs an adaptive max pooling operation on the input tensor, automatically determining the kernel size and stride to produce the specified output dimensions.

impl<T: CommonBounds, const DEVICE: usize, Al> NormalReduce<T> for Tensor<T, Cpu, DEVICE, Al>

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

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

The output tensor type.

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

Compute the sum of elements along the specified dimensions

fn sum_<S: Into<Axis>, O>( &self, axes: S, keep_dims: bool, init_out: bool, out: O, ) -> Result<Self::Output, TensorError>

where O: BorrowMut<Self::Output>,

Compute the sum of elements along the specified dimensions with specified output tensor

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

Compute the product of elements along the specified dimensions

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

Find the minimum of element along the specified dimensions

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

Find the maximum of element along the specified dimensions

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

Compute the L1 norm along the specified dimensions

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

Compute the sum of squares of elements along the specified dimensions

impl<T, const DEVICE: usize, Al> NormalUaryOps for Tensor<T, Cpu, DEVICE, Al>

where T: CommonBounds, <T as NormalOut>::Output: CommonBounds, T::Vec: NormalOutUnary, _Tensor<<T as NormalOut>::Output, Cpu, DEVICE, Al>: TensorLike<<T as NormalOut>::Output>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut>::Output, Cpu, DEVICE, Al>

The output type of the unary operation.

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

The output type of the inplace unary operation.

type OutputMeta = <T as NormalOut>::Output

The output type of the unary operation.

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

Computes the element-wise floor of the tensor.

fn floor_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

Floor method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise square of the tensor.

fn square_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

Square method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise absolute value of the tensor.

fn abs_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

abs method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise ceiling of the tensor.

fn ceil_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

Ceil method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise sign of the tensor.

fn sign_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

sign method with output tensor, this method will write the result to the output tensor

fn clamp( &self, min: Self::OutputMeta, max: Self::OutputMeta, ) -> Result<Self::Output, TensorError>

Clamps (limits) the values of the tensor between the specified min and max.

fn clamp_<U>( &self, min: Self::OutputMeta, max: Self::OutputMeta, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

clamp method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise rounding of the tensor.

fn round_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

round method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise negation (multiplying by -1) of the tensor.

fn neg_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

Inplace Version of neg.

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

Computes the element-wise Rectified Linear Unit (ReLU) activation function.

fn relu_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

relu method with output tensor, this method will write the result to the output tensor

fn leaky_relu( &self, alpha: Self::OutputMeta, ) -> Result<Self::Output, TensorError>

Computes the element-wise Leaky Rectified Linear Unit (Leaky ReLU) activation function.

fn leaky_relu_<U>( &self, alpha: Self::OutputMeta, out: U, ) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

leaky_relu method with output tensor, this method will write the result to the output tensor

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

Computes the element-wise Rectified Linear Unit 6 (ReLU6) activation function.

fn relu6_<U>(&self, out: U) -> Result<Self::Output, TensorError>

where U: BorrowMut<Self::InplaceOutput>,

relu6 method with output tensor, this method will write the result to the output tensor

impl<T, const DEVICE: usize, A> NormalizationOps for Tensor<T, Cpu, DEVICE, A>

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

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

The type of the output tensor

type OutputMeta = <T as FloatOutBinary>::Output

The type of the output meta

fn layernorm<S: Into<Shape>>( &self, normalized_shape: S, gamma: Option<&Self::Output>, beta: Option<&Self::Output>, eps: Self::OutputMeta, ) -> Result<Self::Output, TensorError>

where usize: Cast<Self::OutputMeta>,

Applies Layer Normalization over a specified axes.

fn softmax(&self, axis: i64) -> Result<Self::Output, TensorError>

Applies the softmax function to the input tensor along the specified dimension. The softmax function normalizes the input to a probability distribution, such that each element is in the range [0, 1] and all elements sum to 1.

fn log_softmax(&self, axis: i64) -> Result<Self::Output, TensorError>

Applies the log-softmax function to the input tensor along the specified dimension. The log-softmax function is equivalent to applying the logarithm to the output of the softmax function, but is more numerically stable when computed directly.

impl<T, const DEVICE: usize, Al> Not for &Tensor<T, Cpu, DEVICE, Al>

where T: BitWiseOut<T> + CommonBounds, <T as BitWiseOut>::Output: CommonBounds, T::Vec: BitWiseOut<T::Vec, Output = <<T as BitWiseOut>::Output as TypeCommon>::Vec>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut>::Output, Cpu, DEVICE, Al>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, const DEVICE: usize, Al> Not for Tensor<T, Cpu, DEVICE, Al>

where T: BitWiseOut<T> + CommonBounds, <T as BitWiseOut>::Output: CommonBounds, T::Vec: BitWiseOut<T::Vec, Output = <<T as BitWiseOut>::Output as TypeCommon>::Vec>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut>::Output, Cpu, DEVICE, Al>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, const DEVICE: usize, Al> PartialEq for Tensor<T, Cpu, DEVICE, Al>

where T: Eval<Output = bool> + Cmp<Output = bool> + CommonBounds, Al: Allocator, Al::Output: AllocatorOutputRetrive,

fn eq(&self, other: &Tensor<T, Cpu, DEVICE, Al>) -> 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<T, const DEVICE: usize, Al> Random for Tensor<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>, StandardUniform: 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>

create a Tensor with data in normal distribution. mean = 0.0, std_dev = 1.0.

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

same as randn but the shape will be based on x.

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

create a Tensor with data uniformly distributed between low and high.

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

same as rand but the shape will be based on x.

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

Create a Tensor with values drawn from a beta distribution with parameters alpha and beta. The beta distribution is a continuous probability distribution defined on the interval [0, 1].

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

Same as beta but the shape will be based on x. Creates a Tensor with values drawn from a beta distribution with parameters alpha and beta.

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

Create a Tensor with values drawn from a chi-square distribution with df degrees of freedom. The chi-square distribution is a continuous probability distribution of the sum of squares of df independent standard normal random variables.

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

Same as chisquare but the shape will be based on x. Creates a Tensor with values drawn from a chi-square distribution with df degrees of freedom.

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

Create a Tensor with values drawn from an exponential distribution with rate parameter lambda. The exponential distribution describes the time between events in a Poisson point process.

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

Same as exponential but the shape will be based on x. Creates a Tensor with values drawn from an exponential distribution with rate parameter lambda.

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

Create a Tensor with values drawn from a gamma distribution with shape parameter shape_param (often denoted as k or α) and scale parameter scale (often denoted as θ). The gamma distribution is a continuous probability distribution that generalizes the exponential distribution.

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

Same as gamma but the shape will be based on x. Creates a Tensor with values drawn from a gamma distribution with shape parameter shape_param and scale parameter scale.

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

Create a Tensor with values drawn from a Gumbel distribution (also known as the Extreme Value Type I distribution) with location parameter mu and scale parameter beta. The Gumbel distribution is commonly used to model the distribution of extreme values.

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

Same as gumbel but the shape will be based on x. Creates a Tensor with values drawn from a Gumbel distribution with location parameter mu and scale parameter beta.

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

Create a Tensor with values drawn from a log-normal distribution. A random variable is log-normally distributed if the logarithm of the random variable is normally distributed. The parameters mean and std are the mean and standard deviation of the underlying normal distribution.

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

Same as lognormal but the shape will be based on x. Creates a Tensor with values drawn from a log-normal distribution with parameters mean and std of the underlying normal distribution.

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

Create a Tensor with values drawn from a normal (Gaussian) distribution with specified mean and standard deviation. The normal distribution is a continuous probability distribution that is symmetric around its mean, showing the familiar bell-shaped curve.

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

Same as normal_gaussian but the shape will be based on x. Creates a Tensor with values drawn from a normal distribution with specified mean and standard deviation.

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

Create a Tensor with values drawn from a Pareto distribution. The Pareto distribution is a power-law probability distribution often used to describe the distribution of wealth, population sizes, and many other natural and social phenomena.

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

Same as pareto but the shape will be based on x. Creates a Tensor with values drawn from a Pareto distribution with specified scale and shape parameters.

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

Create a Tensor with values drawn from a Poisson distribution. The Poisson distribution is a discrete probability distribution that expresses the probability of a given number of events occurring in a fixed interval of time or space, assuming these events occur with a known constant mean rate (λ) and independently of the time since the last event.

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

Same as poisson but the shape will be based on x. Creates a Tensor with values drawn from a Poisson distribution with specified rate parameter.

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

Create a Tensor with values drawn from a Weibull distribution. The Weibull distribution is a continuous probability distribution commonly used in reliability engineering, survival analysis, and extreme value theory.

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

Same as weibull but the shape will be based on x. Creates a Tensor with values drawn from a Weibull distribution with specified shape and scale parameters.

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

Create a Tensor with values drawn from a Zipf distribution. The Zipf distribution is a discrete probability distribution commonly used to model frequency distributions of ranked data in various physical and social phenomena, where the frequency of any element is inversely proportional to its rank.

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

Same as zipf but the shape will be based on x. Creates a Tensor with values drawn from a Zipf distribution with specified number of elements and exponent parameter.

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

Create a Tensor with values drawn from a triangular distribution. The triangular distribution is a continuous probability distribution with a lower limit low, upper limit high, and mode mode. It forms a triangular shape in its probability density function.

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

Same as triangular but the shape will be based on x. Creates a Tensor with values drawn from a triangular distribution with specified lower limit, upper limit, and mode.

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

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

Create a Tensor with values drawn from a Bernoulli distribution. The Bernoulli distribution is a discrete probability distribution of a random variable which takes the value 1 with probability p and the value 0 with probability q = 1 - p.

impl<T, const DEVICE: usize, Al> RandomInt for Tensor<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,

Create a Tensor with random integers drawn uniformly from the half-open interval [low, high). The distribution is uniform, meaning each integer in the range has an equal probability of being drawn.

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

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

Same as randint but the shape will be based on x. Creates a Tensor with random integers drawn uniformly from the half-open interval [low, high).

impl<T, const DEVICE: usize, A> RegularizationOps for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + Cmp<Output = bool>, T::Vec: SimdCmp, <T::Vec as SimdCmp>::Output: SimdSelect<T::Vec>, A: Allocator + Send + Sync, A::Output: AllocatorOutputRetrive,

type Output = Tensor<T, Cpu, DEVICE, A>

The type of the output tensor

type OutputMeta = T

The type of the output meta

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

where f64: Cast<Self::OutputMeta>, bool: Cast<Self::OutputMeta>, Self::OutputMeta: NormalOut<bool, Output = Self::OutputMeta>,

Randomly zeroes some of the elements of the input tensor with probability rate using samples from a Bernoulli distribution. Each element is zeroed independently.

fn shrinkage( &self, bias: Self::OutputMeta, lambda: Self::OutputMeta, ) -> Result<Self::Output, TensorError>

Applies the shrinkage function to the input tensor. The shrinkage function is a soft thresholding operator commonly used in signal processing and optimization algorithms, defined as: sign(x - bias) * max(abs(x - bias) - lambda, 0)

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for Complex32

where T: CommonBounds, Complex32: NormalOut<T>, <Complex32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <Complex32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f32> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for Complex64

where T: CommonBounds, Complex64: NormalOut<T>, <Complex64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <Complex64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f64> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for bf16

where T: CommonBounds, bf16: NormalOut<T>, <bf16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <bf16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bf16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bf16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: NormalOut<T>, <bool as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <bool as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bool as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for f16

where T: CommonBounds, f16: NormalOut<T>, <f16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for f32

where T: CommonBounds, f32: NormalOut<T>, <f32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for f64

where T: CommonBounds, f64: NormalOut<T>, <f64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: NormalOut<T>, <i16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: NormalOut<T>, <i32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: NormalOut<T>, <i64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: NormalOut<T>, <i8 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: NormalOut<T>, <u16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: NormalOut<T>, <u32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: NormalOut<T>, <u64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<&Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: NormalOut<T>, <u8 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the % operator.

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

Performs the % operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Complex<f32>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex32>, <T as NormalOut<Complex32>>::Output: CommonBounds, T::Vec: NormalOut<<Complex32 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f32>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: Complex32) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Complex<f32>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex32>, <T as NormalOut<Complex32>>::Output: CommonBounds, T::Vec: NormalOut<<Complex32 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f32>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: Complex32) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Complex<f64>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex64>, <T as NormalOut<Complex64>>::Output: CommonBounds, T::Vec: NormalOut<<Complex64 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f64>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: Complex64) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Complex<f64>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex64>, <T as NormalOut<Complex64>>::Output: CommonBounds, T::Vec: NormalOut<<Complex64 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f64>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: Complex64) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for Complex32

where T: CommonBounds, Complex32: NormalOut<T>, <Complex32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <Complex32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f32> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for Complex64

where T: CommonBounds, Complex64: NormalOut<T>, <Complex64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <Complex64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f64> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for bf16

where T: CommonBounds, bf16: NormalOut<T>, <bf16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <bf16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bf16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bf16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: NormalOut<T>, <bool as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <bool as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bool as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for f16

where T: CommonBounds, f16: NormalOut<T>, <f16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for f32

where T: CommonBounds, f32: NormalOut<T>, <f32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for f64

where T: CommonBounds, f64: NormalOut<T>, <f64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <f64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: NormalOut<T>, <i16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: NormalOut<T>, <i32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: NormalOut<T>, <i64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: NormalOut<T>, <i8 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <i8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: NormalOut<T>, <u16 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: NormalOut<T>, <u32 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: NormalOut<T>, <u64 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: NormalOut<T>, <u8 as NormalOut<T>>::Output: CommonBounds + Cast<<T as NormalOut<T>>::Output>, <u8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

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

Performs the % operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the % operator.

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

Performs the % operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<bf16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bf16>, <T as NormalOut<bf16>>::Output: CommonBounds, T::Vec: NormalOut<<bf16 as TypeCommon>::Vec, Output = <<T as NormalOut<bf16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bf16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: bf16) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<bf16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bf16>, <T as NormalOut<bf16>>::Output: CommonBounds, T::Vec: NormalOut<<bf16 as TypeCommon>::Vec, Output = <<T as NormalOut<bf16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bf16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: bf16) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<bool> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bool>, <T as NormalOut<bool>>::Output: CommonBounds, T::Vec: NormalOut<<bool as TypeCommon>::Vec, Output = <<T as NormalOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: bool) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<bool> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bool>, <T as NormalOut<bool>>::Output: CommonBounds, T::Vec: NormalOut<<bool as TypeCommon>::Vec, Output = <<T as NormalOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: bool) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<f16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f16>, <T as NormalOut<f16>>::Output: CommonBounds, T::Vec: NormalOut<<f16 as TypeCommon>::Vec, Output = <<T as NormalOut<f16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: f16) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<f16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f16>, <T as NormalOut<f16>>::Output: CommonBounds, T::Vec: NormalOut<<f16 as TypeCommon>::Vec, Output = <<T as NormalOut<f16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: f16) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<f32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f32>, <T as NormalOut<f32>>::Output: CommonBounds, T::Vec: NormalOut<<f32 as TypeCommon>::Vec, Output = <<T as NormalOut<f32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<f32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f32>, <T as NormalOut<f32>>::Output: CommonBounds, T::Vec: NormalOut<<f32 as TypeCommon>::Vec, Output = <<T as NormalOut<f32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<f64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f64>, <T as NormalOut<f64>>::Output: CommonBounds, T::Vec: NormalOut<<f64 as TypeCommon>::Vec, Output = <<T as NormalOut<f64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<f64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f64>, <T as NormalOut<f64>>::Output: CommonBounds, T::Vec: NormalOut<<f64 as TypeCommon>::Vec, Output = <<T as NormalOut<f64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<i16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i16>, <T as NormalOut<i16>>::Output: CommonBounds, T::Vec: NormalOut<<i16 as TypeCommon>::Vec, Output = <<T as NormalOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<i16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i16>, <T as NormalOut<i16>>::Output: CommonBounds, T::Vec: NormalOut<<i16 as TypeCommon>::Vec, Output = <<T as NormalOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<i32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i32>, <T as NormalOut<i32>>::Output: CommonBounds, T::Vec: NormalOut<<i32 as TypeCommon>::Vec, Output = <<T as NormalOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<i32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i32>, <T as NormalOut<i32>>::Output: CommonBounds, T::Vec: NormalOut<<i32 as TypeCommon>::Vec, Output = <<T as NormalOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<i64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i64>, <T as NormalOut<i64>>::Output: CommonBounds, T::Vec: NormalOut<<i64 as TypeCommon>::Vec, Output = <<T as NormalOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<i64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i64>, <T as NormalOut<i64>>::Output: CommonBounds, T::Vec: NormalOut<<i64 as TypeCommon>::Vec, Output = <<T as NormalOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<i8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i8>, <T as NormalOut<i8>>::Output: CommonBounds, T::Vec: NormalOut<<i8 as TypeCommon>::Vec, Output = <<T as NormalOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<i8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i8>, <T as NormalOut<i8>>::Output: CommonBounds, T::Vec: NormalOut<<i8 as TypeCommon>::Vec, Output = <<T as NormalOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<u16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u16>, <T as NormalOut<u16>>::Output: CommonBounds, T::Vec: NormalOut<<u16 as TypeCommon>::Vec, Output = <<T as NormalOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<u16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u16>, <T as NormalOut<u16>>::Output: CommonBounds, T::Vec: NormalOut<<u16 as TypeCommon>::Vec, Output = <<T as NormalOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<u32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u32>, <T as NormalOut<u32>>::Output: CommonBounds, T::Vec: NormalOut<<u32 as TypeCommon>::Vec, Output = <<T as NormalOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<u32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u32>, <T as NormalOut<u32>>::Output: CommonBounds, T::Vec: NormalOut<<u32 as TypeCommon>::Vec, Output = <<T as NormalOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<u64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u64>, <T as NormalOut<u64>>::Output: CommonBounds, T::Vec: NormalOut<<u64 as TypeCommon>::Vec, Output = <<T as NormalOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<u64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u64>, <T as NormalOut<u64>>::Output: CommonBounds, T::Vec: NormalOut<<u64 as TypeCommon>::Vec, Output = <<T as NormalOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<u8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u8>, <T as NormalOut<u8>>::Output: CommonBounds, T::Vec: NormalOut<<u8 as TypeCommon>::Vec, Output = <<T as NormalOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Self::Output

Performs the % operation.

impl<T, const DEVICE: usize, A> Rem<u8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u8>, <T as NormalOut<u8>>::Output: CommonBounds, T::Vec: NormalOut<<u8 as TypeCommon>::Vec, Output = <<T as NormalOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Self::Output

Performs the % operation.

impl<T, U, const DEVICE: usize, A> RemAssign<&Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T>, A: Allocator, A::Output: AllocatorOutputRetrive,

fn rem_assign(&mut self, rhs: &Tensor<U, Cpu, DEVICE, A>)

Performs the %= operation.

impl<T, U, const DEVICE: usize, A> RemAssign<Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T>, A: Allocator, A::Output: AllocatorOutputRetrive,

fn rem_assign(&mut self, rhs: Tensor<U, Cpu, DEVICE, A>)

Performs the %= operation.

impl<T, const DEVICE: usize, A> Save for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NoUninit + Pod, A: Allocator + 'static, Tensor<T, Cpu, DEVICE, A>: TensorCreator<Output = Tensor<T, Cpu, DEVICE, A>>,

type Meta = TensorMeta<T, Tensor<T, Cpu, DEVICE, A>>

fn __save( data: &Self, file: &mut File, len_so_far: &mut usize, global_cnt: &mut usize, compression_algo: CompressionAlgo, level: u32, ) -> Result<Self::Meta>

fn save<P>(&self, path: P) -> Result<(), Error>

where P: Into<PathBuf>, Self::Meta: Serialize,

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

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

type Meta = T

tensor data type

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

the output type

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

Remove single-dimensional entries (axes with size 1) from the shape of the tensor at specified positions.

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 dimention.

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

Gives a new shape to the tensor without changing its data when it is possible.

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

Swaps two axes of the 2D tensor, returning a view of the tensor with axes transposed.

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

Permutes the dimensions of the tensor according to the given axes order.

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

Performs the inverse permutation of dimensions according to the given axes order. This is equivalent to undoing a previous permutation.

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

Expands the tensor to a larger size, replicating the data along specified dimensions.

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

Transposes the tensor by swapping the last two dimensions. For 1D or 2D tensors, this is equivalent to a regular transpose. For higher dimensional tensors, only the last two dimensions are swapped.

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

Performs a complete transpose by reversing all dimensions of the tensor. This is different from t() which only swaps the last two dimensions.

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

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

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

Reverses the order of elements along axis 1 (columns) of the tensor. The tensor must be at least 2-dimensional.

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

Reverses the order of elements along axis 0 (rows) of the tensor. The tensor must be at least 1-dimensional.

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

Constructs a new tensor by repeating the input tensor along specified dimensions.

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

where Self::Meta: PartialEq,

Removes zeros from the beginning and/or end of a 1-D tensor.

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

Repeats elements of a tensor along a specified axis.

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

Splits a tensor into multiple sub-tensors along a specified axis at given indices.

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

Splits a tensor into multiple sub-tensors along axis 2 (depth). The tensor must be at least 3-dimensional.

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

Splits a tensor into multiple sub-tensors horizontally (along axis 1). The tensor must be at least 2-dimensional.

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

Splits a tensor into multiple sub-tensors vertically (along axis 0). The tensor must be at least 1-dimensional.

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

Interchanges two axes of a tensor. This operation creates a view of the tensor with the specified axes swapped.

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

where A: Into<Option<usize>>,

Flattens a contiguous range of dimensions in a tensor into a single dimension.

impl<T, const DEVICE: usize, A> Shl<&Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: BitWiseOut<T>, <bool as BitWiseOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<bool as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<&Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: BitWiseOut<T>, <i16 as BitWiseOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<&Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: BitWiseOut<T>, <i32 as BitWiseOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<&Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: BitWiseOut<T>, <i64 as BitWiseOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<&Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: BitWiseOut<T>, <i8 as BitWiseOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<&Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: BitWiseOut<T>, <u16 as BitWiseOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<&Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: BitWiseOut<T>, <u32 as BitWiseOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<&Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: BitWiseOut<T>, <u64 as BitWiseOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<&Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: BitWiseOut<T>, <u8 as BitWiseOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, U, const DEVICE: usize, A> Shl<&Tensor<U, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T, U, const DEVICE: usize, A> Shl<&Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: BitWiseOut<T>, <bool as BitWiseOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<bool as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: BitWiseOut<T>, <i16 as BitWiseOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: BitWiseOut<T>, <i32 as BitWiseOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: BitWiseOut<T>, <i64 as BitWiseOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: BitWiseOut<T>, <i8 as BitWiseOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: BitWiseOut<T>, <u16 as BitWiseOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: BitWiseOut<T>, <u32 as BitWiseOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: BitWiseOut<T>, <u64 as BitWiseOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: BitWiseOut<T>, <u8 as BitWiseOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the << operation.

impl<T, U, const DEVICE: usize, A> Shl<Tensor<U, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T, U, const DEVICE: usize, A> Shl<Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<bool> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<bool>, <T as BitWiseOut<bool>>::Output: CommonBounds, T::Vec: BitWiseOut<<bool as TypeCommon>::Vec, Output = <<T as BitWiseOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: bool) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<bool> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<bool>, <T as BitWiseOut<bool>>::Output: CommonBounds, T::Vec: BitWiseOut<<bool as TypeCommon>::Vec, Output = <<T as BitWiseOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: bool) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<i16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i16>, <T as BitWiseOut<i16>>::Output: CommonBounds, T::Vec: BitWiseOut<<i16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<i16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i16>, <T as BitWiseOut<i16>>::Output: CommonBounds, T::Vec: BitWiseOut<<i16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<i32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i32>, <T as BitWiseOut<i32>>::Output: CommonBounds, T::Vec: BitWiseOut<<i32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<i32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i32>, <T as BitWiseOut<i32>>::Output: CommonBounds, T::Vec: BitWiseOut<<i32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<i64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i64>, <T as BitWiseOut<i64>>::Output: CommonBounds, T::Vec: BitWiseOut<<i64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<i64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i64>, <T as BitWiseOut<i64>>::Output: CommonBounds, T::Vec: BitWiseOut<<i64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<i8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i8>, <T as BitWiseOut<i8>>::Output: CommonBounds, T::Vec: BitWiseOut<<i8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<i8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i8>, <T as BitWiseOut<i8>>::Output: CommonBounds, T::Vec: BitWiseOut<<i8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<u16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u16>, <T as BitWiseOut<u16>>::Output: CommonBounds, T::Vec: BitWiseOut<<u16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<u16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u16>, <T as BitWiseOut<u16>>::Output: CommonBounds, T::Vec: BitWiseOut<<u16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<u32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u32>, <T as BitWiseOut<u32>>::Output: CommonBounds, T::Vec: BitWiseOut<<u32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<u32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u32>, <T as BitWiseOut<u32>>::Output: CommonBounds, T::Vec: BitWiseOut<<u32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<u64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u64>, <T as BitWiseOut<u64>>::Output: CommonBounds, T::Vec: BitWiseOut<<u64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<u64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u64>, <T as BitWiseOut<u64>>::Output: CommonBounds, T::Vec: BitWiseOut<<u64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<u8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u8>, <T as BitWiseOut<u8>>::Output: CommonBounds, T::Vec: BitWiseOut<<u8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shl<u8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u8>, <T as BitWiseOut<u8>>::Output: CommonBounds, T::Vec: BitWiseOut<<u8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> Self::Output

Performs the << operation.

impl<T, const DEVICE: usize, A> Shr<&Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: BitWiseOut<T>, <bool as BitWiseOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<bool as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<&Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: BitWiseOut<T>, <i16 as BitWiseOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<&Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: BitWiseOut<T>, <i32 as BitWiseOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<&Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: BitWiseOut<T>, <i64 as BitWiseOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<&Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: BitWiseOut<T>, <i8 as BitWiseOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<&Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: BitWiseOut<T>, <u16 as BitWiseOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<&Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: BitWiseOut<T>, <u32 as BitWiseOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<&Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: BitWiseOut<T>, <u64 as BitWiseOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<&Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: BitWiseOut<T>, <u8 as BitWiseOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, U, const DEVICE: usize, A> Shr<&Tensor<U, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T, U, const DEVICE: usize, A> Shr<&Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: BitWiseOut<T>, <bool as BitWiseOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<bool as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: BitWiseOut<T>, <i16 as BitWiseOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: BitWiseOut<T>, <i32 as BitWiseOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: BitWiseOut<T>, <i64 as BitWiseOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: BitWiseOut<T>, <i8 as BitWiseOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<i8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: BitWiseOut<T>, <u16 as BitWiseOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u16 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: BitWiseOut<T>, <u32 as BitWiseOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u32 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: BitWiseOut<T>, <u64 as BitWiseOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u64 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: BitWiseOut<T>, <u8 as BitWiseOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: BitWiseOut<<T as TypeCommon>::Vec, Output = <<u8 as BitWiseOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as BitWiseOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: Tensor<T, Cpu, DEVICE, A>) -> Self::Output

Performs the >> operation.

impl<T, U, const DEVICE: usize, A> Shr<Tensor<U, Cpu, DEVICE, A>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T, U, const DEVICE: usize, A> Shr<Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<U>, U: CommonBounds, <T as BitWiseOut<U>>::Output: CommonBounds, T::Vec: BitWiseOut<<U as TypeCommon>::Vec, Output = <<T as BitWiseOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<U>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<bool> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<bool>, <T as BitWiseOut<bool>>::Output: CommonBounds, T::Vec: BitWiseOut<<bool as TypeCommon>::Vec, Output = <<T as BitWiseOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: bool) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<bool> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<bool>, <T as BitWiseOut<bool>>::Output: CommonBounds, T::Vec: BitWiseOut<<bool as TypeCommon>::Vec, Output = <<T as BitWiseOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: bool) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<i16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i16>, <T as BitWiseOut<i16>>::Output: CommonBounds, T::Vec: BitWiseOut<<i16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<i16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i16>, <T as BitWiseOut<i16>>::Output: CommonBounds, T::Vec: BitWiseOut<<i16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<i32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i32>, <T as BitWiseOut<i32>>::Output: CommonBounds, T::Vec: BitWiseOut<<i32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<i32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i32>, <T as BitWiseOut<i32>>::Output: CommonBounds, T::Vec: BitWiseOut<<i32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<i64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i64>, <T as BitWiseOut<i64>>::Output: CommonBounds, T::Vec: BitWiseOut<<i64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<i64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i64>, <T as BitWiseOut<i64>>::Output: CommonBounds, T::Vec: BitWiseOut<<i64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<i8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i8>, <T as BitWiseOut<i8>>::Output: CommonBounds, T::Vec: BitWiseOut<<i8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<i8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<i8>, <T as BitWiseOut<i8>>::Output: CommonBounds, T::Vec: BitWiseOut<<i8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<u16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u16>, <T as BitWiseOut<u16>>::Output: CommonBounds, T::Vec: BitWiseOut<<u16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<u16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u16>, <T as BitWiseOut<u16>>::Output: CommonBounds, T::Vec: BitWiseOut<<u16 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<u32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u32>, <T as BitWiseOut<u32>>::Output: CommonBounds, T::Vec: BitWiseOut<<u32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<u32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u32>, <T as BitWiseOut<u32>>::Output: CommonBounds, T::Vec: BitWiseOut<<u32 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<u64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u64>, <T as BitWiseOut<u64>>::Output: CommonBounds, T::Vec: BitWiseOut<<u64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<u64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u64>, <T as BitWiseOut<u64>>::Output: CommonBounds, T::Vec: BitWiseOut<<u64 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<u8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u8>, <T as BitWiseOut<u8>>::Output: CommonBounds, T::Vec: BitWiseOut<<u8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> Self::Output

Performs the >> operation.

impl<T, const DEVICE: usize, A> Shr<u8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + BitWiseOut<u8>, <T as BitWiseOut<u8>>::Output: CommonBounds, T::Vec: BitWiseOut<<u8 as TypeCommon>::Vec, Output = <<T as BitWiseOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as BitWiseOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> Self::Output

Performs the >> operation.

impl<T: CommonBounds, B: BackendTy + Buffer + Clone, const DEVICE: usize, A> Slice for Tensor<T, B, DEVICE, A>

where A: Allocator,

fn slice( &self, index: &[(i64, i64, i64)], ) -> Result<Tensor<T, B, DEVICE, A>, TensorError>

Create a new Tensor by slicing an existing Tensor. Slicing allows you to extract a portion of a tensor using index ranges for each dimension.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for Complex32

where T: CommonBounds, Complex32: NormalOut<T>, <Complex32 as NormalOut<T>>::Output: CommonBounds, <Complex32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f32> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for Complex64

where T: CommonBounds, Complex64: NormalOut<T>, <Complex64 as NormalOut<T>>::Output: CommonBounds, <Complex64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f64> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for bf16

where T: CommonBounds, bf16: NormalOut<T>, <bf16 as NormalOut<T>>::Output: CommonBounds, <bf16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bf16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bf16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: NormalOut<T>, <bool as NormalOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bool as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for f16

where T: CommonBounds, f16: NormalOut<T>, <f16 as NormalOut<T>>::Output: CommonBounds, <f16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for f32

where T: CommonBounds, f32: NormalOut<T>, <f32 as NormalOut<T>>::Output: CommonBounds, <f32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for f64

where T: CommonBounds, f64: NormalOut<T>, <f64 as NormalOut<T>>::Output: CommonBounds, <f64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: NormalOut<T>, <i16 as NormalOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: NormalOut<T>, <i32 as NormalOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: NormalOut<T>, <i64 as NormalOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: NormalOut<T>, <i8 as NormalOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: NormalOut<T>, <u16 as NormalOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: NormalOut<T>, <u32 as NormalOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: NormalOut<T>, <u64 as NormalOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<&Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: NormalOut<T>, <u8 as NormalOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the - operator.

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

Performs the - operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Complex<f32>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex32>, <T as NormalOut<Complex32>>::Output: CommonBounds, T::Vec: NormalOut<<Complex32 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f32>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Complex<f32>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex32>, <T as NormalOut<Complex32>>::Output: CommonBounds, T::Vec: NormalOut<<Complex32 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f32>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Complex<f64>> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex64>, <T as NormalOut<Complex64>>::Output: CommonBounds, T::Vec: NormalOut<<Complex64 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f64>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Complex<f64>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<Complex64>, <T as NormalOut<Complex64>>::Output: CommonBounds, T::Vec: NormalOut<<Complex64 as TypeCommon>::Vec, Output = <<T as NormalOut<Complex64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<Complex<f64>>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for Complex32

where T: CommonBounds, Complex32: NormalOut<T>, <Complex32 as NormalOut<T>>::Output: CommonBounds, <Complex32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f32> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for Complex64

where T: CommonBounds, Complex64: NormalOut<T>, <Complex64 as NormalOut<T>>::Output: CommonBounds, <Complex64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<Complex64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<Complex<f64> as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for bf16

where T: CommonBounds, bf16: NormalOut<T>, <bf16 as NormalOut<T>>::Output: CommonBounds, <bf16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bf16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bf16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for bool

where T: CommonBounds, bool: NormalOut<T>, <bool as NormalOut<T>>::Output: CommonBounds, <bool as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<bool as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<bool as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for f16

where T: CommonBounds, f16: NormalOut<T>, <f16 as NormalOut<T>>::Output: CommonBounds, <f16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for f32

where T: CommonBounds, f32: NormalOut<T>, <f32 as NormalOut<T>>::Output: CommonBounds, <f32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for f64

where T: CommonBounds, f64: NormalOut<T>, <f64 as NormalOut<T>>::Output: CommonBounds, <f64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<f64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<f64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for i16

where T: CommonBounds, i16: NormalOut<T>, <i16 as NormalOut<T>>::Output: CommonBounds, <i16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for i32

where T: CommonBounds, i32: NormalOut<T>, <i32 as NormalOut<T>>::Output: CommonBounds, <i32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for i64

where T: CommonBounds, i64: NormalOut<T>, <i64 as NormalOut<T>>::Output: CommonBounds, <i64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for i8

where T: CommonBounds, i8: NormalOut<T>, <i8 as NormalOut<T>>::Output: CommonBounds, <i8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<i8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<i8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for u16

where T: CommonBounds, u16: NormalOut<T>, <u16 as NormalOut<T>>::Output: CommonBounds, <u16 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u16 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u16 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for u32

where T: CommonBounds, u32: NormalOut<T>, <u32 as NormalOut<T>>::Output: CommonBounds, <u32 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u32 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u32 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for u64

where T: CommonBounds, u64: NormalOut<T>, <u64 as NormalOut<T>>::Output: CommonBounds, <u64 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u64 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u64 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<Tensor<T, Cpu, DEVICE, A>> for u8

where T: CommonBounds, u8: NormalOut<T>, <u8 as NormalOut<T>>::Output: CommonBounds, <u8 as TypeCommon>::Vec: NormalOut<<T as TypeCommon>::Vec, Output = <<u8 as NormalOut<T>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<u8 as NormalOut<T>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the - operator.

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

Performs the - operation.

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

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds, T::Vec: NormalOut<<U as TypeCommon>::Vec, Output = <<T as NormalOut<U>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<bf16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bf16>, <T as NormalOut<bf16>>::Output: CommonBounds, T::Vec: NormalOut<<bf16 as TypeCommon>::Vec, Output = <<T as NormalOut<bf16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bf16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<bf16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bf16>, <T as NormalOut<bf16>>::Output: CommonBounds, T::Vec: NormalOut<<bf16 as TypeCommon>::Vec, Output = <<T as NormalOut<bf16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bf16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<bool> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bool>, <T as NormalOut<bool>>::Output: CommonBounds, T::Vec: NormalOut<<bool as TypeCommon>::Vec, Output = <<T as NormalOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<bool> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<bool>, <T as NormalOut<bool>>::Output: CommonBounds, T::Vec: NormalOut<<bool as TypeCommon>::Vec, Output = <<T as NormalOut<bool>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<bool>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<f16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f16>, <T as NormalOut<f16>>::Output: CommonBounds, T::Vec: NormalOut<<f16 as TypeCommon>::Vec, Output = <<T as NormalOut<f16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<f16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f16>, <T as NormalOut<f16>>::Output: CommonBounds, T::Vec: NormalOut<<f16 as TypeCommon>::Vec, Output = <<T as NormalOut<f16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<f32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f32>, <T as NormalOut<f32>>::Output: CommonBounds, T::Vec: NormalOut<<f32 as TypeCommon>::Vec, Output = <<T as NormalOut<f32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<f32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f32>, <T as NormalOut<f32>>::Output: CommonBounds, T::Vec: NormalOut<<f32 as TypeCommon>::Vec, Output = <<T as NormalOut<f32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<f64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f64>, <T as NormalOut<f64>>::Output: CommonBounds, T::Vec: NormalOut<<f64 as TypeCommon>::Vec, Output = <<T as NormalOut<f64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<f64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<f64>, <T as NormalOut<f64>>::Output: CommonBounds, T::Vec: NormalOut<<f64 as TypeCommon>::Vec, Output = <<T as NormalOut<f64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<f64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<i16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i16>, <T as NormalOut<i16>>::Output: CommonBounds, T::Vec: NormalOut<<i16 as TypeCommon>::Vec, Output = <<T as NormalOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<i16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i16>, <T as NormalOut<i16>>::Output: CommonBounds, T::Vec: NormalOut<<i16 as TypeCommon>::Vec, Output = <<T as NormalOut<i16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<i32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i32>, <T as NormalOut<i32>>::Output: CommonBounds, T::Vec: NormalOut<<i32 as TypeCommon>::Vec, Output = <<T as NormalOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<i32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i32>, <T as NormalOut<i32>>::Output: CommonBounds, T::Vec: NormalOut<<i32 as TypeCommon>::Vec, Output = <<T as NormalOut<i32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<i64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i64>, <T as NormalOut<i64>>::Output: CommonBounds, T::Vec: NormalOut<<i64 as TypeCommon>::Vec, Output = <<T as NormalOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<i64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i64>, <T as NormalOut<i64>>::Output: CommonBounds, T::Vec: NormalOut<<i64 as TypeCommon>::Vec, Output = <<T as NormalOut<i64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<i8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i8>, <T as NormalOut<i8>>::Output: CommonBounds, T::Vec: NormalOut<<i8 as TypeCommon>::Vec, Output = <<T as NormalOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<i8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<i8>, <T as NormalOut<i8>>::Output: CommonBounds, T::Vec: NormalOut<<i8 as TypeCommon>::Vec, Output = <<T as NormalOut<i8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<i8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<u16> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u16>, <T as NormalOut<u16>>::Output: CommonBounds, T::Vec: NormalOut<<u16 as TypeCommon>::Vec, Output = <<T as NormalOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<u16> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u16>, <T as NormalOut<u16>>::Output: CommonBounds, T::Vec: NormalOut<<u16 as TypeCommon>::Vec, Output = <<T as NormalOut<u16>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u16>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<u32> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u32>, <T as NormalOut<u32>>::Output: CommonBounds, T::Vec: NormalOut<<u32 as TypeCommon>::Vec, Output = <<T as NormalOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<u32> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u32>, <T as NormalOut<u32>>::Output: CommonBounds, T::Vec: NormalOut<<u32 as TypeCommon>::Vec, Output = <<T as NormalOut<u32>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u32>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<u64> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u64>, <T as NormalOut<u64>>::Output: CommonBounds, T::Vec: NormalOut<<u64 as TypeCommon>::Vec, Output = <<T as NormalOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<u64> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u64>, <T as NormalOut<u64>>::Output: CommonBounds, T::Vec: NormalOut<<u64 as TypeCommon>::Vec, Output = <<T as NormalOut<u64>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u64>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<u8> for &Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u8>, <T as NormalOut<u8>>::Output: CommonBounds, T::Vec: NormalOut<<u8 as TypeCommon>::Vec, Output = <<T as NormalOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const DEVICE: usize, A> Sub<u8> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<u8>, <T as NormalOut<u8>>::Output: CommonBounds, T::Vec: NormalOut<<u8 as TypeCommon>::Vec, Output = <<T as NormalOut<u8>>::Output as TypeCommon>::Vec>, A: Allocator, A::Output: AllocatorOutputRetrive,

type Output = Tensor<<T as NormalOut<u8>>::Output, Cpu, DEVICE, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, U, const DEVICE: usize, A> SubAssign<&Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T>, A: Allocator, A::Output: AllocatorOutputRetrive,

fn sub_assign(&mut self, rhs: &Tensor<U, Cpu, DEVICE, A>)

Performs the -= operation.

impl<T, U, const DEVICE: usize, A> SubAssign<Tensor<U, Cpu, DEVICE, A>> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds + NormalOut<U>, U: CommonBounds, <T as NormalOut<U>>::Output: CommonBounds + Cast<T>, A: Allocator, A::Output: AllocatorOutputRetrive,

fn sub_assign(&mut self, rhs: Tensor<U, Cpu, DEVICE, A>)

Performs the -= operation.

impl<T, C, const DEVICE: usize, Al> TensorCmp<T, C> for Tensor<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, Al::Output: AllocatorOutputRetrive,

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

right hand side tensor type

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

output tensor type, normally a boolean tensor

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

where D: Borrow<Self::RHS>,

check if element from x is not equal to element from y

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

where D: Borrow<Self::RHS>,

check if element from x is equal to element from y

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

where D: Borrow<Self::RHS>,

check if element from x is less than the element from y

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

where D: Borrow<Self::RHS>,

check if element from x is greater than the element from y

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

where D: Borrow<Self::RHS>,

check if element from x is less or equal to the element from y

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

where D: Borrow<Self::RHS>,

check if element from x is greater or equal to the element from y

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

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

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

the output type of the tensor

type Meta = T

the meta type of the tensor

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

Creates a new uninitialized tensor with the specified shape. The tensor’s values will be whatever was in memory at the time of allocation.

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

Creates a new tensor of the specified shape, filled with zeros.

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

where u8: Cast<T>,

Creates a new tensor of the specified shape, filled with ones.

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

Creates a new uninitialized tensor with the same shape as the input tensor.

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

Creates a new zeroed tensor with the same shape as the input tensor.

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

where u8: Cast<T>,

Creates a new tensor with all ones with the same shape as the input tensor.

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

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

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

Creates a new tensor filled with a specified value with 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 1-D tensor with evenly spaced values within a given interval [start, end).

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

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

Creates a 1-D tensor with evenly spaced values within a given interval [start, end) with a specified step size.

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

Creates a 2-D tensor with ones on the k-th 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 1-D tensor of num evenly spaced values between start and end.

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

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

Creates a 1-D tensor with num numbers logarithmically spaced between base^start and base^end.

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

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

Creates a 1-D tensor with n numbers geometrically spaced 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 tensor with ones at and below (or above) the k-th diagonal.

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 a copy of the tensor with elements above the k-th diagonal zeroed.

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 a copy of the tensor with elements below the k-th diagonal zeroed.

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

where u8: Cast<T>,

Creates a 2-D identity tensor (1’s on the main diagonal and 0’s elsewhere).

impl<A, B> TensorDot<Tensor<B>> for Tensor<A>

where _Tensor<A>: TensorDot<_Tensor<B>, Output = _Tensor<<A as NormalOut<B>>::Output>>, A: CommonBounds + NormalOut<B>, B: CommonBounds, <A as NormalOut<B>>::Output: CommonBounds,

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

The output tensor type.

fn tensordot<const N: usize>( &self, rhs: &Tensor<B>, axes: ([i64; N], [i64; N]), ) -> Result<Self::Output, TensorError>

Compute tensor dot product along specified axes. This is a generalization of matrix multiplication to higher dimensions.

impl<T, B, const DEVICE: usize, A> TensorInfo<T> for &Tensor<T, B, DEVICE, A>

where T: CommonBounds, B: BackendTy + Buffer, A: Allocator,

fn ptr(&self) -> Pointer<T>

Returns a pointer to the tensor’s first data.

fn size(&self) -> usize

Returns the size of the tensor based on the shape

fn shape(&self) -> &Shape

Returns the shape of the tensor.

fn strides(&self) -> &Strides

Returns the strides of the tensor.

fn layout(&self) -> &Layout

Returns the layout of the tensor. Layout contains shape and strides.

fn parent(&self) -> Option<Pointer<T>>

Returns the root tensor, if any.

fn ndim(&self) -> usize

Returns the number of dimensions of the tensor.

fn is_contiguous(&self) -> bool

Returns whether the tensor is contiguous in memory. View or transpose tensors are not contiguous.

fn elsize() -> usize

Returns the data type memory size in bytes.

impl<T, B, const DEVICE: usize, A> TensorInfo<T> for &mut Tensor<T, B, DEVICE, A>

where T: CommonBounds, B: BackendTy + Buffer, A: Allocator,

fn ptr(&self) -> Pointer<T>

Returns a pointer to the tensor’s first data.

fn size(&self) -> usize

Returns the size of the tensor based on the shape

fn shape(&self) -> &Shape

Returns the shape of the tensor.

fn strides(&self) -> &Strides

Returns the strides of the tensor.

fn layout(&self) -> &Layout

Returns the layout of the tensor. Layout contains shape and strides.

fn parent(&self) -> Option<Pointer<T>>

Returns the root tensor, if any.

fn ndim(&self) -> usize

Returns the number of dimensions of the tensor.

fn is_contiguous(&self) -> bool

Returns whether the tensor is contiguous in memory. View or transpose tensors are not contiguous.

fn elsize() -> usize

Returns the data type memory size in bytes.

impl<T, B, const DEVICE: usize, A> TensorInfo<T> for Tensor<T, B, DEVICE, A>

where T: CommonBounds, B: BackendTy + Buffer, A: Allocator,

fn ptr(&self) -> Pointer<T>

Returns a pointer to the tensor’s first data.

fn size(&self) -> usize

Returns the size of the tensor based on the shape

fn shape(&self) -> &Shape

Returns the shape of the tensor.

fn strides(&self) -> &Strides

Returns the strides of the tensor.

fn layout(&self) -> &Layout

Returns the layout of the tensor. Layout contains shape and strides.

fn parent(&self) -> Option<Pointer<T>>

Returns the root tensor, if any.

fn ndim(&self) -> usize

Returns the number of dimensions of the tensor.

fn is_contiguous(&self) -> bool

Returns whether the tensor is contiguous in memory. View or transpose tensors are not contiguous.

fn elsize() -> usize

Returns the data type memory size in bytes.

impl<'a, T: CommonBounds, const DEVICE: usize, Al> TensorIterator<'a, T> for Tensor<T, Cpu, DEVICE, Al>

where Al: Allocator + 'a, Al::Output: AllocatorOutputRetrive,

fn iter(&'a self) -> Strided<T>

Convert the tensor into a strided iterator.

fn iter_mut(&'a mut self) -> StridedMut<'a, T>

Convert the tensor into a mutable strided iterator.

fn iter_simd(&'a self) -> StridedSimd<T>

Convert the tensor into a strided simd iterator.

fn iter_mut_simd(&'a self) -> StridedMutSimd<'a, T>

Convert the tensor into a mutable strided simd iterator.

fn par_iter_simd(&'a self) -> ParStridedSimd<T>

Convert the tensor into a parallel strided simd iterator.

fn par_iter_mut_simd(&'a mut self) -> ParStridedMutSimd<'a, T>

Convert the tensor into a mutable parallel strided simd iterator.

fn par_iter(&'a self) -> ParStrided<T>

Convert the tensor into a parallel strided iterator.

fn par_iter_mut(&'a mut self) -> ParStridedMut<'a, T>

Convert the tensor into a mutable parallel strided iterator.

impl<T, const DEVICE: usize, A> TensorLike<T> for Tensor<T, Cpu, DEVICE, A>

where T: CommonBounds, A: Allocator,

fn as_raw(&self) -> &[T]

directly convert the tensor to raw slice

fn as_raw_mut(&mut self) -> &mut [T]

directly convert the tensor to mutable raw slice

fn elsize() -> usize

Returns the data type memory size in bytes.

impl<T, const DEVICE: usize, Al> TensorWhere for Tensor<T, Cpu, DEVICE, Al>

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

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

The type of the output tensor

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

The type of the condition tensor

fn tensor_where( condition: &Self::Condition, x: &Self::Output, y: &Self::Output, ) -> Result<Self::Output, TensorError>

Element-wise selection based on a condition tensor. Returns a tensor of elements selected from x where condition is true, and from y where condition is false.

impl<T, const DEVICE_ID: usize, A> ToDataLoader for Tensor<T, Cpu, DEVICE_ID, A>

where T: CommonBounds, A: Allocator,

type Output = DataLoader<T, Tensor<T, Cpu, DEVICE_ID, A>>

the output type of the conversion

fn to_dataloader(self) -> Self::Output

convert to DataLoader

impl<T, const DEVICE: usize, Al> WindowOps for Tensor<T, Cpu, DEVICE, Al>

where T: CommonBounds, _Tensor<T, Cpu, DEVICE, Al>: WindowOps<Output = _Tensor<T, Cpu, DEVICE, Al>> + Into<Tensor<T, Cpu, DEVICE, Al>>, Al: Allocator, Al::Output: AllocatorOutputRetrive,

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

The type of the output tensor

type Meta = T

The type of the meta data

fn hamming_window( window_length: i64, periodic: bool, ) -> Result<Self::Output, TensorError>

Generates a Hamming window of a specified length.

fn hann_window( window_length: i64, periodic: bool, ) -> Result<Self::Output, TensorError>

Generates a Hann window of a specified length.

fn blackman_window( window_length: i64, periodic: bool, ) -> Result<Self::Output, TensorError>

Generates a Blackman window tensor.