Struct Col &nbsp; Copy item path

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

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

creates a column view over the given element

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

creates a ColMut from slice views over the column vector data, the result has the same number of rows as the length of the input slice

impl<'a, T, Rows: Shape, RStride: Stride> Col<Mut<'a, T, Rows, RStride>>

pub const unsafe fn from_raw_parts_mut( ptr: *mut T, nrows: Rows, row_stride: RStride, ) -> Self

creates a ColMut 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(ptr, nrows, 1, row_stride, 0)]

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

returns a pointer to the column data

pub fn nrows(&self) -> Rows

returns the number of rows of the column

pub fn ncols(&self) -> usize

returns the number of columns of the column (always 1)

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

returns the number of rows and columns of the column

pub fn row_stride(&self) -> RStride

returns the row stride of the column, specified in number of elements, not in bytes

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

returns a raw pointer to the element at the given index

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

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

§safety

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

row < self.nrows()

pub fn split_at_row( self, row: IdxInc<Rows>, ) -> (ColRef<'a, T, usize, RStride>, ColRef<'a, T, usize, RStride>)

see ColRef::split_at_row

pub fn transpose(self) -> RowRef<'a, T, Rows, RStride>

pub fn conjugate(self) -> ColRef<'a, T::Conj, Rows, RStride>
where T: Conjugate,

see ColRef::conjugate

pub fn canonical(self) -> ColRef<'a, T::Canonical, Rows, RStride>
where T: Conjugate,

see ColRef::canonical

pub fn adjoint(self) -> RowRef<'a, T::Conj, Rows, RStride>
where T: Conjugate,

see ColRef::adjoint

pub fn get<RowRange>( self, row: RowRange, ) -> <ColRef<'a, T, Rows, RStride> as ColIndex<RowRange>>::Target
where ColRef<'a, T, Rows, RStride>: ColIndex<RowRange>,

see ColRef::get

pub unsafe fn get_unchecked<RowRange>( self, row: RowRange, ) -> <ColRef<'a, T, Rows, RStride> as ColIndex<RowRange>>::Target
where ColRef<'a, T, Rows, RStride>: ColIndex<RowRange>,

see ColRef::get_unchecked

pub fn reverse_rows(self) -> ColRef<'a, T, Rows, RStride::Rev>

see ColRef::reverse_rows

pub fn subrows<V: Shape>( self, row_start: IdxInc<Rows>, nrows: V, ) -> ColRef<'a, T, V, RStride>

see ColRef::subrows

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

see ColRef::iter

pub fn par_iter(self) -> impl 'a + IndexedParallelIterator<Item = &'a T>
where T: Sync, Rows: 'a,

see ColRef::par_iter

pub fn par_partition( self, count: usize, ) -> impl 'a + IndexedParallelIterator<Item = ColRef<'a, T, usize, RStride>>
where T: Sync, Rows: 'a,

see ColRef::par_partition

pub fn try_as_col_major(self) -> Option<ColRef<'a, T, Rows, ContiguousFwd>>

pub fn try_as_col_major_mut(self) -> Option<ColMut<'a, T, Rows, ContiguousFwd>>

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

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

pub fn as_diagonal(self) -> DiagRef<'a, T, Rows, RStride>

impl<T, Rows: Shape, RStride: Stride, Inner: for<'short> ReborrowMut<'short, Target = Mut<'short, T, Rows, RStride>>> Col<Inner>

pub fn copy_from<RhsT: Conjugate<Canonical = T>>( &mut self, other: impl AsColRef<T = RhsT, Rows = Rows>, )
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

pub fn as_mut(&mut self) -> ColMut<'_, T, Rows, RStride>

returns a view over self

impl<'a, T, Rows: Shape, RStride: Stride> Col<Mut<'a, T, Rows, RStride>>

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

see ColRef::as_ptr

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

see ColRef::ptr_at

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

see ColRef::ptr_inbounds_at

pub fn split_at_row_mut( self, row: IdxInc<Rows>, ) -> (ColMut<'a, T, usize, RStride>, ColMut<'a, T, usize, RStride>)

see ColRef::split_at_row

pub fn transpose_mut(self) -> RowMut<'a, T, Rows, RStride>

pub fn conjugate_mut(self) -> ColMut<'a, T::Conj, Rows, RStride>
where T: Conjugate,

see ColRef::conjugate

