Struct Array

pub struct Array<Item, ArrayImpl, const NDIM: usize>(/* private fields */)
where
    Item: RlstBase,
    ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>;

The basic tuple type defining an array.

Implementations

impl<Item: RlstScalar + MatrixInverse, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Stride<2> + Shape<2> + RawAccessMut<Item = Item>> Array<Item, ArrayImpl, 2>

pub fn into_inverse_alloc(self) -> RlstResult<()>

Return the matrix inverse.

impl<Item: RlstScalar + MatrixLu, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Stride<2> + RawAccessMut<Item = Item> + Shape<2>> Array<Item, ArrayImpl, 2>

pub fn into_lu_alloc(self) -> RlstResult<LuDecomposition<Item, ArrayImpl>>

Compute the LU decomposition of a matrix.

The LU Decomposition of an (m,n) matrix A is defined by A = PLU, where P is an (m, m) permutation matrix, L is a (m, k) unit lower triangular matrix, and U is an (k, n) upper triangular matrix.

impl<Item: RlstScalar + MatrixPseudoInverse, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Stride<2> + Shape<2> + UnsafeRandomAccessMut<2, Item = Item> + RawAccessMut<Item = Item>> Array<Item, ArrayImpl, 2>

pub fn into_pseudo_inverse_resize_alloc<ArrayImplPInv: UnsafeRandomAccessByValue<2, Item = Item> + Stride<2> + Shape<2> + RawAccessMut<Item = Item> + UnsafeRandomAccessMut<2, Item = Item> + ResizeInPlace<2>>( self, pinv: Array<Item, ArrayImplPInv, 2>, tol: <Item as RlstScalar>::Real, ) -> RlstResult<()>

Compute the pseudoinverse into the array pinv.

This method dynamically allocates memory for the computation.

Parameters

• pinv: Array to store the pseudo-inverse in. Array is resized if necessary.
• tol: The relative tolerance. Singular values smaller or equal tol will be discarded.

pub fn into_pseudo_inverse_alloc<ArrayImplPInv: UnsafeRandomAccessByValue<2, Item = Item> + Stride<2> + Shape<2> + RawAccessMut<Item = Item> + UnsafeRandomAccessMut<2, Item = Item>>( self, pinv: Array<Item, ArrayImplPInv, 2>, tol: <Item as RlstScalar>::Real, ) -> RlstResult<()>

Compute the pseudo inverse into the array pinv.

This method dynamically allocates memory for the computation.

Parameters

• pinv: Array to store the pseudo-inverse in. If self has shape [m, n] then pinv must have shape [n, m].
• tol: The relative tolerance. Singular values smaller or equal tol * s\[0\] will be discarded, where s[0] is the largest singular value.

impl<Item: RlstScalar + MatrixQr, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Stride<2> + RawAccessMut<Item = Item> + Shape<2>> Array<Item, ArrayImpl, 2>

pub fn into_qr_alloc(self) -> RlstResult<QrDecomposition<Item, ArrayImpl>>

Compute the QR decomposition of a given 2-dimensional array.

impl<Item: RlstScalar + MatrixSvd, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Stride<2> + Shape<2> + RawAccessMut<Item = Item>> Array<Item, ArrayImpl, 2>

pub fn into_singular_values_alloc( self, singular_values: &mut [<Item as RlstScalar>::Real], ) -> RlstResult<()>

Compute the singular values of the matrix.

For a (m, n) matrix A the slice singular_values has length k=min(m, n).

This method allocates temporary memory during execution.

pub fn into_svd_alloc<ArrayImplU: UnsafeRandomAccessByValue<2, Item = Item> + Stride<2> + Shape<2> + RawAccessMut<Item = Item>, ArrayImplVt: UnsafeRandomAccessByValue<2, Item = Item> + Stride<2> + Shape<2> + RawAccessMut<Item = Item>>( self, u: Array<Item, ArrayImplU, 2>, vt: Array<Item, ArrayImplVt, 2>, singular_values: &mut [<Item as RlstScalar>::Real], mode: SvdMode, ) -> RlstResult<()>

Compute the singular value decomposition.

We assume that A is a (m, n) matrix and assume k=min(m, n). This method computes the singular value decomposition A = USVt.

Parameters

• u - Stores the matrix U. For the full SVD the shape needs to be (m, m). For the reduced SVD it needs to be (m, k).
• vt - Stores the matrix Vt. For the full SVD the shape needs to be (n, n). For the reduced SVD it needs to be (k, n). Note that vt stores the complex conjugate transpose of the matrix of right singular vectors. Hence, the columns of vt.transpose().conj() will be the right singular vectors.
• singular_values - Stores the k singular values of A.
• mode - Choose between full SVD SvdMode::Full or reduced SVD SvdMode::Reduced.

