Struct Array 

pub struct Array<ArrayImpl, const NDIM: usize>(/* private fields */);

Public array wrapper around a storage, view, or lazy-expression implementation.

NDIM is the number of axes. The implementation determines whether data is owned or borrowed, contiguous or strided, mutable, or computed lazily. Most users construct one of the aliases such as DynArray rather than naming the implementation type.

Implementations

impl<ArrayImpl, const ADIM: usize> Array<ArrayImpl, ADIM>

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

where NumberType<ADIM>: IsSmallerByOne<NDIM>,

Insert a singleton axis at the front or back.

Despite the historical method name, the inserted axis has extent one, not zero. The view owns its array operand and does not allocate or copy element storage.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

pub fn with_container_type<TypeHint: ContainerTypeRepr + ArrayFromContainerType + RowMajorArrayFromContainerType>( self, ) -> Array<WithEvalType<ArrayImpl, TypeHint, NDIM>, NDIM>

Coerce the array to a specific item type and dimension.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

pub fn into_flat(self) -> Array<ArrayFlatView<ArrayImpl, NDIM>, 1>

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

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

pub fn into_shared(self) -> ArraySharedRef<ArrayImpl, NDIM>

Move the array into a cloneable, single-threaded shared owner.

Use borrow and borrow_mut to access the underlying array.

The rational of this function is to obtain a cloneable shared reference structure to the original array with runtime borrow checking when compile-time checking is not sufficient.

This function is not thread-safe. For a thread-safe variant use Array::into_shared_atomic.

pub fn into_shared_atomic(self) -> ArrayAtomicSharedRef<ArrayImpl, NDIM>

Move the array into a cloneable, thread-safe shared owner. Use borrow and borrow_mut to access the underlying array.

The rational of this function is to obtain a cloneable shared reference structure to the original array with runtime borrow checking when compile-time checking is not sufficient.

This function is thread-safe. For a slightly faster non thread-safe variant use Array::into_shared.

impl<Item: Copy + Default> Array<ScalarArrayImpl<Item>, 0>

pub fn from_scalar(value: Item) -> Self

Construct a zero-dimensional array owning value.

pub fn into_scalar(self) -> Item

Consume the array and return its scalar.

pub fn scalar(&self) -> &Item

Borrow the scalar.

pub fn scalar_mut(&mut self) -> &mut Item

Mutably borrow the scalar.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

pub fn new(arr: ArrayImpl) -> Self

Wrap an array implementation.

The implementation determines the supported ranks and access operations. ZeroDimArray provides scalar-only storage for rank zero.

pub fn imp(&self) -> &ArrayImpl

Return a reference to the implementation.

pub fn imp_mut(&mut self) -> &mut ArrayImpl

Return a mutable reference to the implementation.

pub fn into_imp(self) -> ArrayImpl

Extract the inner implementation.

pub fn r(&self) -> Array<ArrayRef<'_, ArrayImpl, NDIM>, NDIM>

Wrap a shared borrow in an array value.

This is useful with operators and views that consume their operands. The returned value does not copy data and cannot outlive self.

pub fn r_mut(&mut self) -> Array<ArrayRefMut<'_, ArrayImpl, NDIM>, NDIM>

Wrap an exclusive borrow in an array value.

The returned value does not copy data and cannot outlive the mutable borrow of self.

impl<ArrayImpl: Shape<NDIM>, const NDIM: usize> Array<ArrayImpl, NDIM>

pub fn number_of_elements(&self) -> usize

Return the number of elements in the array.

impl<Item: Copy + Default, const NDIM: usize> Array<BaseArray<VectorContainer<Item>, NDIM>, NDIM>

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

Allocate a default-initialized column-major array with shape.

A zero extent is permitted and produces an empty array.

pub fn from_shape_and_vec(shape: [usize; NDIM], data: Vec<Item>) -> Self

Create a column-major array from data without copying the vector.

Flat element i corresponds to the column-major logical index i.

Panics

Panics if data.len() differs from the product of shape.

impl<Item: Copy + Default, const NDIM: usize, const ALIGNMENT: usize> Array<BaseArray<AlignedVectorContainer<Item, ALIGNMENT>, NDIM>, NDIM>

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

Allocate a default-initialized column-major array with shape and ALIGNMENT.

ALIGNMENT must satisfy the allocator requirements documented by aligned-vec.

pub fn from_shape_and_avec( shape: [usize; NDIM], data: AVec<Item, ConstAlign<ALIGNMENT>>, ) -> Self

Create an aligned column-major array from an aligned vector without copying it.

Panics

Panics if data.len() differs from the product of shape.

impl<Item: Copy + Default> Array<BaseArray<VectorContainer<Item>, 2>, 2>

pub fn from_iter_aij<Iter: Iterator<Item = ([usize; 2], Item)>>( shape: [usize; 2], iter: Iter, ) -> DynArray<Item, 2>

Create a new dense matrix with shape shape filled with values from the iterator iter.

impl<Item: Copy + Default, const ALIGNMENT: usize> Array<BaseArray<AlignedVectorContainer<Item, ALIGNMENT>, 2>, 2>

pub fn from_iter_aij<Iter: Iterator<Item = ([usize; 2], Item)>>( shape: [usize; 2], iter: Iter, ) -> AlignedDynArray<Item, 2, ALIGNMENT>

Create a new dense matrix with shape shape filled with values from the iterator iter.

impl<Item: Copy + Default, const NDIM: usize> Array<StridedBaseArray<VectorContainer<Item>, NDIM>, NDIM>

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

Allocate an array with an explicit physical stride.

The allocation spans through the greatest reachable storage offset. Strides must map every logical index to a distinct storage element.

Panics

Panics if two computed logical offsets are equal. Shape/stride arithmetic uses ordinary usize operations, so callers must provide metadata whose products, offsets, and storage span are representable.

impl<Item: Copy + Default, const NDIM: usize> Array<StridedBaseArray<VectorContainer<Item>, NDIM>, NDIM>

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

Create a new heap allocated row-major array.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM>,

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

Return the shape of an array.

Traits:

• Shape

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM>,

pub fn len(&self) -> usize

Return the length of an array.

For more than one dimension the length is the number of elements.

Traits:

• Shape

pub fn is_empty(&self) -> bool

Return true if the array is empty.

This is equivalent to at least one dimension being zero.

Traits:

• Shape

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandomAccessByValue<NDIM>,

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

Get an element by value.

Safety

multi_index must be in range.

Traits

• UnsafeRandomAccessByValue

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandomAccessByRef<NDIM>,

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

Get an element by reference.

Safety

multi_index must be in range.

Traits

• UnsafeRandomAccessByRef

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandomAccessMut<NDIM>,

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

Get an element by mutable reference.

Safety

multi_index must be in range.

Traits

• UnsafeRandomAccessMut

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: RandomAccessByValue<NDIM>,

pub fn get_value(&self, multi_index: [usize; NDIM]) -> Option<ArrayImpl::Item>

Get an element by value.

Traits

• RandomAccessByValue

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: RandomAccessByRef<NDIM>,

pub fn get(&self, multi_index: [usize; NDIM]) -> Option<&ArrayImpl::Item>

Get an element by reference.

Traits

• RandomAccessByRef

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: RandomAccessMut<NDIM>,