pub fn canonical_mut(self) -> ColMut<'a, T::Canonical, Rows, RStride>
where T: Conjugate,

see ColRef::canonical

pub fn adjoint_mut(self) -> RowMut<'a, T::Conj, Rows, RStride>
where T: Conjugate,

see ColRef::adjoint

pub fn get_mut<RowRange>( self, row: RowRange, ) -> <ColMut<'a, T, Rows, RStride> as ColIndex<RowRange>>::Target
where ColMut<'a, T, Rows, RStride>: ColIndex<RowRange>,

see ColRef::get

pub unsafe fn get_mut_unchecked<RowRange>( self, row: RowRange, ) -> <ColMut<'a, T, Rows, RStride> as ColIndex<RowRange>>::Target
where ColMut<'a, T, Rows, RStride>: ColIndex<RowRange>,

see ColRef::get_unchecked

pub fn reverse_rows_mut(self) -> ColMut<'a, T, Rows, RStride::Rev>

see ColRef::reverse_rows

pub fn subrows_mut<V: Shape>( self, row_start: IdxInc<Rows>, nrows: V, ) -> ColMut<'a, T, V, RStride>

see ColRef::subrows

pub fn as_row_shape_mut<V: Shape>(self, nrows: V) -> ColMut<'a, T, V, RStride>

see ColRef::as_row_shape

pub fn as_dyn_rows_mut(self) -> ColMut<'a, T, usize, RStride>

see ColRef::as_dyn_rows

pub fn as_dyn_stride_mut(self) -> ColMut<'a, T, Rows, isize>

see ColRef::as_dyn_stride

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

see ColRef::iter

pub fn par_iter_mut(self) -> impl 'a + IndexedParallelIterator<Item = &'a mut T>
where T: Send, Rows: 'a,

see ColRef::par_iter

pub fn par_partition_mut( self, count: usize, ) -> impl 'a + IndexedParallelIterator<Item = ColMut<'a, T, usize, RStride>>
where T: Send, Rows: 'a,

see ColRef::par_partition

pub fn as_diagonal_mut(self) -> DiagMut<'a, T, Rows, RStride>

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

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

returns a reference over the elements as a slice

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

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

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

impl<'a, T, Rows: Shape> Col<Mut<'a, T, Rows>>
where T: RealField,

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

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

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

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

impl<T, Rows: Shape> Col<Own<T, Rows>>

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

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

pub fn zeros(nrows: Rows) -> Self
where T: ComplexField,

returns a new column with dimension nrows, filled with zeros

pub fn ones(nrows: Rows) -> Self
where T: ComplexField,

returns a new column with dimension nrows, filled with ones

pub fn full(nrows: Rows, value: T) -> Self
where T: Clone,

returns a new column with dimension nrows, filled with value

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

reserves the minimum capacity for row_capacity rows 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 row_capacity rows without reallocating. does nothing if the capacity is already sufficient

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

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

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

truncates the column so that its new dimensions are new_nrows.
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_nrows > self.nrows()

pub fn into_row_shape<V: Shape>(self, nrows: V) -> Col<T, V>

see ColRef::as_row_shape

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

pub fn into_transpose(self) -> Row<T, Rows>

impl<T, Rows: Shape> Col<Own<T, Rows>>

pub fn nrows(&self) -> Rows

returns the number of rows of the column

pub fn ncols(&self) -> usize

returns the number of columns of the column (always 1)

impl<T, Rows: Shape> Col<Own<T, Rows>>

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

see ColRef::as_ptr

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

see ColRef::shape

pub fn row_stride(&self) -> isize

see ColRef::row_stride

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

see ColRef::ptr_at

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

see ColRef::ptr_inbounds_at

pub fn split_at_row( &self, row: IdxInc<Rows>, ) -> (ColRef<'_, T, usize>, ColRef<'_, T, usize>)

see ColRef::split_at_row

pub fn transpose(&self) -> RowRef<'_, T, Rows>

pub fn conjugate(&self) -> ColRef<'_, T::Conj, Rows>
where T: Conjugate,

see ColRef::conjugate

pub fn canonical(&self) -> ColRef<'_, T::Canonical, Rows>
where T: Conjugate,

see ColRef::canonical

pub fn adjoint(&self) -> RowRef<'_, T::Conj, Rows>
where T: Conjugate,

see ColRef::adjoint