This method allocates temporary memory during execution.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<ADIM, Item = Item> + Shape<ADIM>, const ADIM: usize> Array<Item, ArrayImpl, ADIM>

pub fn insert_empty_axis<const NDIM: usize>( self, axis_position: AxisPosition, ) -> Array<Item, ArrayAppendAxis<Item, ArrayImpl, ADIM, NDIM>, NDIM>

where NumberType<ADIM>: IsSmallerByOne<NDIM>,

Insert empty axis

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2>> Array<Item, ArrayImpl, 2>

pub fn row_iter(&self) -> RowIterator<'_, Item, ArrayImpl, 2>

Return a row iterator for a two-dimensional array.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + UnsafeRandomAccessMut<2, Item = Item>> Array<Item, ArrayImpl, 2>

pub fn row_iter_mut(&mut self) -> RowIteratorMut<'_, Item, ArrayImpl, 2>

Return a mutable row iterator for a two-dimensional array.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2>> Array<Item, ArrayImpl, 2>

pub fn col_iter(&self) -> ColIterator<'_, Item, ArrayImpl, 2>

Return a column iterator for a two-dimensional array.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + UnsafeRandomAccessMut<2, Item = Item>> Array<Item, ArrayImpl, 2>

pub fn col_iter_mut(&mut self) -> ColIteratorMut<'_, Item, ArrayImpl, 2>

Return a mutable column iterator for a two-dimensional array.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1>> Array<Item, ArrayImpl, 1>

pub fn len(&self) -> usize

Length of 1-d vector

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn is_empty(&self) -> bool

Return true of array is empty (that is one dimension is zero), otherwise false.

pub fn get_diag<ArrayImplOther: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1> + UnsafeRandomAccessMut<1, Item = Item>>( &self, other: Array<Item, ArrayImplOther, 1>, )

Get the diagonal of an array.

Argument must be a 1d array of length self.shape().iter().min().

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + UnsafeRandomAccessMut<NDIM, Item = Item>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn set_diag<ArrayImplOther: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1> + UnsafeRandomAccessMut<1, Item = Item>>( &mut self, other: Array<Item, ArrayImplOther, 1>, )

Set the diagonal of an array.

Argument must be a 1d array of length self.shape().iter().min().

pub fn fill_from<ArrayImplOther: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>>( &mut self, other: Array<Item, ArrayImplOther, NDIM>, )

Fill an array with values from another array.

pub fn fill_from_resize<ArrayImplOther: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>>( &mut self, other: Array<Item, ArrayImplOther, NDIM>, )

where Self: ResizeInPlace<NDIM>,

Fill an array from another array and resize if necessary.

pub fn fill_from_chunked<Other: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + ChunkedAccess<N, Item = Item>, const N: usize>( &mut self, other: Other, )

Fill an array with values from an other arrays using chunks of size N.

pub fn fill_from_chunked_resize<Other: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + ChunkedAccess<N, Item = Item>, const N: usize>( &mut self, other: Other, )

where Self: ResizeInPlace<NDIM>,

Fill an array with values from an other arrays using chunks of size N. Resize if necessary.

impl<Item: RlstNum, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + UnsafeRandomAccessMut<NDIM, Item = Item>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn set_zero(&mut self)

Set all elements of an array to zero.

pub fn set_one(&mut self)

Set all elements of an array to one.

pub fn set_identity(&mut self)

Fill the diagonal of an array with the value 1 and all other elements zero.

pub fn scale_inplace(&mut self, alpha: Item)

Multiply all array elements with the scalar alpha.

pub fn sum_into<ArrayImplOther: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>>( &mut self, other: Array<Item, ArrayImplOther, NDIM>, )

Sum other array into array.

pub fn cmp_mult_into<ArrayImplOther: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>>( &mut self, other: Array<Item, ArrayImplOther, NDIM>, )

Componentwise multiply other array into array.

pub fn sum_into_chunked<ArrayImplOther: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + ChunkedAccess<N, Item = Item>, const N: usize>( &mut self, other: Array<Item, ArrayImplOther, NDIM>, )

where Self: ChunkedAccess<N, Item = Item>,

Chunked summation into array.

pub fn cmp_mult_into_chunked<ArrayImplOther: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + ChunkedAccess<N, Item = Item>, const N: usize>( &mut self, other: Array<Item, ArrayImplOther, NDIM>, )

where Self: ChunkedAccess<N, Item = Item>,

Chunked componentwise multiplication into array.

impl<Item: RlstNum, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn trace(self) -> Item

