Type Alias Row 

pub type Row<T, Cols = usize> = Row<Own<T, Cols>>;

heap allocated resizable row vector.

note

the memory layout of Row is guaranteed to be row-major, meaning that it has a column stride of 1.

Aliased Type

#[repr(transparent)]
pub struct Row<T, Cols = usize>(/* private fields */);

Implementations

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

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

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

pub fn zeros(ncols: Cols) -> Self

where T: ComplexField,

returns a new row with dimension ncols, filled with zeros

pub fn ones(ncols: Cols) -> Self

where T: ComplexField,

returns a new row with dimension ncols, filled with ones

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

where T: Clone,

returns a new row with dimension ncols, 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_ncols: 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_ncols: 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, ncols: 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<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<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 map<U>(&self, f: impl Fn(&T) -> U) -> Row<U, Cols>

pub fn for_each(&self, f: impl Fn(&T))

pub fn map_mut<U>(&mut self, f: impl FnMut(&mut T) -> U) -> Row<U, Cols>

pub fn for_each_mut(&mut self, f: impl FnMut(&mut T))

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

Trait Implementations

impl<T, Cols: Shape> AsMat<T> for Row<T, Cols>

fn zeros(_: One, cols: Cols) -> Self

where T: ComplexField,

returns a matrix with dimensions (rows, cols) filled with zeros

fn truncate(&mut self, _: One, cols: Self::Cols)

returns a matrix with dimensions (rows, cols) filled with zeros

impl<T, Cols: Shape> AsMatMut for Row<T, Cols>

fn as_mat_mut(&mut self) -> MatMut<'_, Self::T, One, Self::Cols>

returns a view over self

impl<T, Cols: Shape> AsMatRef for Row<T, Cols>

type Cols = Cols

column dimension type

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

owned matrix type

type Rows = One

row dimension type

type T = T

scalar type

fn as_mat_ref(&self) -> MatRef<'_, Self::T, One, Self::Cols>

returns a view over self

impl<T> FromIterator<T> for Row<T>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<'a, T, Len: Shape> IntoView for &'a mut Row<T, Len>

type Target = Row<Mut<'a, T, Len, ContiguousFwd>>

fn into_view(self) -> Self::Target

impl<'a, T, Len: Shape> IntoView for &'a Row<T, Len>

type Target = Row<Ref<'a, T, Len, ContiguousFwd>>

fn into_view(self) -> Self::Target