pub fn get<RowRange>( &self, row: RowRange, ) -> <ColRef<'_, T, Rows> as ColIndex<RowRange>>::Target
where for<'a> ColRef<'a, T, Rows>: ColIndex<RowRange>,

see ColRef::get

pub unsafe fn get_unchecked<RowRange>( &self, row: RowRange, ) -> <ColRef<'_, T, Rows> as ColIndex<RowRange>>::Target
where for<'a> ColRef<'a, T, Rows>: ColIndex<RowRange>,

see ColRef::get_unchecked

pub fn reverse_rows(&self) -> ColRef<'_, T, Rows>

see ColRef::reverse_rows

pub fn subrows<V: Shape>( &self, row_start: IdxInc<Rows>, nrows: V, ) -> ColRef<'_, T, V>

see ColRef::subrows

pub fn as_row_shape<V: Shape>(&self, nrows: V) -> ColRef<'_, T, V>

see ColRef::as_row_shape

pub fn as_dyn_rows(&self) -> ColRef<'_, T, usize>

see ColRef::as_dyn_rows

pub fn as_dyn_stride(&self) -> ColRef<'_, T, Rows, isize>

see ColRef::as_dyn_stride

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

see ColRef::iter

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

see ColRef::par_iter

pub fn par_partition( &self, count: usize, ) -> impl '_ + IndexedParallelIterator<Item = ColRef<'_, T, usize>>
where T: Sync,

see ColRef::par_partition

pub fn try_as_col_major(&self) -> Option<ColRef<'_, T, Rows, ContiguousFwd>>

pub fn try_as_col_major_mut( &mut self, ) -> Option<ColMut<'_, T, Rows, ContiguousFwd>>

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

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

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

impl<T, Rows: Shape> Col<Own<T, Rows>>

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

see ColMut::as_ptr_mut

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

see ColMut::ptr_at_mut

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

see ColMut::ptr_inbounds_at_mut

pub fn split_at_row_mut( &mut self, row: IdxInc<Rows>, ) -> (ColMut<'_, T, usize>, ColMut<'_, T, usize>)

see ColMut::split_at_row_mut

pub fn transpose_mut(&mut self) -> RowMut<'_, T, Rows>

see ColMut::transpose_mut

pub fn conjugate_mut(&mut self) -> ColMut<'_, T::Conj, Rows>
where T: Conjugate,

see ColMut::conjugate_mut

pub fn canonical_mut(&mut self) -> ColMut<'_, T::Canonical, Rows>
where T: Conjugate,

see ColMut::canonical_mut

pub fn adjoint_mut(&mut self) -> RowMut<'_, T::Conj, Rows>
where T: Conjugate,

see ColMut::adjoint_mut

pub fn get_mut<RowRange>( &mut self, row: RowRange, ) -> <ColMut<'_, T, Rows> as ColIndex<RowRange>>::Target
where for<'a> ColMut<'a, T, Rows>: ColIndex<RowRange>,

see ColMut::get_mut

pub unsafe fn get_mut_unchecked<RowRange>( &mut self, row: RowRange, ) -> <ColMut<'_, T, Rows> as ColIndex<RowRange>>::Target
where for<'a> ColMut<'a, T, Rows>: ColIndex<RowRange>,

see ColMut::get_mut_unchecked

pub fn reverse_rows_mut(&mut self) -> ColMut<'_, T, Rows>

see ColMut::reverse_rows_mut

pub fn subrows_mut<V: Shape>( &mut self, row_start: IdxInc<Rows>, nrows: V, ) -> ColMut<'_, T, V>

see ColMut::subrows_mut

pub fn as_row_shape_mut<V: Shape>(&mut self, nrows: V) -> ColMut<'_, T, V>

see ColMut::as_row_shape_mut

pub fn as_dyn_rows_mut(&mut self) -> ColMut<'_, T, usize>

see ColMut::as_dyn_rows_mut

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

see ColMut::as_dyn_stride_mut

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

see ColMut::iter_mut

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

see ColMut::par_iter_mut

pub fn par_partition_mut( &mut self, count: usize, ) -> impl '_ + IndexedParallelIterator<Item = ColMut<'_, T, usize>>
where T: Send,

see ColMut::par_partition_mut

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

see ColMut::as_diagonal_mut

impl<T, Rows: Shape> Col<Own<T, Rows>>
where T: RealField,

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

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

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

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

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

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

