Struct ArrayBase

pub struct ArrayBase<Backend: Backend, StorageType: Storage, NDims: Dimension> { /* private fields */ }

The base type for all arrays. This type should not be used directly – it is used through various type aliases to make the API more ergonomic.

Implementations

impl<Backend, StorageType, NDims> ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

pub const fn new(axes: Axes<NDims>, storage: StorageType) -> Self

where StorageType: OwnedStorage,

Create a new ArrayBase object with the given axes and storage.

pub unsafe fn new_empty(shape: NDims) -> Self

where StorageType: OwnedStorage,

Create a new ArrayBase object with allocated, but uninitialized storage.

Safety

The values in the Array are not initialized, so will almost certainly contain garbage data. Every element in the array should be written to before being read from.

Example

// TODO: Refactor some of this into a single prelude
use tensr::array::base::ArrayBase;
use tensr::dimension::dim::Dim2;
use tensr::backend::host::host_storage::HostStorage;
use tensr::backend::host::host_backend::HostBackend;
use crate::tensr::backend::traits::ContainerLength;

let mut array = unsafe { ArrayBase::<HostBackend, HostStorage<i32>, Dim2>::new_empty(Dim2::new([3, 4])) };
assert_eq!(array.len(), 12);

pub fn zeros(shape: NDims) -> Self

where StorageType: OwnedStorage, StorageType::Scalar: Zero,

pub fn ones(shape: NDims) -> Self

where StorageType: OwnedStorage, StorageType::Scalar: One,

pub fn new_with(shape: NDims, value: StorageType::Scalar) -> Self

where StorageType: OwnedStorage,

pub fn fill(&mut self, value: StorageType::Scalar)

pub const fn shape(&self) -> &NDims

Get the dimensions of the array

pub const fn strides(&self) -> &NDims

Get the strides of the array

Trait Implementations

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Add<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Add<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Add<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Add<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Add<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Add<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Add<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Add<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Add<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Add<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Add<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Add<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Add<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Add<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Add<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Add<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Add<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Add<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Add<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the + operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Add<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Add<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the + operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Add<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the + operation.

impl<Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Add<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'static, Backend, <Backend as Backend>::AddKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the + operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Add<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the + operator.