pub fn get_mut( &mut self, multi_index: [usize; NDIM], ) -> Option<&mut ArrayImpl::Item>

Get an element by mutable reference.

Traits

• RandomAccessMut

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: RawAccess,

pub fn data(&self) -> Option<&[ArrayImpl::Item]>

Return the complete backing storage when it is exposed as one contiguous slice.

The slice follows physical storage order, which may differ from logical column-major iteration for a row-major array. Views and lazy expressions can return None.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: RawAccessMut,

pub fn data_mut(&mut self) -> Option<&mut [ArrayImpl::Item]>

Return the complete mutable backing storage when exposed as one contiguous slice.

The slice follows physical storage order. Views and lazy expressions can return None.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: Stride<NDIM>,

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

Return the stride.

Traits

• Stride

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: Stride<NDIM> + Shape<NDIM>,

pub fn memory_layout(&self) -> MemoryLayout

Return the memory layout

The possible memory layouts are defined in MemoryLayout.

pub fn is_contiguous(&self) -> bool

Return true of the memory layout is contiguous, otherwise false.

A memory layout is contiguous if it is either row or column major.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: ResizeInPlace<NDIM>,

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

Resize the array to the new shape.

The content of the array will be lost upon resizing.

Traits

• ResizeInPlace

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

where Item: Copy + Default,

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

Create a new array from slice with a given shape.

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

where Item: Copy + Default,

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

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

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

where Item: Copy + Default,

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

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

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

where Item: Copy + Default,

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

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

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

where Item: Copy + Default,

pub fn new_from<ArrayImpl>(arr: &Array<ArrayImpl, NDIM>) -> Self

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM>,

Create a new array and fill with values from arr.

impl<Item, const NDIM: usize> Array<StridedBaseArray<VectorContainer<Item>, NDIM>, NDIM>

where Item: Copy + Default,

pub fn new_from<ArrayImpl>( stride: [usize; NDIM], arr: &Array<ArrayImpl, NDIM>, ) -> Self

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM>,

Create a new strided array with stride and fill with values from arr.

pub fn row_major_from<ArrayImpl>(arr: &Array<ArrayImpl, NDIM>) -> Self

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM>,

Create a new row-major array from existing array arr.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandom1DAccessByValue + Shape<NDIM>,

pub fn iter_value(&self) -> ArrayDefaultIteratorByValue<'_, ArrayImpl, NDIM>

Iterate through the array by value.

The iterator always proceeds in column-major order.

Traits

• UnsafeRandom1DAccessByValue
• Shape

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandom1DAccessByRef + Shape<NDIM>,

pub fn iter_ref(&self) -> ArrayDefaultIteratorByRef<'_, ArrayImpl, NDIM>

Iterate through the array by reference.

The iterator always proceeds in column-major order.

Traits

• UnsafeRandom1DAccessByRef
• Shape

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeDisjointRandom1DAccessMut + Shape<NDIM>,

pub fn iter_mut(&mut self) -> ArrayDefaultIteratorMut<'_, ArrayImpl, NDIM>

Iterate through the array by mutable reference.

The iterator always proceeds in column-major order.

Traits

• UnsafeDisjointRandom1DAccessMut
• Shape

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>,

pub fn diag_iter_value(&self) -> ArrayDiagIteratorByValue<'_, ArrayImpl, NDIM>

Iterate through the diagonal of the array by value.

Traits

• UnsafeRandomAccessByValue
• Shape

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandomAccessByRef<NDIM, Item = Item> + Shape<NDIM>,

pub fn diag_iter_ref(&self) -> ArrayDiagIteratorByRef<'_, ArrayImpl, NDIM>

Iterate through the diagonal of the array by reference.

Traits

• UnsafeRandomAccessByRef
• Shape

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandomAccessMut<NDIM, Item = Item> + Shape<NDIM>,

pub fn diag_iter_mut(&mut self) -> ArrayDiagIteratorMut<'_, ArrayImpl, NDIM>

Iterate through the diagonal of the array by mutable reference.

Traits

• UnsafeRandomAccessByRef
• Shape

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeDisjointRandom1DAccessMut<Item = Item> + Shape<NDIM>,

pub fn fill_from<ArrayImplOther>(&mut self, other: &Array<ArrayImplOther, NDIM>)

where ArrayImplOther: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM>,

Copy values from another array in logical column-major order.

Panics

Panics if the shapes differ.

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where Const<NDIM>: ToUInt, <Const<NDIM> as ToUInt>::Output: Unsigned + NonZero, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + UnsafeRandomAccessByValue<NDIM, Item = Item> + Shape<NDIM>,

pub fn multislice_iter<const SDIM: usize, const OUTDIM: usize>( &self, axes: [usize; SDIM], ) -> MultisliceIterator<'_, Item, ArrayImpl, NDIM, SDIM, OUTDIM>

where Const<SDIM>: ToUInt, Const<OUTDIM>: ToUInt, <Const<SDIM> as ToUInt>::Output: Unsigned + NonZero, <Const<OUTDIM> as ToUInt>::Output: Unsigned + NonZero, NumberType<SDIM>: IsSmallerThan<NDIM>, PInt<U<OUTDIM>>: Add<PInt<U<SDIM>>, Output = PInt<U<NDIM>>>, PInt<U<NDIM>>: Sub<PInt<U<SDIM>>>,

Create a new multislice iterator.

Given an array arr with dimensions [2, 3, 4, 5]. Calling self.multislice_iter with axes = [0, 2] returns an iterator over values of the type (indices, slice), where indices is a [2; usize] array taking all possible axis indices in axes 0 and 2, and slice is the output of arr.multislice([0, 2], [indices]).

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where Const<NDIM>: ToUInt, <Const<NDIM> as ToUInt>::Output: Unsigned + NonZero, ArrayImpl: UnsafeDisjointRandom1DAccessMut<Item = Item> + UnsafeRandomAccessMut<NDIM, Item = Item> + Shape<NDIM>,

pub fn multislice_iter_mut<const SDIM: usize, const OUTDIM: usize>( &mut self, axes: [usize; SDIM], ) -> MultisliceIteratorMut<'_, Item, ArrayImpl, NDIM, SDIM, OUTDIM>

where Const<SDIM>: ToUInt, Const<OUTDIM>: ToUInt, <Const<SDIM> as ToUInt>::Output: Unsigned + NonZero, <Const<OUTDIM> as ToUInt>::Output: Unsigned + NonZero, NumberType<SDIM>: IsSmallerThan<NDIM>, PInt<U<OUTDIM>>: Add<PInt<U<SDIM>>, Output = PInt<U<NDIM>>>, PInt<U<NDIM>>: Sub<PInt<U<SDIM>>>,

Create a new mutable multislice iterator.

Given an array arr with dimensions [2, 3, 4, 5]. Calling self.multislice_iter_mut with axes = [0, 2] returns an iterator over values of the type (indices, slice), where indices is a [2; usize] array taking all possible axis indices in axes 0 and 2, and slice is the output of arr.multislice([0, 2], [indices]).

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeDisjointRandom1DAccessMut + Shape<NDIM>,

pub fn fill_from_iter<Iter>(&mut self, iter: Iter)

where Iter: Iterator<Item = ArrayImpl::Item>,

Fill elements in logical column-major order from an iterator.