creates a column view over the given element

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

creates a ColRef from slice views over the column vector data, the result has the same number of rows as the length of the input slice

impl<'a, T, Rows: Shape, RStride: Stride> Col<Ref<'a, T, Rows, RStride>>

pub const unsafe fn from_raw_parts( ptr: *const T, nrows: Rows, row_stride: RStride, ) -> Self

creates a ColRef 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, nrows, 1, row_stride, 0)]

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

returns a pointer to the column data

pub fn nrows(&self) -> Rows

returns the number of rows of the column

pub fn ncols(&self) -> usize

returns the number of columns of the column (always 1)

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

returns the number of rows and columns of the column

pub fn row_stride(&self) -> RStride

returns the row stride of the column, specified in number of elements, not in bytes

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

returns a raw pointer to the element at the given index

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

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

§safety

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

row < self.nrows()

pub fn split_at_row( self, row: IdxInc<Rows>, ) -> (ColRef<'a, T, usize, RStride>, ColRef<'a, T, usize, RStride>)

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

top
bottom

§panics

the function panics if the following condition is violated:

row <= self.nrows()

pub fn transpose(self) -> RowRef<'a, T, Rows, RStride>

returns a view over the transpose of self

pub fn conjugate(self) -> ColRef<'a, T::Conj, Rows, RStride>
where T: Conjugate,

returns a view over the conjugate of self

pub fn canonical(self) -> ColRef<'a, T::Canonical, Rows, RStride>
where T: Conjugate,

returns an unconjugated view over self

pub fn adjoint(self) -> RowRef<'a, T::Conj, Rows, RStride>
where T: Conjugate,

returns a view over the conjugate transpose of self

pub fn get<RowRange>( self, row: RowRange, ) -> <ColRef<'a, T, Rows, RStride> as ColIndex<RowRange>>::Target
where ColRef<'a, T, Rows, RStride>: ColIndex<RowRange>,

returns a reference to the element at the given index, or a subcolumn if row is a range

§panics

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

row must be contained in [0, self.nrows())

pub unsafe fn get_unchecked<RowRange>( self, row: RowRange, ) -> <ColRef<'a, T, Rows, RStride> as ColIndex<RowRange>>::Target
where ColRef<'a, T, Rows, RStride>: ColIndex<RowRange>,

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

§safety

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

row must be contained in [0, self.nrows())

pub fn reverse_rows(self) -> ColRef<'a, T, Rows, RStride::Rev>

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

pub fn subrows<V: Shape>( self, row_start: IdxInc<Rows>, nrows: V, ) -> ColRef<'a, T, V, RStride>

returns a view over the column starting at row row_start, and with number of rows nrows

§panics

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

row_start <= self.nrows()
nrows <= self.nrows() - row_start

pub fn as_row_shape<V: Shape>(self, nrows: V) -> ColRef<'a, T, V, RStride>

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

pub fn as_dyn_rows(self) -> ColRef<'a, T, usize, RStride>

returns the input column with dynamic row shape

pub fn as_dyn_stride(self) -> ColRef<'a, T, Rows, isize>

returns the input column with dynamic stride

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

returns an iterator over the elements of the column

pub fn par_iter(self) -> impl 'a + IndexedParallelIterator<Item = &'a T>
where T: Sync, Rows: 'a,

returns a parallel iterator over the elements of the column

pub fn par_partition( self, count: usize, ) -> impl 'a + IndexedParallelIterator<Item = ColRef<'a, T, usize, RStride>>
where T: Sync, Rows: 'a,

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

only available with the rayon feature

pub fn try_as_col_major(self) -> Option<ColRef<'a, T, Rows, ContiguousFwd>>

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

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

returns a matrix view over self

pub fn as_diagonal(self) -> DiagRef<'a, T, Rows, RStride>

interprets the column as a diagonal matrix

impl<T, Rows: Shape, RStride: Stride, Inner: for<'short> Reborrow<'short, Target = Ref<'short, T, Rows, RStride>>> Col<Inner>

pub fn cloned(&self) -> Col<T, Rows>
where T: Clone,

returns a newly allocated column holding the cloned values of self

pub fn to_owned(&self) -> Col<T::Canonical, Rows>
where T: Conjugate,

returns a newly allocated column holding the (possibly conjugated) values of 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 as_ref(&self) -> ColRef<'_, T, Rows, RStride>

