Struct Row 

#[repr(transparent)]
pub struct Row<Inner>(pub Inner);

generic Row wrapper

Tuple Fields

0: Inner

Implementations

impl<'a, T> Row<Mut<'a, T>>

pub fn from_mut(value: &'a mut T) -> Self

creates a row view over the given element

pub fn from_slice_mut(slice: &'a mut [T]) -> Self

creates a RowMut from slice views over the row vector data, the result has the same number of columns as the length of the input slice

impl<'a, T, Cols: Shape, CStride: Stride> Row<Mut<'a, T, Cols, CStride>>

pub const unsafe fn from_raw_parts_mut( ptr: *mut T, ncols: Cols, col_stride: CStride, ) -> Self

creates a RowMut from pointers to the column vector data, number of rows, and row stride

safety

this function has the same safety requirements as [MatMut::from_raw_parts_mut(ptr, 1, ncols, 0, col_stride)]

pub fn as_ptr(&self) -> *const T

returns a pointer to the row data

pub fn nrows(&self) -> usize

returns the number of rows of the row (always 1)

pub fn ncols(&self) -> Cols

returns the number of columns of the row

pub fn shape(&self) -> (usize, Cols)

returns the number of rows and columns of the row

pub fn col_stride(&self) -> CStride

returns the column stride of the row

pub fn ptr_at(&self, col: IdxInc<Cols>) -> *const T

returns a raw pointer to the element at the given index

pub unsafe fn ptr_inbounds_at(&self, col: Idx<Cols>) -> *const T

returns a raw pointer to the element at the given index, assuming the provided index is within the row bounds

safety

the behavior is undefined if any of the following conditions are violated:

• col < self.ncols()

pub fn split_at_col( self, col: IdxInc<Cols>, ) -> (RowRef<'a, T, usize, CStride>, RowRef<'a, T, usize, CStride>)

see RowRef::split_at_col

pub fn transpose(self) -> ColRef<'a, T, Cols, CStride>

see RowRef::transpose

pub fn conjugate(self) -> RowRef<'a, T::Conj, Cols, CStride>

where T: Conjugate,

see RowRef::conjugate

pub fn canonical(self) -> RowRef<'a, T::Canonical, Cols, CStride>

where T: Conjugate,

see RowRef::canonical

pub fn adjoint(self) -> ColRef<'a, T::Conj, Cols, CStride>

where T: Conjugate,

see RowRef::adjoint

pub fn get<ColRange>( self, col: ColRange, ) -> <RowRef<'a, T, Cols, CStride> as RowIndex<ColRange>>::Target

where RowRef<'a, T, Cols, CStride>: RowIndex<ColRange>,

see RowRef::get

pub unsafe fn get_unchecked<ColRange>( self, col: ColRange, ) -> <RowRef<'a, T, Cols, CStride> as RowIndex<ColRange>>::Target

where RowRef<'a, T, Cols, CStride>: RowIndex<ColRange>,

see RowRef::get_unchecked

pub fn reverse_cols(self) -> RowRef<'a, T, Cols, CStride::Rev>

see RowRef::reverse_cols

pub fn subcols<V: Shape>( self, col_start: IdxInc<Cols>, ncols: V, ) -> RowRef<'a, T, V, CStride>

see RowRef::subcols

pub fn as_col_shape<V: Shape>(self, ncols: V) -> RowRef<'a, T, V, CStride>

see RowRef::as_col_shape

pub fn as_dyn_cols(self) -> RowRef<'a, T, usize, CStride>

see RowRef::as_dyn_cols

pub fn as_dyn_stride(self) -> RowRef<'a, T, Cols, isize>

see RowRef::as_dyn_stride

pub fn iter( self, ) -> impl 'a + ExactSizeIterator + DoubleEndedIterator<Item = &'a T>

where Cols: 'a,

see RowRef::iter

pub fn par_iter(self) -> impl 'a + IndexedParallelIterator<Item = &'a T>

where T: Sync, Cols: 'a,

see RowRef::par_iter

pub fn try_as_row_major(self) -> Option<RowRef<'a, T, Cols, ContiguousFwd>>

see RowRef::try_as_row_major

pub fn as_diagonal(self) -> DiagRef<'a, T, Cols, CStride>

see RowRef::as_diagonal

pub fn as_mat(self) -> MatRef<'a, T, usize, Cols, isize, CStride>

see RowRef::as_mat

pub fn as_mat_mut(self) -> MatMut<'a, T, usize, Cols, isize, CStride>

see RowRef::as_mat

impl<T, Cols: Shape, CStride: Stride, Inner: for<'short> ReborrowMut<'short, Target = Mut<'short, T, Cols, CStride>>> Row<Inner>

pub fn as_mut(&mut self) -> RowMut<'_, T, Cols, CStride>

returns a view over self

pub fn copy_from<RhsT: Conjugate<Canonical = T>>( &mut self, other: impl AsRowRef<T = RhsT, Cols = Cols>, )

where T: ComplexField,

copies other into self

pub fn fill(&mut self, value: T)

where T: Clone,

fills all the elements of self with value

impl<'a, T, Cols: Shape, CStride: Stride> Row<Mut<'a, T, Cols, CStride>>

pub fn as_ptr_mut(&self) -> *mut T

see RowRef::as_ptr

pub fn ptr_at_mut(&self, col: IdxInc<Cols>) -> *mut T

see RowRef::ptr_at

pub unsafe fn ptr_inbounds_at_mut(&self, col: Idx<Cols>) -> *mut T

see RowRef::ptr_inbounds_at

pub fn split_at_col_mut( self, col: IdxInc<Cols>, ) -> (RowMut<'a, T, usize, CStride>, RowMut<'a, T, usize, CStride>)

see RowRef::split_at_col

pub fn transpose_mut(self) -> ColMut<'a, T, Cols, CStride>

see RowRef::transpose

pub fn conjugate_mut(self) -> RowMut<'a, T::Conj, Cols, CStride>

where T: Conjugate,

see RowRef::conjugate

pub fn canonical_mut(self) -> RowMut<'a, T::Canonical, Cols, CStride>

where T: Conjugate,

see RowRef::canonical

pub fn adjoint_mut(self) -> ColMut<'a, T::Conj, Cols, CStride>

where T: Conjugate,

see RowRef::adjoint

pub fn get_mut<ColRange>( self, col: ColRange, ) -> <RowMut<'a, T, Cols, CStride> as RowIndex<ColRange>>::Target

where RowMut<'a, T, Cols, CStride>: RowIndex<ColRange>,

see RowRef::get

pub unsafe fn get_mut_unchecked<ColRange>( self, col: ColRange, ) -> <RowMut<'a, T, Cols, CStride> as RowIndex<ColRange>>::Target

where RowMut<'a, T, Cols, CStride>: RowIndex<ColRange>,

see RowRef::get

pub fn reverse_cols_mut(self) -> RowMut<'a, T, Cols, CStride::Rev>

see RowRef::reverse_cols

pub fn subcols_mut<V: Shape>( self, col_start: IdxInc<Cols>, ncols: V, ) -> RowMut<'a, T, V, CStride>

see RowRef::subcols

pub fn as_col_shape_mut<V: Shape>(self, ncols: V) -> RowMut<'a, T, V, CStride>

see RowRef::as_col_shape

pub fn as_dyn_cols_mut(self) -> RowMut<'a, T, usize, CStride>

see RowRef::as_dyn_cols

pub fn as_dyn_stride_mut(self) -> RowMut<'a, T, Cols, isize>

see RowRef::as_dyn_stride

pub fn iter_mut( self, ) -> impl 'a + ExactSizeIterator + DoubleEndedIterator<Item = &'a mut T>

where Cols: 'a,

see RowRef::iter

pub fn par_iter_mut(self) -> impl 'a + IndexedParallelIterator<Item = &'a mut T>

where T: Send, Cols: 'a,

see RowRef::par_iter

pub fn par_partition( self, count: usize, ) -> impl 'a + IndexedParallelIterator<Item = RowRef<'a, T, usize, CStride>>

where T: Sync, Cols: 'a,

see RowRef::par_partition

pub fn par_partition_mut( self, count: usize, ) -> impl 'a + IndexedParallelIterator<Item = RowMut<'a, T, usize, CStride>>

where T: Send, Cols: 'a,

see RowRef::par_partition

pub fn try_as_row_major_mut(self) -> Option<RowMut<'a, T, Cols, ContiguousFwd>>

see RowRef::try_as_row_major

pub fn as_diagonal_mut(self) -> DiagMut<'a, T, Cols, CStride>

see RowRef::as_diagonal

impl<'a, T, Rows: Shape> Row<Mut<'a, T, Rows, ContiguousFwd>>

pub fn as_slice(self) -> &'a [T]

returns a reference over the elements as a slice

impl<'a, 'ROWS, T> Row<Mut<'a, T, Dim<'ROWS>, ContiguousFwd>>

pub fn as_array(self) -> &'a Array<'ROWS, T>

returns a reference over the elements as a lifetime-bound slice

impl<'a, T, Cols: Shape> Row<Mut<'a, T, Cols, ContiguousFwd>>

pub fn as_slice_mut(self) -> &'a mut [T]

returns a reference over the elements as a slice

impl<'a, 'COLS, T> Row<Mut<'a, T, Dim<'COLS>, ContiguousFwd>>

pub fn as_array_mut(self) -> &'a mut Array<'COLS, T>

returns a reference over the elements as a lifetime-bound slice

impl<'a, T, Cols: Shape, CStride: Stride> Row<Mut<'a, T, Cols, CStride>>

where T: RealField,

pub fn max(&self) -> Option<T>

Returns the maximum element in the row, or None if the row is empty

pub fn min(&self) -> Option<T>

Returns the minimum element in the row, or None if the row is empty

impl<T, Cols: Shape> Row<Own<T, Cols>>

pub fn from_fn(nrows: Cols, f: impl FnMut(Idx<Cols>) -> T) -> Self

returns a new row with dimension nrows, filled with the provided function

pub fn zeros(ncols: Cols) -> Self

where T: ComplexField,

returns a new row with dimension nrows, filled with zeros

pub fn ones(ncols: Cols) -> Self

where T: ComplexField,

returns a new row with dimension nrows, filled with ones

pub fn full(ncols: Cols, value: T) -> Self

where T: Clone,

returns a new row with dimension nrows, filled with value

pub fn try_reserve( &mut self, new_row_capacity: usize, ) -> Result<(), TryReserveError>

reserves the minimum capacity for col_capacity columns without reallocating, or returns an error in case of failure. does nothing if the capacity is already sufficient

pub fn reserve(&mut self, new_row_capacity: usize)

reserves the minimum capacity for col_capacity columns without reallocating. does nothing if the capacity is already sufficient

pub fn resize_with(&mut self, new_nrows: Cols, f: impl FnMut(Idx<Cols>) -> T)

resizes the row in-place so that the new dimension is new_ncols. new elements are created with the given function f, so that elements at index j are created by calling f(j)

pub fn truncate(&mut self, new_nrows: Cols)

truncates the row so that its new dimensions are new_ncols.
the new dimension must be smaller than or equal to the current dimension

panics

the function panics if any of the following conditions are violated:

• new_ncols > self.ncols()

pub fn into_col_shape<V: Shape>(self, nrows: V) -> Row<T, V>

see RowRef::as_col_shape

pub fn into_diagonal(self) -> Diag<T, Cols>

see RowRef::as_diagonal

pub fn into_transpose(self) -> Col<T, Cols>

see RowRef::transpose

impl<T, Cols: Shape> Row<Own<T, Cols>>

pub fn nrows(&self) -> usize

returns the number of rows of the row (always 1)

pub fn ncols(&self) -> Cols

returns the number of columns of the row

impl<T, Cols: Shape> Row<Own<T, Cols>>

pub fn as_ptr(&self) -> *const T

see RowRef::as_ptr

pub fn shape(&self) -> (usize, Cols)

see RowRef::shape

pub fn col_stride(&self) -> isize

see RowRef::col_stride

pub fn ptr_at(&self, col: IdxInc<Cols>) -> *const T

see RowRef::ptr_at

pub unsafe fn ptr_inbounds_at(&self, col: Idx<Cols>) -> *const T

see RowRef::ptr_inbounds_at

pub fn split_at_col( &self, col: IdxInc<Cols>, ) -> (RowRef<'_, T, usize>, RowRef<'_, T, usize>)

see RowRef::split_at_col

pub fn transpose(&self) -> ColRef<'_, T, Cols>

see RowRef::transpose

pub fn conjugate(&self) -> RowRef<'_, T::Conj, Cols>

where T: Conjugate,

see RowRef::conjugate

pub fn canonical(&self) -> RowRef<'_, T::Canonical, Cols>

where T: Conjugate,

see RowRef::canonical

pub fn adjoint(&self) -> ColRef<'_, T::Conj, Cols>

where T: Conjugate,

see RowRef::adjoint

pub fn get<ColRange>( &self, col: ColRange, ) -> <RowRef<'_, T, Cols> as RowIndex<ColRange>>::Target

where for<'a> RowRef<'a, T, Cols>: RowIndex<ColRange>,

see RowRef::get

pub unsafe fn get_unchecked<ColRange>( &self, col: ColRange, ) -> <RowRef<'_, T, Cols> as RowIndex<ColRange>>::Target

where for<'a> RowRef<'a, T, Cols>: RowIndex<ColRange>,

see RowRef::get_unchecked

pub fn reverse_cols(&self) -> RowRef<'_, T, Cols>

see RowRef::reverse_cols

pub fn subcols<V: Shape>( &self, col_start: IdxInc<Cols>, ncols: V, ) -> RowRef<'_, T, V>

see RowRef::subcols

pub fn as_col_shape<V: Shape>(&self, ncols: V) -> RowRef<'_, T, V>

see RowRef::as_col_shape

pub fn as_dyn_cols(&self) -> RowRef<'_, T, usize>

see RowRef::as_dyn_cols

pub fn as_dyn_stride(&self) -> RowRef<'_, T, Cols, isize>

see RowRef::as_dyn_stride

pub fn iter( &self, ) -> impl '_ + ExactSizeIterator + DoubleEndedIterator<Item = &T>

see RowRef::iter

pub fn par_iter(&self) -> impl '_ + IndexedParallelIterator<Item = &T>

where T: Sync,

see RowRef::par_iter

pub fn try_as_row_major(&self) -> Option<RowRef<'_, T, Cols, ContiguousFwd>>

see RowRef::try_as_row_major

pub fn as_diagonal(&self) -> DiagRef<'_, T, Cols>

see RowRef::as_diagonal

pub unsafe fn const_cast(&self) -> RowMut<'_, T, Cols>

see RowRef::const_cast

pub fn as_mat(&self) -> MatRef<'_, T, usize, Cols, isize>

see RowRef::as_mat

pub fn as_mat_mut(&mut self) -> MatMut<'_, T, usize, Cols, isize>

see RowRef::as_mat

impl<T, Cols: Shape> Row<Own<T, Cols>>

pub fn as_ptr_mut(&mut self) -> *mut T

see RowMut::as_ptr_mut

pub fn ptr_at_mut(&mut self, col: IdxInc<Cols>) -> *mut T

see RowMut::ptr_at_mut

pub unsafe fn ptr_inbounds_at_mut(&mut self, col: Idx<Cols>) -> *mut T

see RowMut::ptr_inbounds_at_mut

pub fn split_at_col_mut( &mut self, col: IdxInc<Cols>, ) -> (RowMut<'_, T, usize>, RowMut<'_, T, usize>)

see RowMut::split_at_col_mut

pub fn transpose_mut(&mut self) -> ColMut<'_, T, Cols>

see RowMut::transpose_mut

pub fn conjugate_mut(&mut self) -> RowMut<'_, T::Conj, Cols>

where T: Conjugate,

see RowMut::conjugate_mut

pub fn canonical_mut(&mut self) -> RowMut<'_, T::Canonical, Cols>

where T: Conjugate,

see RowMut::canonical_mut

pub fn adjoint_mut(&mut self) -> ColMut<'_, T::Conj, Cols>

where T: Conjugate,

see RowMut::adjoint_mut

pub fn get_mut<ColRange>( &mut self, col: ColRange, ) -> <RowMut<'_, T, Cols> as RowIndex<ColRange>>::Target

where for<'a> RowMut<'a, T, Cols>: RowIndex<ColRange>,

see RowMut::get_mut

pub unsafe fn get_mut_unchecked<ColRange>( &mut self, col: ColRange, ) -> <RowMut<'_, T, Cols> as RowIndex<ColRange>>::Target

where for<'a> RowMut<'a, T, Cols>: RowIndex<ColRange>,

see RowMut::get_mut_unchecked

pub fn reverse_cols_mut(&mut self) -> RowMut<'_, T, Cols>

see RowMut::reverse_cols_mut

pub fn subcols_mut<V: Shape>( &mut self, col_start: IdxInc<Cols>, ncols: V, ) -> RowMut<'_, T, V>

see RowMut::subcols_mut

pub fn as_col_shape_mut<V: Shape>(&mut self, ncols: V) -> RowMut<'_, T, V>

see RowMut::as_col_shape_mut

pub fn as_dyn_cols_mut(&mut self) -> RowMut<'_, T, usize>

see RowMut::as_dyn_cols_mut

pub fn as_dyn_stride_mut(&mut self) -> RowMut<'_, T, Cols, isize>

see RowMut::as_dyn_stride_mut

pub fn iter_mut( &mut self, ) -> impl '_ + ExactSizeIterator + DoubleEndedIterator<Item = &mut T>

see RowMut::iter_mut

pub fn par_iter_mut( &mut self, ) -> impl '_ + IndexedParallelIterator<Item = &mut T>

where T: Send,

see RowMut::par_iter_mut

pub fn try_as_row_major_mut( &mut self, ) -> Option<RowMut<'_, T, Cols, ContiguousFwd>>

see RowMut::try_as_row_major_mut

pub fn as_diagonal_mut(&mut self) -> DiagMut<'_, T, Cols>

see RowMut::as_diagonal_mut

impl<T, Cols: Shape> Row<Own<T, Cols>>

where T: RealField,

pub fn max(&self) -> Option<T>

Returns the maximum element in the row, or None if the row is empty

pub fn min(&self) -> Option<T>

Returns the minimum element in the row, or None if the row is empty

impl<'a, T> Row<Ref<'a, T>>

pub fn from_ref(value: &'a T) -> Self

creates a row view over the given element

pub fn from_slice(slice: &'a [T]) -> Self

creates a RowRef from slice views over the row vector data, the result has the same number of columns as the length of the input slice

impl<'a, T, Cols: Shape, CStride: Stride> Row<Ref<'a, T, Cols, CStride>>

pub const unsafe fn from_raw_parts( ptr: *const T, ncols: Cols, col_stride: CStride, ) -> Self

creates a RowRef from pointers to the column vector data, number of rows, and row stride

safety

this function has the same safety requirements as [MatRef::from_raw_parts(ptr, 1, ncols, 0, col_stride)]

pub fn as_ptr(&self) -> *const T

returns a pointer to the row data

pub fn nrows(&self) -> usize

returns the number of rows of the row (always 1)

pub fn ncols(&self) -> Cols

returns the number of columns of the row

pub fn shape(&self) -> (usize, Cols)

returns the number of rows and columns of the row

pub fn col_stride(&self) -> CStride

returns the column stride of the row

pub fn ptr_at(&self, col: IdxInc<Cols>) -> *const T

returns a raw pointer to the element at the given index

pub unsafe fn ptr_inbounds_at(&self, col: Idx<Cols>) -> *const T

returns a raw pointer to the element at the given index, assuming the provided index is within the row bounds

safety

the behavior is undefined if any of the following conditions are violated:

• col < self.ncols()

pub fn split_at_col( self, col: IdxInc<Cols>, ) -> (RowRef<'a, T, usize, CStride>, RowRef<'a, T, usize, CStride>)

splits the row vertically at the given column into two parts and returns an array of each subrow, in the following order:

• left
• right

panics

the function panics if the following condition is violated:

• col <= self.ncols()

pub fn transpose(self) -> ColRef<'a, T, Cols, CStride>

returns a view over the transpose of self

pub fn conjugate(self) -> RowRef<'a, T::Conj, Cols, CStride>

where T: Conjugate,

returns a view over the conjugate of self

pub fn canonical(self) -> RowRef<'a, T::Canonical, Cols, CStride>

where T: Conjugate,

returns an unconjugated view over self

pub fn adjoint(self) -> ColRef<'a, T::Conj, Cols, CStride>

where T: Conjugate,

returns a view over the conjugate transpose of self

pub fn get<ColRange>( self, col: ColRange, ) -> <RowRef<'a, T, Cols, CStride> as RowIndex<ColRange>>::Target

where RowRef<'a, T, Cols, CStride>: RowIndex<ColRange>,

returns a reference to the element at the given index, or a subrow if col is a range, with bound checks

panics

the function panics if any of the following conditions are violated:

• col must be contained in [0, self.ncols())

pub unsafe fn get_unchecked<ColRange>( self, col: ColRange, ) -> <RowRef<'a, T, Cols, CStride> as RowIndex<ColRange>>::Target

where RowRef<'a, T, Cols, CStride>: RowIndex<ColRange>,

returns a reference to the element at the given index, or a subrow if col is a range, without bound checks

panics

the behavior is undefined if any of the following conditions are violated:

• col must be contained in [0, self.ncols())

pub fn reverse_cols(self) -> RowRef<'a, T, Cols, CStride::Rev>

returns a view over the self, with the columns in reversed order

pub fn subcols<V: Shape>( self, col_start: IdxInc<Cols>, ncols: V, ) -> RowRef<'a, T, V, CStride>

returns a view over the subrow starting at column col_start, and with number of columns ncols

panics

the function panics if any of the following conditions are violated:

• col_start <= self.ncols()
• ncols <= self.ncols() - col_start

pub fn as_col_shape<V: Shape>(self, ncols: V) -> RowRef<'a, T, V, CStride>

returns the input row with the given column shape after checking that it matches the current column shape

pub fn as_dyn_cols(self) -> RowRef<'a, T, usize, CStride>

returns the input row with dynamic column shape

pub fn as_dyn_stride(self) -> RowRef<'a, T, Cols, isize>

returns the input row with dynamic stride

pub fn iter( self, ) -> impl 'a + ExactSizeIterator + DoubleEndedIterator<Item = &'a T>

where Cols: 'a,

returns an iterator over the elements of the row

pub fn par_iter(self) -> impl 'a + IndexedParallelIterator<Item = &'a T>

where T: Sync, Cols: 'a,

returns a parallel iterator over the elements of the row

pub fn par_partition( self, count: usize, ) -> impl 'a + IndexedParallelIterator<Item = RowRef<'a, T, usize, CStride>>

where T: Sync, Cols: 'a,

returns a parallel iterator that provides exactly count successive chunks of the elements of this row

only available with the rayon feature

pub fn try_as_row_major(self) -> Option<RowRef<'a, T, Cols, ContiguousFwd>>

returns a view over the row with a static column stride equal to +1, or None otherwise

pub fn as_mat(self) -> MatRef<'a, T, usize, Cols, isize, CStride>

returns a matrix view over self

pub fn as_diagonal(self) -> DiagRef<'a, T, Cols, CStride>

interprets the row as a diagonal matrix

impl<T, Cols: Shape, CStride: Stride, Inner: for<'short> Reborrow<'short, Target = Ref<'short, T, Cols, CStride>>> Row<Inner>

pub fn as_ref(&self) -> RowRef<'_, T, Cols, CStride>

returns a view over self

pub fn norm_max(&self) -> Real<T>

where T: Conjugate,

returns the maximum norm of self

pub fn norm_l2(&self) -> Real<T>

where T: Conjugate,

returns the l2 norm of self

pub fn squared_norm_l2(&self) -> Real<T>

where T: Conjugate,

returns the squared l2 norm of self

pub fn norm_l1(&self) -> Real<T>

where T: Conjugate,

returns the l1 norm of self

pub fn sum(&self) -> T::Canonical

where T: Conjugate,

returns the sum of the elements of self

pub fn kron( &self, rhs: impl AsMatRef<T: Conjugate<Canonical = T::Canonical>>, ) -> Mat<T::Canonical>

where T: Conjugate,

see Mat::kron

pub fn is_all_finite(&self) -> bool

where T: Conjugate,

returns true if all of the elements of self are finite. otherwise returns false.

pub fn has_nan(&self) -> bool

where T: Conjugate,

returns true if any of the elements of self is NaN. otherwise returns false.

pub fn cloned(&self) -> Row<T, Cols>

where T: Clone,

returns a newly allocated row holding the cloned values of self

pub fn to_owned(&self) -> Row<T::Canonical, Cols>

where T: Conjugate,

returns a newly allocated row holding the (possibly conjugated) values of self

impl<'a, T, Rows: Shape> Row<Ref<'a, T, Rows, ContiguousFwd>>

pub fn as_slice(self) -> &'a [T]

returns a reference over the elements as a slice

impl<'a, 'ROWS, T> Row<Ref<'a, T, Dim<'ROWS>, ContiguousFwd>>

pub fn as_array(self) -> &'a Array<'ROWS, T>

returns a reference over the elements as a lifetime-bound slice

impl<'a, T, Cols: Shape, CStride: Stride> Row<Ref<'a, T, Cols, CStride>>

where T: RealField,

pub fn max(&self) -> Option<T>

Returns the maximum element in the row, or None if the row is empty

pub fn min(&self) -> Option<T>

Returns the minimum element in the row, or None if the row is empty

impl<Inner> Row<Inner>

pub fn from_inner_ref(inner: &Inner) -> &Self

wrap by reference

pub fn from_inner_mut(inner: &mut Inner) -> &mut Self

wrap by mutable reference

Trait Implementations

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Add<&Row<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the + operator.

fn add(self, rhs: &Row<R>) -> Self::Output

Performs the + operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Add<&Row<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the + operator.

fn add(self, rhs: &Row<R>) -> Self::Output

Performs the + operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Add<Row<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the + operator.

fn add(self, rhs: Row<R>) -> Self::Output

Performs the + operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Add<Row<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the + operator.

fn add(self, rhs: Row<R>) -> Self::Output

Performs the + operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> AddAssign<&Row<R>> for Row<L>

fn add_assign(&mut self, rhs: &Row<R>)

Performs the += operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> AddAssign<Row<R>> for Row<L>

fn add_assign(&mut self, rhs: Row<R>)

Performs the += operation.

impl<Inner: Clone> Clone for Row<Inner>

fn clone(&self) -> Row<Inner>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Inner: Debug> Debug for Row<Inner>

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

Formats the value using the given formatter.

impl<Inner> Deref for Row<Inner>

type Target = Inner

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Inner> DerefMut for Row<Inner>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, Cols: Shape, D: Distribution<T>> Distribution<Row<Own<T, Cols>>> for CwiseRowDistribution<Cols, D>

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Row<T, Cols>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Div<&Scale<T>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the / operator.

fn div(self, rhs: &Scale<T>) -> Self::Output

Performs the / operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Div<&Scale<T>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the / operator.

fn div(self, rhs: &Scale<T>) -> Self::Output

Performs the / operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Div<&f64> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Div<&f64> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Div<Scale<T>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the / operator.

fn div(self, rhs: Scale<T>) -> Self::Output

Performs the / operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Div<Scale<T>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the / operator.

fn div(self, rhs: Scale<T>) -> Self::Output

Performs the / operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Div<f64> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Div<f64> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> DivAssign<&Scale<T>> for Row<L>

fn div_assign(&mut self, rhs: &Scale<T>)

Performs the /= operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> DivAssign<&f64> for Row<L>

fn div_assign(&mut self, rhs: &f64)

Performs the /= operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> DivAssign<Scale<T>> for Row<L>

fn div_assign(&mut self, rhs: Scale<T>)

Performs the /= operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> DivAssign<f64> for Row<L>

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl<T, Cols: Shape, CStride: Stride, Inner: for<'short> Reborrow<'short, Target = Ref<'short, T, Cols, CStride>>> Index<<Cols as ShapeIdx>::Idx<usize>> for Row<Inner>

type Output = T

The returned type after indexing.

fn index(&self, col: Idx<Cols>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, Cols: Shape, CStride: Stride, Inner: for<'short> Reborrow<'short, Target = Ref<'short, T, Cols, CStride>> + for<'short> ReborrowMut<'short, Target = Mut<'short, T, Cols, CStride>>> IndexMut<<Cols as ShapeIdx>::Idx<usize>> for Row<Inner>

fn index_mut(&mut self, col: Idx<Cols>) -> &mut Self::Output

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

impl<Inner: IntoConst> IntoConst for Row<Inner>

type Target = Row<<Inner as IntoConst>::Target>

fn into_const(self) -> Self::Target

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RRStride>>> Mul<&Col<R>> for &Row<L>

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: &Col<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RRStride>>> Mul<&Col<R>> for Row<L>

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: &Col<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for &Row<L>

type Output = Row<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<&Diag<R>> for Row<L>

type Output = Row<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Diag<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, Cols, RRStride, RCStride>>> Mul<&Mat<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Mat<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, Cols, RRStride, RCStride>>> Mul<&Mat<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Mat<R>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<&Perm<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Perm<R>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<&Perm<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Perm<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<&Row<R>> for &Col<L>

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, RT: Conjugate<Canonical = T>, RCStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<&Row<R>> for &Scale<T>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, RT: Conjugate<Canonical = T>, RCStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<&Row<R>> for &f64

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<&Row<R>> for Col<L>

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, RT: Conjugate<Canonical = T>, RCStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<&Row<R>> for Scale<T>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, RT: Conjugate<Canonical = T>, RCStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<&Row<R>> for f64

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Mul<&Scale<T>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scale<T>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Mul<&Scale<T>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scale<T>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<&SparseColMat<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<&SparseColMat<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseColMat<R>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<&SparseRowMat<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseRowMat<R>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<&SparseRowMat<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: &SparseRowMat<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Mul<&f64> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Mul<&f64> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RRStride>>> Mul<Col<R>> for &Row<L>

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: Col<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RRStride>>> Mul<Col<R>> for Row<L>

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: Col<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for &Row<L>

type Output = Row<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: Diag<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Dim: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Dim, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Dim, RStride>>> Mul<Diag<R>> for Row<L>

type Output = Row<Own<T, Dim>>

The resulting type after applying the * operator.

fn mul(self, rhs: Diag<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, Cols, RRStride, RCStride>>> Mul<Mat<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Mat<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, Cols, RRStride, RCStride>>> Mul<Mat<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Mat<R>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<Perm<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Perm<R>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, Cols>>> Mul<Perm<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Perm<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<Row<R>> for &Col<L>

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, RT: Conjugate<Canonical = T>, RCStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<Row<R>> for &Scale<T>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, RT: Conjugate<Canonical = T>, RCStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<Row<R>> for &f64

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Rows: Shape, Cols: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<Row<R>> for Col<L>

type Output = Mat<Own<T, Rows, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, RT: Conjugate<Canonical = T>, RCStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<Row<R>> for Scale<T>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, RT: Conjugate<Canonical = T>, RCStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Mul<Row<R>> for f64

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Row<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Mul<Scale<T>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<T>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Mul<Scale<T>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: Scale<T>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<SparseColMat<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<SparseColMat<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: SparseColMat<R>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<SparseRowMat<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: SparseRowMat<R>) -> Self::Output

Performs the * operation.

impl<I: Index, T: ComplexField, Cols: Shape, Depth: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Depth, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, I, RT, Depth, Cols>>> Mul<SparseRowMat<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

fn mul(self, rhs: SparseRowMat<R>) -> Self::Output

Performs the * operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Mul<f64> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>> Mul<f64> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> MulAssign<&Scale<T>> for Row<L>

fn mul_assign(&mut self, rhs: &Scale<T>)

Performs the *= operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> MulAssign<&f64> for Row<L>

fn mul_assign(&mut self, rhs: &f64)

Performs the *= operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> MulAssign<Scale<T>> for Row<L>

fn mul_assign(&mut self, rhs: Scale<T>)

Performs the *= operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>> MulAssign<f64> for Row<L>

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl<T: Conjugate, Cols: Shape, CStride: Stride, Inner: for<'a> Reborrow<'a, Target = Ref<'a, T, Cols, CStride>>> Neg for &Row<Inner>

type Output = Row<Own<<T as Conjugate>::Canonical, Cols>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Conjugate, Cols: Shape, CStride: Stride, Inner: for<'a> Reborrow<'a, Target = Ref<'a, T, Cols, CStride>>> Neg for Row<Inner>

type Output = Row<Own<<T as Conjugate>::Canonical, Cols>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<LT: PartialEq<RT>, LCols: Shape, LCStride: Stride, RT, RCols: Shape, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, LCols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, RCols, RCStride>>> PartialEq<Row<R>> for Row<L>

fn eq(&self, other: &Row<R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'short, Inner: Reborrow<'short>> Reborrow<'short> for Row<Inner>

type Target = Row<<Inner as Reborrow<'short>>::Target>

fn rb(&'short self) -> Self::Target

impl<'short, Inner: ReborrowMut<'short>> ReborrowMut<'short> for Row<Inner>

type Target = Row<<Inner as ReborrowMut<'short>>::Target>

fn rb_mut(&'short mut self) -> Self::Target

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Sub<&Row<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the - operator.

fn sub(self, rhs: &Row<R>) -> Self::Output

Performs the - operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Sub<&Row<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the - operator.

fn sub(self, rhs: &Row<R>) -> Self::Output

Performs the - operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Sub<Row<R>> for &Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the - operator.

fn sub(self, rhs: Row<R>) -> Self::Output

Performs the - operation.

impl<T: ComplexField, Cols: Shape, LT: Conjugate<Canonical = T>, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> Sub<Row<R>> for Row<L>

type Output = Row<Own<T, Cols>>

The resulting type after applying the - operator.

fn sub(self, rhs: Row<R>) -> Self::Output

Performs the - operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> SubAssign<&Row<R>> for Row<L>

fn sub_assign(&mut self, rhs: &Row<R>)

Performs the -= operation.

impl<T: ComplexField, Cols: Shape, LCStride: Stride, RT: Conjugate<Canonical = T>, RCStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Cols, LCStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Cols, RCStride>>> SubAssign<Row<R>> for Row<L>

fn sub_assign(&mut self, rhs: Row<R>)

Performs the -= operation.

impl<Inner: Copy> Copy for Row<Inner>