Return the trace of an array.

pub fn sum(self) -> Item

Return the sum of the elements.

impl<Item: RlstScalar, ArrayImpl: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1>> Array<Item, ArrayImpl, 1>

where Item::Real: Float,

pub fn inner<ArrayImplOther: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1>>( &self, other: Array<Item, ArrayImplOther, 1>, ) -> Item

Compute the inner product between two vectors.

The inner product takes the complex conjugate of the other argument.

pub fn norm_inf(self) -> <Item as RlstScalar>::Real

Compute the maximum (or inf) norm of a vector.

pub fn norm_1(self) -> <Item as RlstScalar>::Real

Compute the 1-norm of a vector.

pub fn norm_2(self) -> <Item as RlstScalar>::Real

Compute the 2-norm of a vector.

pub fn cross<ArrayImplOther: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1>, ArrayImplRes: UnsafeRandomAccessByValue<1, Item = Item> + UnsafeRandomAccessMut<1, Item = Item> + UnsafeRandomAccessByRef<1, Item = Item> + Shape<1>>( &self, other: Array<Item, ArrayImplOther, 1>, res: Array<Item, ArrayImplRes, 1>, )

Compute the cross product with vector other and store into res.

impl<Item, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + Stride<2> + RawAccessMut<Item = Item>> Array<Item, ArrayImpl, 2>

where Item: MatrixSvd + RlstScalar,

pub fn norm_2_alloc(self) -> RlstResult<<Item as RlstScalar>::Real>

Compute the 2-norm of a matrix.

This method allocates temporary memory during execution.

impl<Item: RlstScalar, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2>> Array<Item, ArrayImpl, 2>

pub fn norm_fro(self) -> Item::Real

Compute the Frobenius-norm of a matrix.

pub fn norm_inf(self) -> Item::Real

Compute the inf-norm of a matrix.

pub fn norm_1(self) -> Item::Real

Compute the 1-norm of a matrix.

impl<Item: RlstScalar, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + Stride<2> + RawAccessMut<Item = Item>> Array<Item, ArrayImpl, 2>

where LuDecomposition<Item, ArrayImpl>: MatrixLuDecomposition<Item = Item, ArrayImpl = ArrayImpl>,

pub fn into_solve_vec<ArrayImplMut: RawAccessMut<Item = Item> + UnsafeRandomAccessByValue<1, Item = Item> + UnsafeRandomAccessMut<1, Item = Item> + Shape<1> + Stride<1>>( self, trans: TransMode, rhs: Array<Item, ArrayImplMut, 1>, ) -> RlstResult<Array<Item, ArrayImplMut, 1>>

Solve a linear system with a single right-hand side.

The array is overwritten with the LU Decomposition and the right-hand side is overwritten with the solution. The solution is also returned.

pub fn into_det<ArrayImplMut: RawAccessMut<Item = Item> + UnsafeRandomAccessByValue<2, Item = Item> + UnsafeRandomAccessMut<2, Item = Item> + Shape<2> + Stride<2>>( self, ) -> RlstResult<Item>

Compute the determinant of a matrix.

The array is overwritten by the determinant computation.

pub fn into_solve_mat<ArrayImplMut: RawAccessMut<Item = Item> + UnsafeRandomAccessByValue<2, Item = Item> + UnsafeRandomAccessMut<2, Item = Item> + Shape<2> + Stride<2>>( self, trans: TransMode, rhs: Array<Item, ArrayImplMut, 2>, ) -> RlstResult<Array<Item, ArrayImplMut, 2>>

Solve a linear system with multiple right-hand sides.

The array is overwritten with the LU Decomposition and the right-hand side is overwritten with the solution. The solution is also returned.

impl<Item: RlstNum, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn cast<T: RlstNum>( self, ) -> Array<T, ArrayCast<Item, T, ArrayImpl, NDIM>, NDIM>

Cast array to type T.

impl<Item: RlstScalar, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn conj(self) -> Array<Item, ArrayConjugate<Item, ArrayImpl, NDIM>, NDIM>

Conjugate

impl<Item: RlstNum, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn scalar_mul( self, other: Item, ) -> Array<Item, ArrayScalarMult<Item, ArrayImpl, NDIM>, NDIM>

Multiplication by a scalar

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = f32> + Shape<NDIM>, const NDIM: usize> Array<f32, ArrayImpl, NDIM>

pub fn to_complex( self, ) -> Array<c32, ArrayToComplex<c32, ArrayImpl, NDIM>, NDIM>

Convert to complex

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = f64> + Shape<NDIM>, const NDIM: usize> Array<f64, ArrayImpl, NDIM>