returns a view over 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.

impl<'a, T, Rows: Shape> Col<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> Col<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, Rows: Shape, RStride: Stride> Col<Ref<'a, T, Rows, RStride>>
where T: RealField,

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

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

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

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

impl<Inner> Col<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, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Add<&Col<R>> for &Col<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the + operator.

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

Performs the + operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the + operator.

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

Performs the + operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the + operator.

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

Performs the + operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> AddAssign<&Col<R>> for Col<L>

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

Performs the += operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> AddAssign<Col<R>> for Col<L>

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

Performs the += operation. Read more

impl<Inner: Clone> Clone for Col<Inner>

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

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

impl<Inner: Debug> Debug for Col<Inner>

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

Formats the value using the given formatter. Read more

impl<Inner> Deref for Col<Inner>

type Target = Inner

The resulting type after dereferencing.

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

Dereferences the value.

impl<Inner> DerefMut for Col<Inner>

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

Mutably dereferences the value.

impl<T, Rows: Shape, D: Distribution<T>> Distribution<Col<Own<T, Rows>>> for CwiseColDistribution<Rows, D>

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

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. Read more

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 Read more

impl<T: ComplexField, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>> Div<&Scale<T>> for &Col<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T: ComplexField, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>> Div<&Scale<T>> for Col<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T: ComplexField, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>> Div<&f64> for &Col<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T: ComplexField, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>> Div<&f64> for Col<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T: ComplexField, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>> Div<Scale<T>> for &Col<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T: ComplexField, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>> Div<Scale<T>> for Col<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T: ComplexField, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>> Div<f64> for &Col<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T: ComplexField, Rows: Shape, LT: Conjugate<Canonical = T>, LRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, Rows, LRStride>>> Div<f64> for Col<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>> DivAssign<&Scale<T>> for Col<L>

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

Performs the /= operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>> DivAssign<&f64> for Col<L>

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

Performs the /= operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>> DivAssign<Scale<T>> for Col<L>

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

Performs the /= operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>> DivAssign<f64> for Col<L>

fn div_assign(&mut self, rhs: f64)

Performs the /= operation. Read more

impl<T, Rows: Shape, RStride: Stride, Inner: for<'short> Reborrow<'short, Target = Ref<'short, T, Rows, RStride>>> Index<<Rows as ShapeIdx>::Idx<usize>> for Col<Inner>

type Output = T

The returned type after indexing.

fn index(&self, row: Idx<Rows>) -> &Self::Output

Performs the indexing (container[index]) operation. Read more

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

fn index_mut(&mut self, row: Idx<Rows>) -> &mut Self::Output

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

impl<Inner: IntoConst> IntoConst for Col<Inner>

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

fn into_const(self) -> Self::Target

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

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

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<&Col<R>> for &Perm<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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. Read more

impl<T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<&Col<R>> for &Scale<T>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<&Col<R>> for &f64

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<&Col<R>> for Perm<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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. Read more

impl<T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<&Col<R>> for Scale<T>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<&Col<R>> for f64

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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. Read more

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. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<Col<R>> for &Perm<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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. Read more

impl<T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<Col<R>> for &Scale<T>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<Col<R>> for &f64

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

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

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<I: Index, T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, I, Rows>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<Col<R>> for Perm<L>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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. Read more

impl<T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<Col<R>> for Scale<T>

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Rows: Shape, RT: Conjugate<Canonical = T>, RRStride: Stride, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> Mul<Col<R>> for f64

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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. Read more

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. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>> MulAssign<&Scale<T>> for Col<L>

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

Performs the *= operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>> MulAssign<&f64> for Col<L>

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

Performs the *= operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>> MulAssign<Scale<T>> for Col<L>

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

Performs the *= operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>> MulAssign<f64> for Col<L>

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation. Read more

impl<T: Conjugate, Rows: Shape, RStride: Stride, Inner: for<'a> Reborrow<'a, Target = Ref<'a, T, Rows, RStride>>> Neg for &Col<Inner>

type Output = Col<Own<<T as Conjugate>::Canonical, Rows>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation. Read more

impl<T: Conjugate, Rows: Shape, RStride: Stride, Inner: for<'a> Reborrow<'a, Target = Ref<'a, T, Rows, RStride>>> Neg for Col<Inner>