Filling stops when either the array or iterator is exhausted. Existing trailing array elements are unchanged when the iterator is short; excess iterator values are ignored.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: ResizeInPlace<NDIM> + Shape<NDIM> + UnsafeDisjointRandom1DAccessMut,

pub fn fill_from_resize<ArrayImplOther>( &mut self, other: &Array<ArrayImplOther, NDIM>, )

where ArrayImplOther: Shape<NDIM> + UnsafeRandom1DAccessByValue<Item = ArrayImpl::Item>,

Fill from another array and resize if necessary.

This method is especially useful together with empty_array.

#Traits

• UnsafeDisjointRandom1DAccessMut
• Shape

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeDisjointRandom1DAccessMut + Shape<NDIM>,

pub fn fill_with_value(&mut self, value: ArrayImpl::Item)

Fill array with a given value.

Traits

• UnsafeDisjointRandom1DAccessMut
• Shape

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeDisjointRandom1DAccessMut + Shape<NDIM>,

pub fn set_zero(&mut self)

Set the elements of the array to zero.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeDisjointRandom1DAccessMut + UnsafeRandomAccessMut<NDIM> + Shape<NDIM>, ArrayImpl::Item: One,

pub fn set_identity(&mut self)

Set all off-diagonal elements to zero and the diagonal to one.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandomAccessByValue<NDIM> + Shape<NDIM>, ArrayImpl::Item: Sum,

pub fn trace(&self) -> ArrayImpl::Item

Compute the sum of the diagonal values of the array.

Note: The Item type must support the trait std::iter::Sum.

Traits

• UnsafeRandomAccessByValue
• Shape

impl<Item, ArrayImpl> Array<ArrayImpl, 1>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<1>, ArrayImpl::Item: Conj<Output = Item> + Mul<Output = ArrayImpl::Item> + Add<Output = Item>,

pub fn inner<ArrayImplOther>( &self, other: &Array<ArrayImplOther, 1>, ) -> Option<Item>

where ArrayImplOther: UnsafeRandom1DAccessByValue<Item = Item> + Shape<1>,

Compute the inner product of two 1d arrays.

The elements of other are taken as conjugate.

Returns None if the arrays are empty.

Note: The Item type must support the traits Conj, std::iter::Sum and std::ops::Mul.

Traits

• UnsafeRandom1DAccessByValue
• Shape

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM>, Item: Abs, <Item as Abs>::Output: Max<Output = <Item as Abs>::Output>,

pub fn max_abs(&self) -> Option<<Item as Abs>::Output>

Compute the maximum absolute value over all elements.

Note: The item type must support Abs and the output of Abs must support Max.

The function returns None if the array is empty.

Traits

• UnsafeRandom1DAccessByValue
• Shape

impl<Item, ArrayImpl> Array<ArrayImpl, 1>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<1>, Item: Abs, <Item as Abs>::Output: Add<Output = <Item as Abs>::Output>,

pub fn norm_1(&self) -> Option<<Item as Abs>::Output>

Compute the 1-norm of a 1d array.

The function returns None if the array is empty.

Note: The item type must support Abs and the output of Abs must support std::ops::Add.

Traits

• UnsafeRandom1DAccessByValue
• Shape

impl<Item, ArrayImpl> Array<ArrayImpl, 1>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<1>, Item: AbsSquare, <Item as AbsSquare>::Output: Sqrt<Output = <Item as AbsSquare>::Output> + Add<Output = <Item as AbsSquare>::Output>,

pub fn norm_2(&self) -> Option<<Item as AbsSquare>::Output>

Compute the 2-norm of a 1d array.

Note: The item type must support AbsSquare. The output of AbsSquare must support std::ops::Add and Sqrt.

Traits

• UnsafeRandom1DAccessByValue
• Shape

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM>, Item: AbsSquare, <Item as AbsSquare>::Output: Sqrt<Output = <Item as AbsSquare>::Output> + Add<Output = <Item as AbsSquare>::Output> + Copy + Default,

pub fn norm_fro(&self) -> Option<<Item as AbsSquare>::Output>

Compute the Frobenius-Norm of a nd array.

Note: The item type must support AbsSquare. The output of AbsSquare must support std::ops::Add, Sqrt, Copy, and Default.

Traits

• UnsafeRandom1DAccessByValue
• Shape

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandom1DAccessByValue + Shape<NDIM>,

pub fn into_type<T>( self, ) -> Array<ArrayUnaryOperator<ArrayImpl::Item, T, ArrayImpl, fn(ArrayImpl::Item) -> T, NDIM>, NDIM>

where ArrayImpl::Item: Into<T>,

Convert an array into the new item type T.

Note: It is required that ArrayImpl::Item: Into<T>.

Traits

• UnsafeRandom1DAccessByValue
• Shape

impl<ArrayImpl> Array<ArrayImpl, 2>

where ArrayImpl: Shape<2> + UnsafeRandomAccessByValue<2>,

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

Return a column iterator for a 2d array.

Traits

• UnsafeRandomAccessByValue
• Shape

impl<ArrayImpl> Array<ArrayImpl, 2>

where ArrayImpl: Shape<2> + UnsafeRandomAccessMut<2>,

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

Return a mutable column iterator for a 2d array.

Traits

• UnsafeRandomAccessMut
• Shape

impl<ArrayImpl> Array<ArrayImpl, 2>

where ArrayImpl: Shape<2> + UnsafeRandomAccessByValue<2>,

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

Return a row iterator for a 2d array.

Traits

• UnsafeRandomAccessByValue
• Shape

impl<ArrayImpl> Array<ArrayImpl, 2>

where ArrayImpl: Shape<2> + UnsafeRandomAccessByValue<2>,

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

Return a mutable row iterator for a 2d array.

Traits

• UnsafeRandomAccessMut
• Shape

impl<ArrayImpl> Array<ArrayImpl, 2>

where ArrayImpl: UnsafeRandom1DAccessByValue + Shape<2>,

pub fn iter_aij_value( &self, ) -> impl Iterator<Item = ([usize; 2], ArrayImpl::Item)> + '_

Return an iterator of the form (i, j, data).

Here, i is the row, j is the column, and data is the associated element returned by value.

Traits

• UnsafeRandom1DAccessByValue
• Shape

impl<ArrayImpl> Array<ArrayImpl, 2>

where ArrayImpl: UnsafeRandom1DAccessByRef + Shape<2>,

pub fn iter_aij_ref( &self, ) -> impl Iterator<Item = ([usize; 2], &ArrayImpl::Item)> + '_

Return an iterator of the form (i, j, &data).

Here, i is the row, j is the column, and &data is the reference to the associated element.

Traits

• UnsafeRandom1DAccessByRef
• Shape

impl<ArrayImpl> Array<ArrayImpl, 2>

where ArrayImpl: UnsafeDisjointRandom1DAccessMut + Shape<2>,

pub fn iter_aij_mut( &mut self, ) -> impl Iterator<Item = ([usize; 2], &mut ArrayImpl::Item)> + '_

Return an iterator of the form (i, j, &mut data).

Here, i is the row, j is the column, and &data is the mutable reference to the associated element.

Traits

• UnsafeRandom1DAccessByRef
• Shape

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

