Struct faer_core::MatMut

pub struct MatMut<'a, T> { /* private fields */ }

Mutable matrix view with general row and column strides.

For usage examples, see MatRef.

Implementations

impl<'a, T> MatMut<'a, T>

pub unsafe fn from_raw_parts(
    ptr: *mut T,
    nrows: usize,
    ncols: usize,
    row_stride: isize,
    col_stride: isize
) -> Self

Returns a mutable matrix slice from the given arguments.
ptr: pointer to the first element of the matrix.
nrows: number of rows of the matrix.
ncols: number of columns of the matrix.
row_stride: offset between the first elements of two successive rows in the matrix. col_stride: offset between the first elements of two successive columns in the matrix.

Safety

ptr must be non null and properly aligned for type T.
For each i < nrows and j < ncols,
ptr.offset(i as isize * row_stride + j as isize * col_stride) must point to a valid initialized object of type T, unless memory pointing to that address is never read. Additionally, when (i, j) != (0, 0), this pointer is never equal to ptr (no self aliasing).
The referenced memory must not be accessed by another pointer which was not derived from the return value, during the lifetime 'a.

pub fn as_ptr(self) -> *mut T

Returns a mutable pointer to the first (top left) element of the matrix.

pub fn nrows(&self) -> usize

Returns the number of rows of the matrix.

pub fn ncols(&self) -> usize

Returns the number of columns of the matrix.

pub fn row_stride(&self) -> isize

Returns the offset between the first elements of two successive rows in the matrix.

pub fn col_stride(&self) -> isize

Returns the offset between the first elements of two successive columns in the matrix.

pub fn ptr_at(self, i: usize, j: usize) -> *mut T

Returns a mutable pointer to the element at position (i, j) in the matrix.

pub unsafe fn ptr_in_bounds_at_unchecked(self, i: usize, j: usize) -> *mut T

Returns a mutable pointer to the element at position (i, j) in the matrix, assuming it falls within its bounds with no bound checks.

Safety

Requires that i < self.nrows() and j < self.ncols().

Otherwise, the behavior is undefined.

pub fn ptr_in_bounds_at(self, i: usize, j: usize) -> *mut T

Returns a mutable pointer to the element at position (i, j) in the matrix, while asserting that it falls within its bounds.

Panics

Requires that i < self.nrows() and j < self.ncols().

Otherwise, it panics.

pub unsafe fn split_at_unchecked(
    self,
    i: usize,
    j: usize
) -> (Self, Self, Self, Self)

Splits the matrix into four corner parts in the following order: top left, top right, bottom left, bottom right.

Safety

Requires that i <= self.nrows() and j <= self.ncols().

Otherwise, the behavior is undefined.

pub fn split_at(self, i: usize, j: usize) -> (Self, Self, Self, Self)

Splits the matrix into four corner parts in the following order: top left, top right, bottom left, bottom right.

Panics

Requires that i <= self.nrows() and j <= self.ncols().

Otherwise, it panics.

pub unsafe fn get_unchecked(self, i: usize, j: usize) -> &'a mut T

Returns a mutable reference to the element at position (i, j), with no bound checks.

Safety

Requires that i < self.nrows() and j < self.ncols().

Otherwise, the behavior is undefined.

pub fn get(self, i: usize, j: usize) -> &'a mut T

Returns a mutable reference to the element at position (i, j), or panics if the indices are out of bounds.

pub unsafe fn row_unchecked(self, i: usize) -> RowMut<'a, T>

Returns the i-th row of the matrix, with no bound checks.

Safety

Requires that i < self.nrows().

Otherwise, the behavior is undefined.

pub fn row(self, i: usize) -> RowMut<'a, T>

Returns the i-th row of the matrix.

Panics

Requires that i < self.nrows().

Otherwise, it panics.

pub unsafe fn col_unchecked(self, j: usize) -> ColMut<'a, T>

Returns the j-th column of the matrix, with no bound checks.

Safety

Requires that j < self.ncols().

Otherwise, the behavior is undefined.

pub fn col(self, j: usize) -> ColMut<'a, T>

Returns the j-th column of the matrix.

Panics

Requires that j < self.ncols().

Otherwise, it panics.

pub fn transpose(self) -> MatMut<'a, T>

Returns the transpose of self.

pub fn reverse_rows(self) -> Self