type Output = Col<Own<<T as Conjugate>::Canonical, Rows>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation. Read more

impl<LT: PartialEq<RT>, LRows: Shape, LRStride: Stride, RT, RRows: Shape, RRStride: Stride, L: for<'a> Reborrow<'a, Target = Ref<'a, LT, LRows, LRStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, RRows, RRStride>>> PartialEq<Col<R>> for Col<L>

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

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

1.0.0 · Source§

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 Col<Inner>

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

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

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

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

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

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the - operator.

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

Performs the - operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the - operator.

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

Performs the - operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the - operator.

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

Performs the - operation. Read more

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

type Output = Col<Own<T, Rows>>

The resulting type after applying the - operator.

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

Performs the - operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> SubAssign<&Col<R>> for Col<L>

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

Performs the -= operation. Read more

impl<T: ComplexField, Rows: Shape, LRStride: Stride, RT: Conjugate<Canonical = T>, RRStride: Stride, L: for<'a> ReborrowMut<'a, Target = Mut<'a, T, Rows, LRStride>>, R: for<'a> Reborrow<'a, Target = Ref<'a, RT, Rows, RRStride>>> SubAssign<Col<R>> for Col<L>

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

Performs the -= operation. Read more

impl<Inner: Copy> Copy for Col<Inner>

Auto Trait Implementations§

impl<Inner> Freeze for Col<Inner>
where Inner: Freeze,

impl<Inner> RefUnwindSafe for Col<Inner>
where Inner: RefUnwindSafe,

impl<Inner> Send for Col<Inner>
where Inner: Send,

impl<Inner> Sync for Col<Inner>
where Inner: Sync,

impl<Inner> Unpin for Col<Inner>
where Inner: Unpin,

impl<Inner> UnwindSafe for Col<Inner>
where Inner: UnwindSafe,

Blanket Implementations§

impl<Rhs, Lhs, Output> AddByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Add<&'a Rhs, Output = Output>,

type Output = Output

fn add_by_ref(&self, rhs: &Rhs) -> <Lhs as AddByRef<Rhs>>::Output

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<M> AsColMut for M
where M: AsMatMut<Cols = One>,

fn as_col_mut( &mut self, ) -> Col<Mut<'_, <M as AsMatRef>::T, <M as AsMatRef>::Rows>>

returns a view over self

impl<M> AsColRef for M
where M: AsMatRef<Cols = One>,

fn as_col_ref(&self) -> Col<Ref<'_, <M as AsMatRef>::T, <M as AsMatRef>::Rows>>

returns a view over self

impl<M> AsRowMut for M
where M: AsMatMut<Rows = One>,

fn as_row_mut( &mut self, ) -> Row<Mut<'_, <M as AsMatRef>::T, <M as AsMatRef>::Cols>>

returns a view over self

impl<M> AsRowRef for M
where M: AsMatRef<Rows = One>,

fn as_row_ref(&self) -> Row<Ref<'_, <M as AsMatRef>::T, <M as AsMatRef>::Cols>>

returns a view over self

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> ByRef<T> for T

fn by_ref(&self) -> &T

impl<T> CloneToUninit for T
where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

impl<T> DistributionExt for T
where T: ?Sized,

fn rand<T>(&self, rng: &mut (impl ?Sized + Rng)) -> T
where Self: Distribution<T>,

impl<Rhs, Lhs, Output> DivByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Div<&'a Rhs, Output = Output>,

type Output = Output

fn div_by_ref(&self, rhs: &Rhs) -> <Lhs as DivByRef<Rhs>>::Output

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

impl<Rhs, Lhs, Output> MulByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Mul<&'a Rhs, Output = Output>,

type Output = Output

fn mul_by_ref(&self, rhs: &Rhs) -> <Lhs as MulByRef<Rhs>>::Output

impl<T, Output> NegByRef for T
where &'a T: for<'a> Neg<Output = Output>,

type Output = Output

fn neg_by_ref(&self) -> <T as NegByRef>::Output

impl<T> Pointable for T

const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)

The target type on which the method may be called.

impl<Rhs, Lhs, Output> SubByRef<Rhs> for Lhs
where &'a Lhs: for<'a> Sub<&'a Rhs, Output = Output>,

type Output = Output

fn sub_by_ref(&self, rhs: &Rhs) -> <Lhs as SubByRef<Rhs>>::Output

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V