pub fn cast<Target>(self) -> Array<ArrayCast<Target, ArrayImpl, NDIM>, NDIM>

Cast array to type T.

The cast is done through num::cast::cast and source and target types need to support casting through that function.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

pub fn coerce_dim<const CDIM: usize>( self, ) -> RlstResult<Array<CoerceArray<ArrayImpl, NDIM, CDIM>, CDIM>>

Coerce the array to a specific dimension.

This is useful to coerce from a generic dimension parameter to a specific number of dimensions.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM>,

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

Permute axes of an array.

For a valid permutation, permutation[output_axis] identifies the corresponding source axis. For example, [1, 0, 2] swaps the first two axes.

Panics

Panics if an entry is outside 0..NDIM or if an axis occurs more than once. Every source axis must occur exactly once.

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

Transpose an array.

The transpose of an n-dimensional array reverses the order of the axes.

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where Item: RandScalar + RlstScalar, ArrayImpl: UnsafeDisjointRandom1DAccessMut<Item = Item> + Shape<NDIM>, StandardNormal: Distribution<Item::Real>, StandardUniform: Distribution<Item::Real>,

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

Fill an array with normally distributed random numbers.

Traits

• UnsafeDisjointRandom1DAccessMut
• Shape
• Item: RandScalar + RlstScalar

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

Fill an array with equally distributed random numbers.

Traits

• UnsafeDisjointRandom1DAccessMut
• Shape
• Item: RandScalar + RlstScalar

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

Fill an array with equally distributed random numbers using a given seed.

Traits

• UnsafeDisjointRandom1DAccessMut
• Shape
• Item: RandScalar + RlstScalar

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

Fill an array with normally distributed random numbers using a given seed.

Traits

• UnsafeDisjointRandom1DAccessMut
• Shape
• Item: RandScalar + RlstScalar

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

pub fn reverse_axis( self, axis: usize, ) -> Array<ReverseAxis<ArrayImpl, NDIM>, NDIM>

Return a lazy view with one axis indexed in reverse.

Panics

Panics if axis >= NDIM.

impl<ArrayImpl, const ADIM: usize> Array<ArrayImpl, ADIM>

where ArrayImpl: Shape<ADIM>,

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

where NumberType<ADIM>: IsGreaterByOne<OUTDIM>, NumberType<OUTDIM>: 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).

pub fn multislice<const SDIM: usize, const OUTDIM: usize>( self, axes: [usize; SDIM], indices: [usize; SDIM], ) -> Array<Multislice<ArrayImpl, ADIM, SDIM, OUTDIM>, OUTDIM>

where NumberType<SDIM>: IsSmallerThan<ADIM>, NumberDifference<ADIM, SDIM>: SubtractEqual<OUTDIM>,

Create a multislice from a given array.

A multislice works like Array::slice but allows the slicing along multiple dimensions at the same time. The axes array determines which axes are fixed and the indices array determines the value in each fixed axis. The dimension SDIM is the number of axes along which we slice. The parameter OUTDIM is the number of dimensions after slicing.

impl<ArrayImpl> Array<ArrayImpl, 2>

where ArrayImpl: Shape<2>,

pub fn row(self, row_index: usize) -> Array<ArraySlice<ArrayImpl, 2, 1>, 1>

Return the row with index row_index from a two-dimensional array.

pub fn col(self, col_index: usize) -> Array<ArraySlice<ArrayImpl, 2, 1>, 1>

Return the column with index col_index from a two-dimensional array.

impl<ArrayImpl: Shape<NDIM>, const NDIM: usize> Array<ArrayImpl, NDIM>

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

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

The offset is the starting index of the subview and the shape is the number of indices in each dimension of the subview.

impl<ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

pub fn unary_op<OpItem, OpTarget, Op: Fn(OpItem) -> OpTarget>( self, op: Op, ) -> Array<ArrayUnaryOperator<OpItem, OpTarget, ArrayImpl, Op, NDIM>, NDIM>

Create a new array by applying the unitary operator op to each element of self.

impl<Item: Default + Copy + Mul<Output = Item>, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

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

Multiple the array with a given scalar.

Note: The Item type must support std::ops::Mul.