fn add(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Add<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Add<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Add<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::AddKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the + operator.

fn add( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the + operation.

impl<'a, Backend, StorageType, NDims> ContainerBackendType for &'a ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

type Backend = Backend

impl<'a, Backend, StorageType, NDims> ContainerBackendType for &'a mut ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

type Backend = Backend

impl<Backend, StorageType, NDims> ContainerBackendType for ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

type Backend = Backend

impl<'a, Backend, StorageType, NDims> ContainerLength for &'a ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

fn len(&self) -> usize

Returns the length of the container

fn is_empty(&self) -> bool

Returns true if the container is empty. This is equivalent to self.len() == 0.

impl<'a, Backend, StorageType, NDims> ContainerLength for &'a mut ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

fn len(&self) -> usize

Returns the length of the container

fn is_empty(&self) -> bool

Returns true if the container is empty. This is equivalent to self.len() == 0.

impl<Backend, StorageType, NDims> ContainerLength for ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

fn len(&self) -> usize

Returns the length of the container

fn is_empty(&self) -> bool

Returns true if the container is empty. This is equivalent to self.len() == 0.

impl<'a, Backend, StorageType, NDims> ContainerScalarType for &'a ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

type Scalar = <StorageType as ContainerScalarType>::Scalar

The scalar type of the container

impl<'a, Backend, StorageType, NDims> ContainerScalarType for &'a mut ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

type Scalar = <StorageType as ContainerScalarType>::Scalar

The scalar type of the container

impl<Backend, StorageType, NDims> ContainerScalarType for ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

type Scalar = <StorageType as ContainerScalarType>::Scalar

The scalar type of the container

impl<'a, Backend, StorageType, NDims> ContainerStorageAccessor for &'a ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

fn get_storage(&self) -> &Self::Storage

Return a reference to the underlying storage

impl<'a, Backend, StorageType, NDims> ContainerStorageAccessor for &'a mut ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

fn get_storage(&self) -> &Self::Storage

Return a reference to the underlying storage

impl<Backend, StorageType, NDims> ContainerStorageAccessor for ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

fn get_storage(&self) -> &Self::Storage

Return a reference to the underlying storage

impl<'a, Backend, StorageType, NDims> ContainerStorageType for &'a ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

type Storage = StorageType

The storage type of the container

impl<'a, Backend, StorageType, NDims> ContainerStorageType for &'a mut ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

type Storage = StorageType

The storage type of the container

impl<Backend, StorageType, NDims> ContainerStorageType for ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

type Storage = StorageType

The storage type of the container

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Div<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Div<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Div<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Div<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Div<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Div<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Div<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Div<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Div<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Div<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Div<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Div<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Div<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Div<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Div<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Div<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Div<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Div<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Div<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the / operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Div<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Div<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the / operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Div<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the / operation.

impl<Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Div<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'static, Backend, <Backend as Backend>::DivKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the / operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Div<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the / operator.

fn div(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Div<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Div<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Div<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::DivKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the / operator.

fn div( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the / operation.

impl<'a, Backend, StorageType, NDims> GetWriteableBuffer for &'a ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage + GetWriteableBuffer, NDims: Dimension,

type Buffer = <StorageType as GetWriteableBuffer>::Buffer

unsafe fn get_buffer_and_set_no_free( &mut self, _: usize, ) -> Option<Self::Buffer>

If possible, return the underlying buffer and tell this container to not free the data when it is dropped. This enables data reuse in the lazy evaluated function system.

impl<'a, Backend, StorageType, NDims> GetWriteableBuffer for &'a mut ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage + GetWriteableBuffer, NDims: Dimension,

type Buffer = <StorageType as GetWriteableBuffer>::Buffer

unsafe fn get_buffer_and_set_no_free( &mut self, _: usize, ) -> Option<Self::Buffer>

If possible, return the underlying buffer and tell this container to not free the data when it is dropped. This enables data reuse in the lazy evaluated function system.

impl<Backend, StorageType, NDims> GetWriteableBuffer for ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage + GetWriteableBuffer, NDims: Dimension,

type Buffer = <StorageType as GetWriteableBuffer>::Buffer

unsafe fn get_buffer_and_set_no_free( &mut self, len: usize, ) -> Option<Self::Buffer>

If possible, return the underlying buffer and tell this container to not free the data when it is dropped. This enables data reuse in the lazy evaluated function system.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Mul<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Mul<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Mul<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Mul<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Mul<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Mul<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Mul<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Mul<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Mul<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Mul<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Mul<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Mul<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Mul<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Mul<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Mul<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Mul<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Mul<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Mul<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Mul<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the * operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Mul<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Mul<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the * operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Mul<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the * operation.

impl<Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Mul<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'static, Backend, <Backend as Backend>::MulKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the * operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Mul<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the * operator.

fn mul(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Mul<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Mul<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Mul<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::MulKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the * operator.

fn mul( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the * operation.

impl<'a, Backend, StorageType, NDims> MutableContainerStorageAccessor for &'a mut ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

fn get_storage_mut(&mut self) -> &mut Self::Storage

Return a mutable reference to the underlying storage

impl<Backend, StorageType, NDims> MutableContainerStorageAccessor for ArrayBase<Backend, StorageType, NDims>

where Backend: Backend, StorageType: Storage, NDims: Dimension,

fn get_storage_mut(&mut self) -> &mut Self::Storage

Return a mutable reference to the underlying storage

impl<'a, StorageType, NDims> ScalarAccessor for &'a ArrayBase<HostBackend, StorageType, NDims>

where StorageType: Storage, NDims: Dimension,

fn get_scalar(&self, index: usize) -> Self::Scalar

Return the index’th element of a data container or wrapper

impl<'a, StorageType, NDims> ScalarAccessor for &'a mut ArrayBase<HostBackend, StorageType, NDims>

where StorageType: Storage, NDims: Dimension,

fn get_scalar(&self, index: usize) -> Self::Scalar

Return the index’th element of a data container or wrapper

impl<StorageType, NDims> ScalarAccessor for ArrayBase<HostBackend, StorageType, NDims>

where StorageType: Storage, NDims: Dimension,

fn get_scalar(&self, index: usize) -> Self::Scalar

Return the index’th element of a data container or wrapper

impl<'a, StorageType, NDims> ScalarWriter for &'a mut ArrayBase<HostBackend, StorageType, NDims>

where StorageType: Storage, NDims: Dimension,

fn write_scalar(&mut self, value: Self::Scalar, index: usize)

Write a value to the index’th element of a data container or wrapper

impl<StorageType, NDims> ScalarWriter for ArrayBase<HostBackend, StorageType, NDims>

where StorageType: Storage, NDims: Dimension,

fn write_scalar(&mut self, value: Self::Scalar, index: usize)

Write a value to the index’th element of a data container or wrapper

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Sub<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Sub<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Sub<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Sub<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Sub<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Sub<&'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Sub<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Sub<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Sub<&'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Sub<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Sub<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Sub<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Sub<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Sub<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Sub<&'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut ArrayBase<Backend, StorageTypeRhs, NDimsRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Sub<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Sub<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Sub<&'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Sub<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the - operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Sub<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Sub<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the - operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Sub<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a mut TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the - operation.

impl<Backend, StorageTypeLhs, NDimsLhs, StorageTypeRhs, NDimsRhs> Sub<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'static, Backend, <Backend as Backend>::SubKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the - operation.

impl<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs, StorageTypeRhs, NDimsRhs> Sub<ArrayBase<Backend, StorageTypeRhs, NDimsRhs>> for TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>

where Backend: Backend, OpLhs: BinaryOp, LhsTypeLhs: GetWriteableBuffer, RhsTypeLhs: GetWriteableBuffer<Buffer = LhsTypeLhs::Buffer>, StorageTypeRhs: Storage, NDimsRhs: Dimension,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, TensrFn2<'a, Backend, OpLhs, LhsTypeLhs, RhsTypeLhs>, ArrayBase<Backend, StorageTypeRhs, NDimsRhs>>

The resulting type after applying the - operator.

fn sub(self, rhs: ArrayBase<Backend, StorageTypeRhs, NDimsRhs>) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Sub<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Sub<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, &'a mut ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the - operation.

impl<'a, Backend, StorageTypeLhs, NDimsLhs, OpRhs, LhsTypeRhs, RhsTypeRhs> Sub<TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>> for ArrayBase<Backend, StorageTypeLhs, NDimsLhs>

where Backend: Backend, StorageTypeLhs: Storage, NDimsLhs: Dimension, OpRhs: BinaryOp, LhsTypeRhs: GetWriteableBuffer, RhsTypeRhs: GetWriteableBuffer<Buffer = LhsTypeRhs::Buffer>,

type Output = TensrFn2<'a, Backend, <Backend as Backend>::SubKernel, ArrayBase<Backend, StorageTypeLhs, NDimsLhs>, TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>>

The resulting type after applying the - operator.

fn sub( self, rhs: TensrFn2<'a, Backend, OpRhs, LhsTypeRhs, RhsTypeRhs>, ) -> Self::Output

Performs the - operation.