pub fn to_complex( self, ) -> Array<c64, ArrayToComplex<c64, ArrayImpl, NDIM>, NDIM>

Convert to complex

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = c64> + Shape<NDIM>, const NDIM: usize> Array<c64, ArrayImpl, NDIM>

pub fn to_complex(self) -> Self

Convert to complex

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = c32> + Shape<NDIM>, const NDIM: usize> Array<c32, ArrayImpl, NDIM>

pub fn to_complex(self) -> Self

Convert to complex

impl<Item: RlstNum, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn permute_axes( self, permutation: [usize; NDIM], ) -> Array<Item, ArrayTranspose<Item, ArrayImpl, NDIM>, NDIM>

Permute axes of an array

pub fn transpose( self, ) -> Array<Item, ArrayTranspose<Item, ArrayImpl, NDIM>, NDIM>

Transpose an array

impl<Item: RlstScalar + RandScalar, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + UnsafeRandomAccessMut<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

where StandardNormal: Distribution<<Item as RlstScalar>::Real>, Standard: Distribution<<Item as RlstScalar>::Real>,

pub fn fill_from_standard_normal<R: Rng>(&mut self, rng: &mut R)

Fill an array with normally distributed random numbers.

pub fn fill_from_equally_distributed<R: Rng>(&mut self, rng: &mut R)

Fill an array with equally distributed random numbers.

pub fn fill_from_seed_equally_distributed(&mut self, seed: usize)

Fill with equally distributed numbers using a given seed.

pub fn fill_from_seed_normally_distributed(&mut self, seed: usize)

Fill with normally distributed numbers using a given seed.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<ADIM, Item = Item> + Shape<ADIM>, const ADIM: usize> Array<Item, ArrayImpl, ADIM>

pub fn slice<const NDIM: usize>( self, axis: usize, index: usize, ) -> Array<Item, ArraySlice<Item, ArrayImpl, ADIM, NDIM>, NDIM>

where NumberType<ADIM>: IsGreaterByOne<NDIM>, NumberType<NDIM>: IsGreaterZero,

Create a slice from a given array.

Consider an array arr with shape [a0, a1, a2, a3, ...]. The function call arr.slice(2, 3) returns a one dimension smaller array indexed by [a0, a1, 3, a3, ...]. Hence, the dimension 2 has been fixed to always have the value 3.

Examples

If arr is a matrix then the first column of the matrix is obtained from arr.slice(1, 0), while the third row of the matrix is obtained from arr.slice(0, 2).

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn into_subview( self, offset: [usize; NDIM], shape: [usize; NDIM], ) -> Array<Item, ArraySubView<Item, ArrayImpl, NDIM>, NDIM>

Move the array into a subview specified by an offset and shape of the subview.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn view(&self) -> Array<Item, ArrayView<'_, Item, ArrayImpl, NDIM>, NDIM>

Return a view onto the array.

pub fn view_flat( &self, ) -> Array<Item, ArrayFlatView<'_, Item, ArrayImpl, NDIM>, 1>

Return a flattened 1d view onto the array. The view is flattened in column-major order.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + UnsafeRandomAccessMut<NDIM, Item = Item>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn view_mut( &mut self, ) -> Array<Item, ArrayViewMut<'_, Item, ArrayImpl, NDIM>, NDIM>

Return a mutable view onto the array.

pub fn view_flat_mut( &mut self, ) -> Array<Item, ArrayFlatViewMut<'_, Item, ArrayImpl, NDIM>, 1>

Return a flattened 1d view onto the array. The view is flattened in column-major order.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Array<Item, ArrayImpl, NDIM>

pub fn new(arr: ArrayImpl) -> Self

Instantiate a new array from an ArrayImpl structure.

pub fn number_of_elements(&self) -> usize

Return the number of elements in the array.

impl<Item: RlstBase, const NDIM: usize> Array<Item, BaseArray<Item, VectorContainer<Item>, NDIM>, NDIM>

pub fn from_shape(shape: [usize; NDIM]) -> Self

Create a new heap allocated array from a given shape.

pub fn from_shape_with_stride( shape: [usize; NDIM], stride: [usize; NDIM], ) -> Self

Create a new heap allocated array from a given shape.

impl<'a, Item: RlstBase, const NDIM: usize> Array<Item, BaseArray<Item, SliceContainer<'a, Item>, NDIM>, NDIM>