impl<Item: Conj, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn conj( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Conj>::Output, ArrayImpl, fn(Item) -> <Item as Conj>::Output, NDIM>, NDIM>

Componentwise apply conj to the array.

impl<Item: Abs, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn abs( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Abs>::Output, ArrayImpl, fn(Item) -> <Item as Abs>::Output, NDIM>, NDIM>

Componentwise apply abs to the array.

impl<Item: Square, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn square( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Square>::Output, ArrayImpl, fn(Item) -> <Item as Square>::Output, NDIM>, NDIM>

Componentwise apply square to the array.

impl<Item: AbsSquare, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn abs_square( self, ) -> Array<ArrayUnaryOperator<Item, <Item as AbsSquare>::Output, ArrayImpl, fn(Item) -> <Item as AbsSquare>::Output, NDIM>, NDIM>

Componentwise apply abs_square to the array.

impl<Item: Sqrt, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn sqrt( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Sqrt>::Output, ArrayImpl, fn(Item) -> <Item as Sqrt>::Output, NDIM>, NDIM>

Componentwise apply sqrt to the array.

impl<Item: Exp, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn exp( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Exp>::Output, ArrayImpl, fn(Item) -> <Item as Exp>::Output, NDIM>, NDIM>

Componentwise apply exp to the array.

impl<Item: Ln, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn ln( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Ln>::Output, ArrayImpl, fn(Item) -> <Item as Ln>::Output, NDIM>, NDIM>

Componentwise apply ln to the array.

impl<Item: Recip, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn recip( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Recip>::Output, ArrayImpl, fn(Item) -> <Item as Recip>::Output, NDIM>, NDIM>

Componentwise apply recip to the array.

impl<Item: Sin, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn sin( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Sin>::Output, ArrayImpl, fn(Item) -> <Item as Sin>::Output, NDIM>, NDIM>

Componentwise apply sin to the array.

impl<Item: Cos, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn cos( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Cos>::Output, ArrayImpl, fn(Item) -> <Item as Cos>::Output, NDIM>, NDIM>

Componentwise apply cos to the array.

impl<Item: Tan, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn tan( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Tan>::Output, ArrayImpl, fn(Item) -> <Item as Tan>::Output, NDIM>, NDIM>

Componentwise apply tan to the array.

impl<Item: Asin, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn asin( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Asin>::Output, ArrayImpl, fn(Item) -> <Item as Asin>::Output, NDIM>, NDIM>

Componentwise apply asin to the array.

impl<Item: Acos, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn acos( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Acos>::Output, ArrayImpl, fn(Item) -> <Item as Acos>::Output, NDIM>, NDIM>

Componentwise apply acos to the array.

impl<Item: Atan, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn atan( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Atan>::Output, ArrayImpl, fn(Item) -> <Item as Atan>::Output, NDIM>, NDIM>

Componentwise apply atan to the array.

impl<Item: Sinh, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn sinh( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Sinh>::Output, ArrayImpl, fn(Item) -> <Item as Sinh>::Output, NDIM>, NDIM>

Componentwise apply sinh to the array.

impl<Item: Cosh, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn cosh( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Cosh>::Output, ArrayImpl, fn(Item) -> <Item as Cosh>::Output, NDIM>, NDIM>

Componentwise apply cosh to the array.

impl<Item: Tanh, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn tanh( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Tanh>::Output, ArrayImpl, fn(Item) -> <Item as Tanh>::Output, NDIM>, NDIM>

Componentwise apply tanh to the array.

impl<Item: Asinh, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn asinh( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Asinh>::Output, ArrayImpl, fn(Item) -> <Item as Asinh>::Output, NDIM>, NDIM>

Componentwise apply asinh to the array.

impl<Item: Acosh, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn acosh( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Acosh>::Output, ArrayImpl, fn(Item) -> <Item as Acosh>::Output, NDIM>, NDIM>

Componentwise apply acosh to the array.

impl<Item: Atanh, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>,

pub fn atanh( self, ) -> Array<ArrayUnaryOperator<Item, <Item as Atanh>::Output, ArrayImpl, fn(Item) -> <Item as Atanh>::Output, NDIM>, NDIM>

Componentwise apply atanh to the array.

impl<Item, ArrayImpl> Array<ArrayImpl, 2>

where ArrayImpl: RawAccess<Item = Item> + Stride<2> + Shape<2>, Item: Gemm + Copy + Default + One + Zero,

pub fn dot<ArrayImplOther, const NDIM: usize>( &self, other: &Array<ArrayImplOther, NDIM>, ) -> DynArray<Item, NDIM>

where ArrayImplOther: RawAccess<Item = Item> + Shape<NDIM> + Stride<NDIM>,

Compute the matrix-matrix product of self with other.

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandomAccessMut<NDIM, Item = Item>, Item: Copy,

pub unsafe fn swap_unsafe(&mut self, pos1: [usize; NDIM], pos2: [usize; NDIM])

Swap the elements at the positions pos1 and pos2

Safety

pos1 and pos2 must not be out of bounds.

impl<Item, ArrayImpl, const NDIM: usize> Array<ArrayImpl, NDIM>

where ArrayImpl: UnsafeRandomAccessMut<NDIM, Item = Item> + Shape<NDIM>, Item: Copy,

pub fn swap( &mut self, pos1: [usize; NDIM], pos2: [usize; NDIM], ) -> RlstResult<()>

Swap the elements at the positions pos1 and pos2.

Returns an error if either pos1 or pos2 is out of bounds.

impl<Item, const NDIM: usize> Array<BaseArray<ArrayContainer<Item, 1>, NDIM>, NDIM>

where Item: Copy + Default,

pub fn one_element_array() -> Self

Create an empty 1-element array of the given dimension.

Trait Implementations

impl<ArrayImpl1, ArrayImpl2, const NDIM: usize> Add<Array<ArrayImpl2, NDIM>> for Array<ArrayImpl1, NDIM>

where ArrayImpl1: Shape<NDIM>, ArrayImpl2: Shape<NDIM>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Item, ArrayImpl1, ArrayImpl2, const NDIM: usize> AddAssign<Array<ArrayImpl2, NDIM>> for Array<ArrayImpl1, NDIM>

where ArrayImpl1: Shape<NDIM> + UnsafeDisjointRandom1DAccessMut<Item = Item>, ArrayImpl2: Shape<NDIM> + UnsafeRandom1DAccessByValue<Item = Item>, Item: AddAssign,

fn add_assign(&mut self, rhs: Array<ArrayImpl2, NDIM>)

Performs the += operation.

impl<Item, ArrayImplX, ArrayImplY, ArrayImpl> AsMatrixApply<Array<ArrayImplX, 1>, Array<ArrayImplY, 1>> for Array<ArrayImpl, 2>

where Item: Gemm + Copy, ArrayImplX: RawAccess<Item = Item> + Stride<1> + Shape<1>, ArrayImplY: RawAccessMut<Item = Item> + Stride<1> + Shape<1>, ArrayImpl: RawAccess<Item = Item> + Stride<2> + Shape<2>,

fn apply( &self, alpha: Self::Item, x: &Array<ArrayImplX, 1>, beta: Self::Item, y: &mut Array<ArrayImplY, 1>, )

Compute the matvec y -> alpha * self * x + beta * y with self a matrix.

impl<Item, ArrayImplX, ArrayImplY> AsMatrixApply<Array<ArrayImplX, 1>, Array<ArrayImplY, 1>> for CsrMatrix<Item>

where Item: Default + Mul<Output = Item> + AddAssign<Item> + Add<Output = Item> + Copy + One, ArrayImplX: UnsafeRandomAccessByValue<1, Item = Item> + Shape<1>, ArrayImplY: UnsafeDisjointRandom1DAccessMut<Item = Item> + Shape<1>,

fn apply( &self, alpha: Self::Item, x: &Array<ArrayImplX, 1>, beta: Self::Item, y: &mut Array<ArrayImplY, 1>, )

Compute the matvec y -> alpha * self * x + beta * y with self a matrix.

impl<Item, ArrayImplX, ArrayImplY, ArrayImpl> AsMatrixApply<Array<ArrayImplX, 2>, Array<ArrayImplY, 2>> for Array<ArrayImpl, 2>

where Item: Gemm + Copy, ArrayImplX: RawAccess<Item = Item> + Stride<2> + Shape<2>, ArrayImplY: RawAccessMut<Item = Item> + Stride<2> + Shape<2>, ArrayImpl: RawAccess<Item = Item> + Stride<2> + Shape<2>,

fn apply( &self, alpha: Self::Item, x: &Array<ArrayImplX, 2>, beta: Self::Item, y: &mut Array<ArrayImplY, 2>, )

Compute the matvec y -> alpha * self * x + beta * y with self a matrix.

impl<Item, ArrayImplX, ArrayImplY> AsMatrixApply<Array<ArrayImplX, 2>, Array<ArrayImplY, 2>> for CsrMatrix<Item>

where Item: Copy, for<'b> Self: BaseItem<Item = Item> + AsMatrixApply<Array<ArraySlice<ArrayRef<'b, ArrayImplX, 2>, 2, 1>, 1>, Array<ArraySlice<ArrayRefMut<'b, ArrayImplY, 2>, 2, 1>, 1>>, ArrayImplX: UnsafeRandomAccessByValue<2, Item = Item> + Shape<2>, ArrayImplY: UnsafeRandomAccessMut<2, Item = Item> + Shape<2>,

fn apply( &self, alpha: Self::Item, x: &Array<ArrayImplX, 2>, beta: Self::Item, y: &mut Array<ArrayImplY, 2>, )

Compute the matvec y -> alpha * self * x + beta * y with self a matrix.

impl<ArrayImpl, const NDIM: usize> BaseItem for Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem,

type Item = <ArrayImpl as BaseItem>::Item

Item type.

impl<Item, ArrayImpl> Cholesky for Array<ArrayImpl, 2>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, Item: Lapack,

type Item = Item

Item type of the array.

fn cholesky(&self, uplo: UpLo) -> RlstResult<DynArray<Self::Item, 2>>

Compute the Cholesky factor of a square Hermitian positive-definite matrix.

impl<Item, ArrayImpl, RhsArrayImpl, const NDIM: usize> CholeskySolve<Array<RhsArrayImpl, NDIM>> for Array<ArrayImpl, 2>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, RhsArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM>, Item: Lapack,

type Output = Array<BaseArray<VectorContainer<Item>, NDIM>, NDIM>

The output type of the Cholesky solver.

fn cholesky_solve( &self, uplo: UpLo, rhs: &Array<RhsArrayImpl, NDIM>, ) -> RlstResult<Self::Output>

Solve a Hermitian positive-definite system by Cholesky factorization.

impl<ArrayImpl: Shape<NDIM>, const NDIM: usize> Debug for Array<ArrayImpl, NDIM>

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

Formats the value using the given formatter.

impl<ArrayImpl1, ArrayImpl2, const NDIM: usize> Div<Array<ArrayImpl2, NDIM>> for Array<ArrayImpl1, NDIM>

where ArrayImpl1: Shape<NDIM>, ArrayImpl2: Shape<NDIM>,

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Item, ArrayImpl, const NDIM: usize> Div<Item> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = Item>, Item: Recip<Output = Item> + Div<Output = Item>,

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Item, ArrayImpl1, ArrayImpl2, const NDIM: usize> DivAssign<Array<ArrayImpl2, NDIM>> for Array<ArrayImpl1, NDIM>

where ArrayImpl1: Shape<NDIM> + UnsafeDisjointRandom1DAccessMut<Item = Item>, ArrayImpl2: Shape<NDIM> + UnsafeRandom1DAccessByValue<Item = Item>, Item: DivAssign,

fn div_assign(&mut self, rhs: Array<ArrayImpl2, NDIM>)

Performs the /= operation.

impl<Item, ArrayImpl, const NDIM: usize> DivAssign<Item> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + UnsafeDisjointRandom1DAccessMut<Item = Item>, Item: DivAssign + Copy,

fn div_assign(&mut self, rhs: Item)

Performs the /= operation.

impl<Item, ArrayImpl> EigenvalueDecomposition for Array<ArrayImpl, 2>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, Item: Lapack,

fn eigenvalues( &self, ) -> RlstResult<DynArray<<Self::Item as RlstScalar>::Complex, 1>>

Return the eigenvalues of the matrix.

The eigenvalues are computed using the LAPACK ?gees routine.

Errors

Returns an error if the matrix is not square or if the LAPACK routine fails.

fn schur( &self, ) -> RlstResult<(DynArray<Self::Item, 2>, DynArray<Self::Item, 2>)>

Compute the Schur decomposition of the matrix.

The Schur decomposition of a square matrix A is given by A = Z * T * Z^H, where:

• T is a block-upper triangular matrix. Its diagonal blocks are 1x1 or 2x2 and encode the eigenvalues of the matrix.
• Z is a unitary matrix.

Returns a tuple (T, Z).

Errors

Returns an error if the matrix is not square or if the LAPACK routine fails.

fn eig( &self, mode: EigMode, ) -> RlstResult<(DynArray<<Self::Item as RlstScalar>::Complex, 1>, Option<DynArray<<Self::Item as RlstScalar>::Complex, 2>>, Option<DynArray<<Self::Item as RlstScalar>::Complex, 2>>)>

Compute the eigenvalues and eigenvectors of the matrix.

The eigenvalues and eigenvectors are computed using the LAPACK ?geev routine.

Arguments

• mode: Specifies which eigenvectors to compute.

Returns

A tuple (lam, vr, vl) containing:

• lam: A vector of eigenvalues.
• vr: An optional matrix of right eigenvectors.
• vl: An optional matrix of left eigenvectors.

Errors

Returns an error if the matrix is not square or if the LAPACK routine fails.

type Item = Item

The item type of the matrix.

impl<Item, ArrayImpl, const NDIM: usize> EvaluateArray<Item, NDIM> for Array<ArrayImpl, NDIM>

where Item: Copy + Default, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM> + ContainerType,

type OutputImpl = <<ArrayImpl as ContainerType>::Type as ArrayFromContainerType>::OutputImpl<Item, NDIM>

The output implementation type of the evaluated object.

fn eval(&self) -> Array<Self::OutputImpl, NDIM>

Evaluate the object.

impl<Item, ArrayImpl, const NDIM: usize> EvaluateRowMajorArray<Item, NDIM> for Array<ArrayImpl, NDIM>

where Item: Copy + Default, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM> + ContainerType,

type OutputImpl = <<ArrayImpl as ContainerType>::Type as RowMajorArrayFromContainerType>::OutputImpl<Item, NDIM>

The output implementation type of the evaluated array.

fn eval_row_major(&self) -> Array<Self::OutputImpl, NDIM>

Evaluate the array into a new row-major array.

impl<'a, ArrayImpl: BaseItem + Shape<2>> From<&'a Array<ArrayImpl, 2>> for Operator<ArrayOperator<'a, ArrayImpl>>

where ArrayOperator<'a, ArrayImpl>: OperatorBase,

fn from(value: &'a Array<ArrayImpl, 2>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<Complex<f32>>, 0>> for c32

fn from(value: ZeroDimArray<c32>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<Complex<f64>>, 0>> for c64

fn from(value: ZeroDimArray<c64>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<f32>, 0>> for f32

fn from(value: ZeroDimArray<f32>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<f64>, 0>> for f64

fn from(value: ZeroDimArray<f64>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<i8>, 0>> for i8

fn from(value: ZeroDimArray<i8>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<i16>, 0>> for i16

fn from(value: ZeroDimArray<i16>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<i32>, 0>> for i32

fn from(value: ZeroDimArray<i32>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<i64>, 0>> for i64

fn from(value: ZeroDimArray<i64>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<i128>, 0>> for i128

fn from(value: ZeroDimArray<i128>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<isize>, 0>> for isize

fn from(value: ZeroDimArray<isize>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<u8>, 0>> for u8

fn from(value: ZeroDimArray<u8>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<u16>, 0>> for u16

fn from(value: ZeroDimArray<u16>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<u32>, 0>> for u32

fn from(value: ZeroDimArray<u32>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<u64>, 0>> for u64

fn from(value: ZeroDimArray<u64>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<u128>, 0>> for u128

fn from(value: ZeroDimArray<u128>) -> Self

Converts to this type from the input type.

impl From<Array<ScalarArrayImpl<usize>, 0>> for usize

fn from(value: ZeroDimArray<usize>) -> Self

Converts to this type from the input type.

impl<Item, ArrayImpl, BArrayImpl> GeneralizedEigenvalueDecomposition<Array<BArrayImpl, 2>> for Array<ArrayImpl, 2>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, BArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, Item: Lapack,

type Item = Item

The item type of the matrix.

fn eig_generalized( &self, b: &Array<BArrayImpl, 2>, mode: EigMode, ) -> RlstResult<(DynArray<<Self::Item as RlstScalar>::Complex, 1>, Option<DynArray<<Self::Item as RlstScalar>::Complex, 2>>, Option<DynArray<<Self::Item as RlstScalar>::Complex, 2>>)>

Compute eigenvalues and selected eigenvectors of (A, B).

fn eigenvalues_generalized( &self, b: &B, ) -> RlstResult<DynArray<<Self::Item as RlstScalar>::Complex, 1>>

Return eigenvalues of the square pencil (A, B) in unspecified order.

impl<Item, ArrayImpl, BArrayImpl> GeneralizedSchur<Array<BArrayImpl, 2>> for Array<ArrayImpl, 2>

where Item: Lapack, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, BArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>,

type Item = Item

The scalar type of the matrix pencil.

fn qz(&self, b: &Array<BArrayImpl, 2>) -> RlstResult<QzDecomposition<Item>>

Compute factors satisfying A = Q S Z^H and B = Q T Z^H.

impl<Item, ArrayImpl, BArrayImpl> GeneralizedSymmEig<Array<BArrayImpl, 2>> for Array<ArrayImpl, 2>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, BArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, Item: Lapack,

type Item = Item

Item type of the generalized symmetric eigenvalue decomposition.

fn eigh_generalized( &self, b: &Array<BArrayImpl, 2>, uplo: UpLo, mode: SymmEigMode, itype: GeneralizedSymmEigType, ) -> RlstResult<(DynArray<<Self::Item as RlstScalar>::Real, 1>, Option<DynArray<Self::Item, 2>>)>

Compute generalized eigenvalues and, when requested, eigenvectors.

fn eigenvaluesh_generalized( &self, b: &B, uplo: UpLo, itype: GeneralizedSymmEigType, ) -> RlstResult<DynArray<<Self::Item as RlstScalar>::Real, 1>>

Compute the ascending real eigenvalues of a definite generalized symmetric/Hermitian eigenproblem.

impl<ArrayImpl, const NDIM: usize> Index<[usize; NDIM]> for Array<ArrayImpl, NDIM>

where ArrayImpl: RandomAccessByRef<NDIM>,

type Output = <ArrayImpl as BaseItem>::Item

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<ArrayImpl, const NDIM: usize> IndexMut<[usize; NDIM]> for Array<ArrayImpl, NDIM>

where Array<ArrayImpl, NDIM>: Index<[usize; NDIM], Output = ArrayImpl::Item>, ArrayImpl: RandomAccessMut<NDIM>,

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

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

impl<Item, ArrayImpl> Inverse for Array<ArrayImpl, 2>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, Item: Copy + Default + Getri + Getrf,

type Output = Array<BaseArray<VectorContainer<Item>, 2>, 2>

The item type of the inverse.

fn inverse(&self) -> RlstResult<DynArray<Item, 2>>

Compute the inverse of a square matrix.

impl<Item, ArrayImpl> Ldl for Array<ArrayImpl, 2>

where Item: Lapack, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>,

type Item = Item

Item type of the LDL decomposition.

fn ldl(&self, uplo: UpLo) -> RlstResult<LdlDecomposition<Item>>

Factor a copied matrix, using the selected triangle.

impl<ArrayImpl> Linspace<f32> for Array<ArrayImpl, 1>

where ArrayImpl: MutableArrayImpl<f32, 1>,

fn linspace(&mut self, a: f32, b: f32)

Fill an array with equally spaced points, including first value a and last value b.

impl<ArrayImpl> Linspace<f64> for Array<ArrayImpl, 1>

where ArrayImpl: MutableArrayImpl<f64, 1>,

fn linspace(&mut self, a: f64, b: f64)

Fill an array with equally spaced points, including first value a and last value b.

impl<Item, ArrayImpl> Lq for Array<ArrayImpl, 2>

where Item: Lapack, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>,

type Item = Item

Item type of the LQ decomposition.

fn lq(&self) -> RlstResult<LqDecomposition<Item>>

Compute packed factors satisfying A = L Q.

impl<Item, ArrayImpl> Lu for Array<ArrayImpl, 2>

where Item: Lapack, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>,

type Item = Item

Item type of the LU decomposition.

fn lu(&self) -> RlstResult<LuDecomposition<Item>>

Compute the pivoted LU decomposition of a matrix.

impl<ArrayImpl1, ArrayImpl2, const NDIM: usize> Mul<Array<ArrayImpl2, NDIM>> for Array<ArrayImpl1, NDIM>

where ArrayImpl1: Shape<NDIM>, ArrayImpl2: Shape<NDIM>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for f64

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for f32

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for c64

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for c32

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for usize

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for i8

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for i16

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for i32

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for i64

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for u8

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for u16

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for u32

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Array<ArrayImpl, NDIM>> for u64

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<Complex<f32>> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = c32>,

type Output = Array<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, const NDIM: usize> Mul<Complex<f64>> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = c64>,

type Output = Array<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, const NDIM: usize> Mul<f32> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = f32>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<f64> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = f64>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<i8> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = i8>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<i16> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = i16>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<i32> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = i32>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<i64> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = i64>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<u8> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = u8>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<u16> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = u16>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<u32> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = u32>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<u64> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = u64>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<ArrayImpl, const NDIM: usize> Mul<usize> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + BaseItem<Item = usize>,

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Item, ArrayImpl1, ArrayImpl2, const NDIM: usize> MulAdd<Item, Array<ArrayImpl2, NDIM>> for Array<ArrayImpl1, NDIM>

where ArrayImpl1: BaseItem<Item = Item> + Shape<NDIM>, ArrayImpl2: BaseItem<Item = Item> + Shape<NDIM>, Item: MulAdd<Output = Item> + Copy,

fn mul_add( self, a: Item, b: Array<ArrayImpl2, NDIM>, ) -> Array<MulAddImpl<ArrayImpl1, ArrayImpl2, Item, NDIM>, NDIM>

where ArrayImpl1: BaseItem<Item = Item> + Shape<NDIM>, ArrayImpl2: BaseItem<Item = Item> + Shape<NDIM>, Item: MulAdd<Output = Item> + Copy,

Compentwie form self * a + b, where a is a scalar and b is another array. The implementation depdends on the MulAdd trait from the num crate for the componets of the arrays.

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

The resulting type after applying the fused multiply-add.

impl<Item, ArrayImpl1, ArrayImpl2, const NDIM: usize> MulAssign<Array<ArrayImpl2, NDIM>> for Array<ArrayImpl1, NDIM>

where ArrayImpl1: Shape<NDIM> + UnsafeDisjointRandom1DAccessMut<Item = Item>, ArrayImpl2: Shape<NDIM> + UnsafeRandom1DAccessByValue<Item = Item>, Item: MulAssign,

fn mul_assign(&mut self, rhs: Array<ArrayImpl2, NDIM>)

Performs the *= operation.

impl<Item, ArrayImpl, const NDIM: usize> MulAssign<Item> for Array<ArrayImpl, NDIM>

where ArrayImpl: Shape<NDIM> + UnsafeDisjointRandom1DAccessMut<Item = Item>, Item: MulAssign + Copy,

fn mul_assign(&mut self, rhs: Item)

Performs the *= operation.

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

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

Multiply into

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

where Self: Sized, Self::Item: One + Zero,

Multiply First * Second and sum into Self

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

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

Multiply into

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

where Self: Sized, Self::Item: One + Zero,

Multiply First * Second and sum into Self

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

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

Multiply into

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

where Self: Sized, Self::Item: One + Zero,

Multiply First * Second and sum into Self

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

fn mult_into_resize( self, transa: TransMode, transb: TransMode, alpha: Item, arr_a: Array<ArrayImplFirst, 1>, arr_b: Array<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, Self::Item: One + Zero,

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

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

fn mult_into_resize( self, transa: TransMode, transb: TransMode, alpha: Item, arr_a: Array<ArrayImplFirst, 2>, arr_b: Array<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, Self::Item: One + Zero,

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

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

fn mult_into_resize( self, transa: TransMode, transb: TransMode, alpha: Item, arr_a: Array<ArrayImplFirst, 2>, arr_b: Array<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, Self::Item: One + Zero,

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

impl<Item, ArrayImpl, const NDIM: usize> Neg for Array<ArrayImpl, NDIM>

where ArrayImpl: BaseItem<Item = Item>, Item: Neg<Output = Item>,

type Output = Array<ArrayNeg<ArrayImpl, NDIM>, NDIM>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<ArrayImpl: RandomAccessByValue<2, Item = c32> + Shape<2>> PrettyPrint<Complex<f32>> for Array<ArrayImpl, 2>

fn pretty_print(&self)

Pretty printing

fn pretty_print_with_dimension(&self, rows: usize, cols: usize)

Pretty printing with dimension

fn pretty_print_advanced( &self, rows: usize, cols: usize, print_width: usize, mantissa: usize, exponent: usize, )

Pretty printing with advanced options

impl<ArrayImpl: RandomAccessByValue<2, Item = c64> + Shape<2>> PrettyPrint<Complex<f64>> for Array<ArrayImpl, 2>

fn pretty_print(&self)

Pretty printing

fn pretty_print_with_dimension(&self, rows: usize, cols: usize)

Pretty printing with dimension

fn pretty_print_advanced( &self, rows: usize, cols: usize, print_width: usize, mantissa: usize, exponent: usize, )

Pretty printing with advanced options

impl<ArrayImpl: RandomAccessByValue<2, Item = f32> + Shape<2>> PrettyPrint<f32> for Array<ArrayImpl, 2>

fn pretty_print(&self)

Pretty printing

fn pretty_print_with_dimension(&self, rows: usize, cols: usize)

Pretty printing with dimension

fn pretty_print_advanced( &self, rows: usize, cols: usize, print_width: usize, mantissa: usize, exponent: usize, )

Pretty printing with advanced options

impl<ArrayImpl: RandomAccessByValue<2, Item = f64> + Shape<2>> PrettyPrint<f64> for Array<ArrayImpl, 2>

fn pretty_print(&self)

Pretty printing

fn pretty_print_with_dimension(&self, rows: usize, cols: usize)

Pretty printing with dimension

fn pretty_print_advanced( &self, rows: usize, cols: usize, print_width: usize, mantissa: usize, exponent: usize, )

Pretty printing with advanced options

impl<Item, ArrayImpl> Qr for Array<ArrayImpl, 2>

where Item: Lapack, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>,

fn qr(&self, pivoting: EnablePivoting) -> RlstResult<QrDecomposition<Item>>

Compute the QR decomposition of a matrix.

type Item = Item

Item type of the QR decomposition.

impl<Item, ArrayImpl> SingularValueDecomposition for Array<ArrayImpl, 2>

where Item: Lapack + Gemm, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>,

type Item = Item

The item type of the matrix.

fn singular_values( &self, ) -> RlstResult<DynArray<<Self::Item as RlstScalar>::Real, 1>>

Compute singular values in descending order.

fn svd( &self, mode: SvdMode, ) -> RlstResult<(DynArray<<Self::Item as RlstScalar>::Real, 1>, DynArray<Self::Item, 2>, DynArray<Self::Item, 2>)>

Compute the singular value decomposition of a matrix.

fn svd_truncated( &self, max_singular_values: Option<usize>, tol: Option<<Self::Item as RlstScalar>::Real>, ) -> RlstResult<(DynArray<<Self::Item as RlstScalar>::Real, 1>, DynArray<Self::Item, 2>, DynArray<Self::Item, 2>)>

Compute the truncated singular value decomposition of a matrix.

fn pseudo_inverse( &self, max_singular_values: Option<usize>, tol: Option<<Self::Item as RlstScalar>::Real>, ) -> RlstResult<PInv<Self::Item>>

where <Self::Item as RlstScalar>::Real: Into<Self::Item>,

Compute an SVD-based, optionally truncated pseudo-inverse.

impl<Item, ArrayImpl, RhsArrayImpl, const NDIM: usize> Solve<Array<RhsArrayImpl, NDIM>> for Array<ArrayImpl, 2>

where Item: Lapack, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, RhsArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM>,

type Output = Array<BaseArray<VectorContainer<Item>, NDIM>, NDIM>

The output type of the solver.

fn solve(&self, rhs: &Array<RhsArrayImpl, NDIM>) -> RlstResult<Self::Output>

Solve A x = b, or a rectangular system in the least-squares sense.

impl<Item, ArrayImpl, RhsArrayImpl, const NDIM: usize> SolveTriangular<Array<RhsArrayImpl, NDIM>> for Array<ArrayImpl, 2>

where Item: Lapack, ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, RhsArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<NDIM>,

type Output = Array<BaseArray<VectorContainer<Item>, NDIM>, NDIM>

The output type of the triangular solver.

fn solve_triangular( &self, uplo: UpLo, rhs: &Array<RhsArrayImpl, NDIM>, ) -> RlstResult<Self::Output>

Solve a triangular system using only the triangle selected by uplo.

impl<ArrayImpl1, ArrayImpl2, const NDIM: usize> Sub<Array<ArrayImpl2, NDIM>> for Array<ArrayImpl1, NDIM>

where ArrayImpl1: Shape<NDIM>, ArrayImpl2: Shape<NDIM>,

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Item, ArrayImpl1, ArrayImpl2, const NDIM: usize> SubAssign<Array<ArrayImpl2, NDIM>> for Array<ArrayImpl1, NDIM>

where ArrayImpl1: Shape<NDIM> + UnsafeDisjointRandom1DAccessMut<Item = Item>, ArrayImpl2: Shape<NDIM> + UnsafeRandom1DAccessByValue<Item = Item>, Item: SubAssign,

fn sub_assign(&mut self, rhs: Array<ArrayImpl2, NDIM>)

Performs the -= operation.

impl<Item, AImpl, BImpl, CImpl> SylvesterSolve<Array<BImpl, 2>, Array<CImpl, 2>> for Array<AImpl, 2>

where Item: Lapack + Gemm, AImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, BImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, CImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>,

type Item = Item

The scalar type of the coefficient matrices.

fn solve_sylvester( &self, b: &Array<BImpl, 2>, c: &Array<CImpl, 2>, sign: TrsylSign, ) -> RlstResult<SylvesterSolution<Item>>

Solve A X + sign X B = scale C without automatically unscaling X.

impl<Item, ArrayImpl> SymmEig for Array<ArrayImpl, 2>

where ArrayImpl: UnsafeRandom1DAccessByValue<Item = Item> + Shape<2>, Item: Lapack,

type Item = Item

Item type of the symmetric eigenvalue decomposition.

fn eigh( &self, uplo: UpLo, mode: SymmEigMode, ) -> RlstResult<(DynArray<Item::Real, 1>, Option<DynArray<Item, 2>>)>

Compute ascending eigenvalues and, when requested, eigenvectors.

fn eigenvaluesh( &self, ) -> RlstResult<DynArray<<Self::Item as RlstScalar>::Real, 1>>

Compute ascending eigenvalues of a square real symmetric or complex Hermitian matrix, reading its upper triangle.