Returns a matrix whose rows are the the rows of the input matrix in reverse order.

pub fn reverse_cols(self) -> Self

Returns a matrix whose columns are the the columns of the input matrix in reverse order.

pub fn reverse_rows_and_cols(self) -> Self

Returns a matrix whose rows and columns are the the rows and columns of the input matrix in reverse order.

pub unsafe fn diagonal_unchecked(self) -> ColMut<'a, T>

Returns the diagonal of the matrix, as a column vector.

Safety

Requires that the matrix be square.

Otherwise, the behavior is undefined.

pub fn diagonal(self) -> ColMut<'a, T>

Returns the diagonal of the matrix, as a column vector.

Panics

Requires that the matrix be square.

Otherwise, it panics.

pub fn into_row_iter(self) -> RowIterMut<'a, T>

Returns an iterator over the rows of the matrix.

pub fn into_col_iter(self) -> ColIterMut<'a, T>

Returns an iterator over the columns of the matrix.

pub unsafe fn submatrix_unchecked(
    self,
    i: usize,
    j: usize,
    nrows: usize,
    ncols: usize
) -> Self

Returns a view over a submatrix of self, starting at position (i, j) with dimensions (nrows, ncols).

Safety

Requires that i <= self.nrows(),
j <= self.ncols(),
nrows <= self.nrows() - i
and ncols <= self.ncols() - j.

Otherwise, the behavior is undefined.

pub fn submatrix(self, i: usize, j: usize, nrows: usize, ncols: usize) -> Self

Returns a view over a submatrix of self, starting at position (i, j) with dimensions (nrows, ncols).

Panics

Requires that i <= self.nrows(),
j <= self.ncols(),
nrows <= self.nrows() - i
and ncols <= self.ncols() - j.

Otherwise, it panics.

pub fn cwise(self) -> ZipMat<(Self,)>

Returns a thin wrapper that can be used to execute coefficientwise operations on matrices.

impl<'a, T> MatMut<'a, Complex<T>>

pub fn into_real_imag(self) -> (MatMut<'a, T>, MatMut<'a, T>)

Trait Implementations

impl<'short, 'a, T> CwiseMat<'short, &'short MatMut<'a, T>> for MatMut<'a, T>

type Item = &'short mut T

fn nrows(&self) -> usize

fn ncols(&self) -> usize

fn is_col_major(&self) -> bool

fn is_row_major(&self) -> bool

unsafe fn get_unchecked(&'short mut self, i: usize, j: usize) -> Self::Item

unsafe fn get_col_major_unchecked(
    &'short mut self,
    i: usize,
    j: usize
) -> Self::Item

unsafe fn get_row_major_unchecked(
    &'short mut self,
    i: usize,
    j: usize
) -> Self::Item

fn transpose(self) -> Self

impl<'a, T: Debug + 'static> Debug for MatMut<'a, T>

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

Formats the value using the given formatter.

impl<'a, T> Index<(usize, usize)> for MatMut<'a, T>

type Output = T

The returned type after indexing.

fn index(&self, (i, j): (usize, usize)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, T> IndexMut<(usize, usize)> for MatMut<'a, T>

fn index_mut(&mut self, (i, j): (usize, usize)) -> &mut Self::Output

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

impl<'a, T> IntoConst for MatMut<'a, T>

type Target = MatRef<'a, T>

fn into_const(self) -> Self::Target

impl<'a, U, T: PartialEq<U>> PartialEq<MatMut<'a, U>> for MatMut<'a, T>

fn eq(&self, other: &MatMut<'a, U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, U, T: PartialEq<U>> PartialEq<MatMut<'a, U>> for MatRef<'a, T>

fn eq(&self, other: &MatMut<'a, U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, U, T: PartialEq<U>> PartialEq<MatRef<'a, U>> for MatMut<'a, T>

fn eq(&self, other: &MatRef<'a, U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'b, 'a, T> Reborrow<'b, &'b MatMut<'a, T>> for MatMut<'a, T>

type Target = MatRef<'b, T>

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

impl<'b, 'a, T> ReborrowMut<'b, &'b MatMut<'a, T>> for MatMut<'a, T>

type Target = MatMut<'b, T>

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

impl<'a, T: Send> Send for MatMut<'a, T>

impl<'a, T: Sync> Sync for MatMut<'a, T>