pub fn from_shape(slice: &'a [Item], shape: [usize; NDIM]) -> Self

Create a new array from a slice with a given shape.

The stride is automatically assumed to be column major.

pub fn from_shape_with_stride( slice: &'a [Item], shape: [usize; NDIM], stride: [usize; NDIM], ) -> Self

Create a new array from a slice with a given shape and stride.

impl<'a, Item: RlstBase, const NDIM: usize> Array<Item, BaseArray<Item, SliceContainerMut<'a, Item>, NDIM>, NDIM>

pub fn from_shape(slice: &'a mut [Item], shape: [usize; NDIM]) -> Self

Create a new array from a slice with a given shape.

The stride is automatically assumed to be column major.

pub fn from_shape_with_stride( slice: &'a mut [Item], shape: [usize; NDIM], stride: [usize; NDIM], ) -> Self

Create a new array from a slice with a given shape and stride.

Trait Implementations

impl<Item: RlstNum, ArrayImpl1: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, ArrayImpl2: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Add<Array<Item, ArrayImpl2, NDIM>> for Array<Item, ArrayImpl1, NDIM>

type Output = Array<Item, ArrayAddition<Item, ArrayImpl1, ArrayImpl2, NDIM>, NDIM>

The resulting type after applying the + operator.

fn add(self, rhs: Array<Item, ArrayImpl2, NDIM>) -> Self::Output

Performs the + operation.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + ChunkedAccess<N, Item = Item>, const NDIM: usize, const N: usize> ChunkedAccess<N> for Array<Item, ArrayImpl, NDIM>

type Item = Item

Item type

fn get_chunk(&self, chunk_index: usize) -> Option<DataChunk<Self::Item, N>>

Get chunk

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Debug for Array<Item, ArrayImpl, NDIM>

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

Formats the value using the given formatter.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> DefaultIterator for Array<Item, ArrayImpl, NDIM>

type Item = Item

Item type

type Iter<'a> = ArrayDefaultIterator<'a, Item, ArrayImpl, NDIM> where Self: 'a

Iterator type

fn iter(&self) -> Self::Iter<'_>

Get iterator

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + UnsafeRandomAccessMut<NDIM, Item = Item>, const NDIM: usize> DefaultIteratorMut for Array<Item, ArrayImpl, NDIM>

type Item = Item

Item type

type IterMut<'a> = ArrayDefaultIteratorMut<'a, Item, ArrayImpl, NDIM> where Self: 'a

Iterator

fn iter_mut(&mut self) -> Self::IterMut<'_>

Get mutable iterator

impl<Item: RlstNum, ArrayImpl1: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, ArrayImpl2: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Div<Array<Item, ArrayImpl2, NDIM>> for Array<Item, ArrayImpl1, NDIM>

type Output = Array<Item, CmpWiseDivision<Item, ArrayImpl1, ArrayImpl2, NDIM>, NDIM>

The resulting type after applying the / operator.

fn div(self, rhs: Array<Item, ArrayImpl2, NDIM>) -> Self::Output

Performs the / operation.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + UnsafeRandomAccessByRef<NDIM, Item = Item>, const NDIM: usize> Index<[usize; NDIM]> for Array<Item, ArrayImpl, NDIM>

type Output = Item

The returned type after indexing.

fn index(&self, index: [usize; NDIM]) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + UnsafeRandomAccessByRef<NDIM, Item = Item> + UnsafeRandomAccessMut<NDIM, Item = Item>, const NDIM: usize> IndexMut<[usize; NDIM]> for Array<Item, ArrayImpl, NDIM>

fn index_mut(&mut self, index: [usize; NDIM]) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = c32> + Shape<NDIM>, const NDIM: usize> Mul<Array<Complex<f32>, ArrayImpl, NDIM>> for c32

type Output = Array<Complex<f32>, ArrayScalarMult<Complex<f32>, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<c32, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = c64> + Shape<NDIM>, const NDIM: usize> Mul<Array<Complex<f64>, ArrayImpl, NDIM>> for c64

type Output = Array<Complex<f64>, ArrayScalarMult<Complex<f64>, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<c64, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<Item: RlstNum, ArrayImpl1: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, ArrayImpl2: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Mul<Array<Item, ArrayImpl2, NDIM>> for Array<Item, ArrayImpl1, NDIM>

type Output = Array<Item, CmpWiseProduct<Item, ArrayImpl1, ArrayImpl2, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<Item, ArrayImpl2, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = f32> + Shape<NDIM>, const NDIM: usize> Mul<Array<f32, ArrayImpl, NDIM>> for f32

type Output = Array<f32, ArrayScalarMult<f32, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<f32, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = f64> + Shape<NDIM>, const NDIM: usize> Mul<Array<f64, ArrayImpl, NDIM>> for f64

type Output = Array<f64, ArrayScalarMult<f64, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<f64, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = i16> + Shape<NDIM>, const NDIM: usize> Mul<Array<i16, ArrayImpl, NDIM>> for i16

type Output = Array<i16, ArrayScalarMult<i16, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<i16, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = i32> + Shape<NDIM>, const NDIM: usize> Mul<Array<i32, ArrayImpl, NDIM>> for i32

type Output = Array<i32, ArrayScalarMult<i32, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<i32, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = i64> + Shape<NDIM>, const NDIM: usize> Mul<Array<i64, ArrayImpl, NDIM>> for i64

type Output = Array<i64, ArrayScalarMult<i64, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<i64, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = i8> + Shape<NDIM>, const NDIM: usize> Mul<Array<i8, ArrayImpl, NDIM>> for i8

type Output = Array<i8, ArrayScalarMult<i8, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<i8, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = u16> + Shape<NDIM>, const NDIM: usize> Mul<Array<u16, ArrayImpl, NDIM>> for u16

type Output = Array<u16, ArrayScalarMult<u16, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<u16, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = u32> + Shape<NDIM>, const NDIM: usize> Mul<Array<u32, ArrayImpl, NDIM>> for u32

type Output = Array<u32, ArrayScalarMult<u32, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<u32, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = u64> + Shape<NDIM>, const NDIM: usize> Mul<Array<u64, ArrayImpl, NDIM>> for u64

type Output = Array<u64, ArrayScalarMult<u64, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<u64, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = u8> + Shape<NDIM>, const NDIM: usize> Mul<Array<u8, ArrayImpl, NDIM>> for u8

type Output = Array<u8, ArrayScalarMult<u8, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<u8, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = usize> + Shape<NDIM>, const NDIM: usize> Mul<Array<usize, ArrayImpl, NDIM>> for usize

type Output = Array<usize, ArrayScalarMult<usize, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<usize, ArrayImpl, NDIM>) -> Self::Output

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = c32> + Shape<NDIM>, const NDIM: usize> Mul<Complex<f32>> for Array<c32, ArrayImpl, NDIM>

type Output = Array<Complex<f32>, ArrayScalarMult<Complex<f32>, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = c64> + Shape<NDIM>, const NDIM: usize> Mul<Complex<f64>> for Array<c64, ArrayImpl, NDIM>

type Output = Array<Complex<f64>, ArrayScalarMult<Complex<f64>, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = f32> + Shape<NDIM>, const NDIM: usize> Mul<f32> for Array<f32, ArrayImpl, NDIM>

type Output = Array<f32, ArrayScalarMult<f32, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = f64> + Shape<NDIM>, const NDIM: usize> Mul<f64> for Array<f64, ArrayImpl, NDIM>

type Output = Array<f64, ArrayScalarMult<f64, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = i16> + Shape<NDIM>, const NDIM: usize> Mul<i16> for Array<i16, ArrayImpl, NDIM>

type Output = Array<i16, ArrayScalarMult<i16, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = i32> + Shape<NDIM>, const NDIM: usize> Mul<i32> for Array<i32, ArrayImpl, NDIM>

type Output = Array<i32, ArrayScalarMult<i32, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = i64> + Shape<NDIM>, const NDIM: usize> Mul<i64> for Array<i64, ArrayImpl, NDIM>

type Output = Array<i64, ArrayScalarMult<i64, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = i8> + Shape<NDIM>, const NDIM: usize> Mul<i8> for Array<i8, ArrayImpl, NDIM>

type Output = Array<i8, ArrayScalarMult<i8, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = u16> + Shape<NDIM>, const NDIM: usize> Mul<u16> for Array<u16, ArrayImpl, NDIM>

type Output = Array<u16, ArrayScalarMult<u16, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = u32> + Shape<NDIM>, const NDIM: usize> Mul<u32> for Array<u32, ArrayImpl, NDIM>

type Output = Array<u32, ArrayScalarMult<u32, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = u64> + Shape<NDIM>, const NDIM: usize> Mul<u64> for Array<u64, ArrayImpl, NDIM>

type Output = Array<u64, ArrayScalarMult<u64, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = u8> + Shape<NDIM>, const NDIM: usize> Mul<u8> for Array<u8, ArrayImpl, NDIM>

type Output = Array<u8, ArrayScalarMult<u8, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = usize> + Shape<NDIM>, const NDIM: usize> Mul<usize> for Array<usize, ArrayImpl, NDIM>

type Output = Array<usize, ArrayScalarMult<usize, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Item: RlstScalar + Gemm, ArrayImpl: UnsafeRandomAccessByValue<1, Item = Item> + UnsafeRandomAccessMut<1, Item = Item> + Shape<1> + Stride<1> + RawAccessMut<Item = Item>, ArrayImplFirst: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1> + Stride<1> + RawAccess<Item = Item>, ArrayImplSecond: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + Stride<2> + RawAccess<Item = Item>> MultInto<Array<Item, ArrayImplFirst, 1>, Array<Item, ArrayImplSecond, 2>> for Array<Item, ArrayImpl, 1>

type Item = Item

Item type

fn mult_into( self, transa: TransMode, transb: TransMode, alpha: Item, arr_a: Array<Item, ArrayImplFirst, 1>, arr_b: Array<Item, ArrayImplSecond, 2>, beta: Item, ) -> Self

Multiply into

fn simple_mult_into(self, arr_a: First, arr_b: Second) -> Self

where Self: Sized,

Multiply First * Second and sum into Self

impl<Item: RlstScalar + Gemm, ArrayImpl: UnsafeRandomAccessByValue<1, Item = Item> + UnsafeRandomAccessMut<1, Item = Item> + Shape<1> + Stride<1> + RawAccessMut<Item = Item>, ArrayImplFirst: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + Stride<2> + RawAccess<Item = Item>, ArrayImplSecond: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1> + Stride<1> + RawAccess<Item = Item>> MultInto<Array<Item, ArrayImplFirst, 2>, Array<Item, ArrayImplSecond, 1>> for Array<Item, ArrayImpl, 1>

type Item = Item

Item type

fn mult_into( self, transa: TransMode, transb: TransMode, alpha: Item, arr_a: Array<Item, ArrayImplFirst, 2>, arr_b: Array<Item, ArrayImplSecond, 1>, beta: Item, ) -> Self

Multiply into

fn simple_mult_into(self, arr_a: First, arr_b: Second) -> Self

where Self: Sized,

Multiply First * Second and sum into Self

impl<Item: RlstScalar, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + UnsafeRandomAccessMut<2, Item = Item> + Shape<2> + Stride<2> + RawAccessMut<Item = Item>, ArrayImplFirst: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + Stride<2> + RawAccess<Item = Item>, ArrayImplSecond: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + Stride<2> + RawAccess<Item = Item>> MultInto<Array<Item, ArrayImplFirst, 2>, Array<Item, ArrayImplSecond, 2>> for Array<Item, ArrayImpl, 2>

type Item = Item

Item type

fn mult_into( self, transa: TransMode, transb: TransMode, alpha: Item, arr_a: Array<Item, ArrayImplFirst, 2>, arr_b: Array<Item, ArrayImplSecond, 2>, beta: Item, ) -> Self

Multiply into

fn simple_mult_into(self, arr_a: First, arr_b: Second) -> Self

where Self: Sized,

Multiply First * Second and sum into Self

impl<Item: RlstScalar + Gemm, ArrayImpl: UnsafeRandomAccessByValue<1, Item = Item> + UnsafeRandomAccessMut<1, Item = Item> + Shape<1> + Stride<1> + RawAccessMut<Item = Item> + ResizeInPlace<1>, ArrayImplFirst: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1> + Stride<1> + RawAccess<Item = Item>, ArrayImplSecond: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + Stride<2> + RawAccess<Item = Item>> MultIntoResize<Array<Item, ArrayImplFirst, 1>, Array<Item, ArrayImplSecond, 2>> for Array<Item, ArrayImpl, 1>

type Item = Item

Item type

fn mult_into_resize( self, transa: TransMode, transb: TransMode, alpha: Item, arr_a: Array<Item, ArrayImplFirst, 1>, arr_b: Array<Item, ArrayImplSecond, 2>, beta: Item, ) -> Self

Multiply into with resize

fn simple_mult_into_resize(self, arr_a: First, arr_b: Second) -> Self

where Self: Sized,

Multiply First * Second and sum into Self. Allow to resize Self if necessary

impl<Item: RlstScalar + Gemm, ArrayImpl: UnsafeRandomAccessByValue<1, Item = Item> + UnsafeRandomAccessMut<1, Item = Item> + Shape<1> + Stride<1> + RawAccessMut<Item = Item> + ResizeInPlace<1>, ArrayImplFirst: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + Stride<2> + RawAccess<Item = Item>, ArrayImplSecond: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1> + Stride<1> + RawAccess<Item = Item>> MultIntoResize<Array<Item, ArrayImplFirst, 2>, Array<Item, ArrayImplSecond, 1>> for Array<Item, ArrayImpl, 1>

type Item = Item

Item type

fn mult_into_resize( self, transa: TransMode, transb: TransMode, alpha: Item, arr_a: Array<Item, ArrayImplFirst, 2>, arr_b: Array<Item, ArrayImplSecond, 1>, beta: Item, ) -> Self

Multiply into with resize

fn simple_mult_into_resize(self, arr_a: First, arr_b: Second) -> Self

where Self: Sized,

Multiply First * Second and sum into Self. Allow to resize Self if necessary

impl<Item: RlstScalar + Gemm, ArrayImpl: UnsafeRandomAccessByValue<2, Item = Item> + UnsafeRandomAccessMut<2, Item = Item> + Shape<2> + Stride<2> + RawAccessMut<Item = Item> + ResizeInPlace<2>, ArrayImplFirst: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + Stride<2> + RawAccess<Item = Item>, ArrayImplSecond: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2> + Stride<2> + RawAccess<Item = Item>> MultIntoResize<Array<Item, ArrayImplFirst, 2>, Array<Item, ArrayImplSecond, 2>> for Array<Item, ArrayImpl, 2>

MultIntoResize

type Item = Item

Item type

fn mult_into_resize( self, transa: TransMode, transb: TransMode, alpha: Item, arr_a: Array<Item, ArrayImplFirst, 2>, arr_b: Array<Item, ArrayImplSecond, 2>, beta: Item, ) -> Self

Multiply into with resize

fn simple_mult_into_resize(self, arr_a: First, arr_b: Second) -> Self

where Self: Sized,

Multiply First * Second and sum into Self. Allow to resize Self if necessary

impl<Item: RlstScalar, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Neg for Array<Item, ArrayImpl, NDIM>

type Output = Array<Item, ArrayScalarMult<Item, ArrayImpl, NDIM>, NDIM>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> NumberOfElements for Array<Item, ArrayImpl, NDIM>

fn number_of_elements(&self) -> usize

Return the number of elements.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + RawAccess<Item = Item>, const NDIM: usize> RawAccess for Array<Item, ArrayImpl, NDIM>

type Item = Item

Item type

fn data(&self) -> &[Self::Item]

Get a slice of the whole data.

fn buff_ptr(&self) -> *const Self::Item

Return a pointer to the start of the underlying buffer.

fn offset(&self) -> usize

Offset of beginning of data from start ptr.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + RawAccessMut<Item = Item>, const NDIM: usize> RawAccessMut for Array<Item, ArrayImpl, NDIM>

fn data_mut(&mut self) -> &mut [Self::Item]

Get a mutable slice of the whole data.

fn buff_ptr_mut(&mut self) -> *mut Self::Item

Return a pointer to the start of the underlying buffer.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + ResizeInPlace<NDIM>, const NDIM: usize> ResizeInPlace<NDIM> for Array<Item, ArrayImpl, NDIM>

fn resize_in_place(&mut self, shape: [usize; NDIM])

Resize an operator in place

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Shape<NDIM> for Array<Item, ArrayImpl, NDIM>

fn shape(&self) -> [usize; NDIM]

Return the shape of the object.

fn is_empty(&self) -> bool

Return true if a dimension is 0.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + Stride<NDIM>, const NDIM: usize> Stride<NDIM> for Array<Item, ArrayImpl, NDIM>

fn stride(&self) -> [usize; NDIM]

Return the stride of the object.

impl<Item: RlstNum, ArrayImpl1: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, ArrayImpl2: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> Sub<Array<Item, ArrayImpl2, NDIM>> for Array<Item, ArrayImpl1, NDIM>

type Output = Array<Item, ArraySubtraction<Item, ArrayImpl1, ArrayImpl2, NDIM>, NDIM>

The resulting type after applying the - operator.

fn sub(self, rhs: Array<Item, ArrayImpl2, NDIM>) -> Self::Output

Performs the - operation.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + UnsafeRandomAccessByRef<NDIM, Item = Item>, const NDIM: usize> UnsafeRandomAccessByRef<NDIM> for Array<Item, ArrayImpl, NDIM>

type Item = Item

Item type

unsafe fn get_unchecked(&self, multi_index: [usize; NDIM]) -> &Self::Item

Return a mutable reference to the element at position determined by multi_index.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>, const NDIM: usize> UnsafeRandomAccessByValue<NDIM> for Array<Item, ArrayImpl, NDIM>

type Item = Item

Item type

unsafe fn get_value_unchecked(&self, multi_index: [usize; NDIM]) -> Self::Item

Return the element at position determined by multi_index.

impl<Item: RlstBase, ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM> + UnsafeRandomAccessMut<NDIM, Item = Item>, const NDIM: usize> UnsafeRandomAccessMut<NDIM> for Array<Item, ArrayImpl, NDIM>

type Item = Item

Item type

unsafe fn get_unchecked_mut( &mut self, multi_index: [usize; NDIM], ) -> &mut Self::Item

Return a mutable reference to the element at position determined by multi_index.