Struct feanor_math::matrix::submatrix::SubmatrixMut

pub struct SubmatrixMut<'a, V, T>
where
    V: 'a + AsPointerToSlice<T>,
{ /* private fields */ }

Implementations

impl<'a, V, T> SubmatrixMut<'a, V, T>

where V: 'a + AsPointerToSlice<T>,

pub fn submatrix(self, rows: Range<usize>, cols: Range<usize>) -> Self

pub fn restrict_rows(self, rows: Range<usize>) -> Self

pub fn restrict_cols(self, cols: Range<usize>) -> Self

pub fn split_rows( self, fst_rows: Range<usize>, snd_rows: Range<usize> ) -> (Self, Self)

pub fn split_cols( self, fst_cols: Range<usize>, snd_cols: Range<usize> ) -> (Self, Self)

pub fn row_iter(self) -> impl 'a + ExactSizeIterator<Item = &'a mut [T]>

pub fn col_iter(self) -> impl 'a + ExactSizeIterator<Item = ColumnMut<'a, V, T>>

pub fn at<'b>(&'b mut self, i: usize, j: usize) -> &'b mut T

pub fn row_at<'b>(&'b mut self, i: usize) -> &'b mut [T]

pub fn col_at<'b>(&'b mut self, j: usize) -> ColumnMut<'b, V, T>

pub fn reborrow<'b>(&'b mut self) -> SubmatrixMut<'b, V, T>

pub fn as_const<'b>(&'b self) -> Submatrix<'b, V, T>

pub fn col_count(&self) -> usize

pub fn row_count(&self) -> usize

impl<'a, V, T> SubmatrixMut<'a, V, T>

where V: 'a + Sync + AsPointerToSlice<T>, T: Send,

pub fn concurrent_row_iter( self ) -> impl 'a + ExactSizeIterator<Item = &'a mut [T]>

pub fn concurrent_col_iter( self ) -> impl 'a + ExactSizeIterator<Item = ColumnMut<'a, V, T>>

impl<'a, T> SubmatrixMut<'a, AsFirstElement<T>, T>

pub fn new(data: &'a mut [T], row_count: usize, col_count: usize) -> Self

impl<'a, T> SubmatrixMut<'a, Vec<T>, T>

pub fn new(data: &'a mut [Vec<T>]) -> Self

impl<'a, T, const N: usize> SubmatrixMut<'a, [T; N], T>

pub fn new(data: &'a mut [[T; N]]) -> Self

Trait Implementations

impl<'a, V, R> Matrix<R> for SubmatrixMut<'a, V, R::Element>

where V: 'a + AsPointerToSlice<R::Element>, R: ?Sized + RingBase,

fn entry_at(&self, i: usize, j: usize) -> &<R as RingBase>::Element

fn col_count(&self) -> usize

fn row_count(&self) -> usize

fn format<'a, S>(&'a self, ring: &'a S) -> MatrixDisplayWrapper<'a, R, Self>

where S: RingStore<Type = R>,

fn matrix_eq<M, S>(&self, other: &M, ring: S) -> bool

where M: Matrix<R>, S: RingStore<Type = R>,