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(),
• j < self.ncols().

Otherwise, the behavior is undefined.

pub unsafe fn write_at_unchecked(&mut self, i: usize, j: usize, value: T)

Writes the given value to the matrix at position (i, j) in the matrix, assuming it falls within its bounds with no bound checks.

Safety

Requires that

• i < self.nrows(),
• j < self.ncols().

Otherwise, the behavior is undefined.

pub fn write_at(&mut self, i: usize, j: usize, value: T)

Writes the given value to the matrix at position (i, j) in the matrix, or panics if the indices are out of bounds.

Panics

Requires that

• i < self.nrows(),
• j < self.ncols().

Otherwise, it panics.

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(),
• 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(),
• 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(),
• j <= self.ncols().

Otherwise, it panics.

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

Splits the matrix horizontally into two parts in the following order: top, bottom.

Panics

Requires that

• i <= self.nrows(),

Otherwise, the behavior is undefined.

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

Splits the matrix horizontally into two parts in the following order: top, bottom.

Panics

Requires that

• i <= self.nrows(),

Otherwise, it panics.

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

Splits the matrix vertically into two parts in the following order: left, right.

Panics

Requires that

• j <= self.nrows(),

Otherwise, the behavior is undefined.

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

Splits the matrix vertically into two parts in the following order: left, right.

Panics

Requires that

• j <= self.nrows(),

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(),
• 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 conjugate(self) -> MatMut<'a, T::Conj>where T: Conjugate,

Returns the conjugate of self.

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

Returns the conjugate transpose of self.

pub fn raw_with_conj(self) -> (MatMut<'a, T::Num>, Conj)where T: Conjugate,

Returns the raw representation of self, along with whether it should be conjugated or not.

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 fn into_par_row_chunks( self, chunk_count: usize ) -> impl IndexedParallelIterator<Item = (usize, MatMut<'a, T>)>where T: Sync + Send,

Returns a parallel iterator over the rows of the matrix.

pub fn into_par_col_chunks( self, chunk_count: usize ) -> impl IndexedParallelIterator<Item = (usize, MatMut<'a, T>)>where T: Sync + Send,

Returns a parallel iterator over the rows 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,
• 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,
• 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.

pub fn as_ref(&self) -> MatRef<'_, T>

Returns a view over the matrix.

pub fn as_mut(&mut self) -> MatMut<'_, T>

Returns a mutable view over the matrix.

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

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

Trait Implementations

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Add<&'a Mat<U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Mat<U>) -> Self::Output

Performs the + operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Add<Mat<U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the + operator.

fn add(self, rhs: Mat<U>) -> Self::Output

Performs the + operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Add<MatMut<'a, U>> for &'a Mat<T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the + operator.

fn add(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the + operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Add<MatMut<'a, U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the + operator.

fn add(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the + operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Add<MatMut<'a, U>> for Mat<T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the + operator.

fn add(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the + operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Add<MatMut<'a, U>> for MatRef<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the + operator.

fn add(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the + operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Add<MatRef<'a, U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the + operator.

fn add(self, rhs: MatRef<'a, U>) -> Self::Output

Performs the + operation.

impl<'a, T: 'static, U: 'static> Coerce<MatMut<'a, U>> for MatMut<'a, T>

fn coerce(self) -> MatMut<'a, U>

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, T: Conjugate, U: Conjugate<Num = T::Num>> Mul<&'a Mat<U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Mat<U>) -> Self::Output

Performs the * operation.

impl Mul<Complex<f32>> for MatMut<'_, ComplexConj<f32>>

type Output = Mat<Complex<f32>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Complex<f32>> for MatMut<'_, c32>

type Output = Mat<Complex<f32>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Complex<f64>> for MatMut<'_, ComplexConj<f64>>

type Output = Mat<Complex<f64>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Complex<f64>> for MatMut<'_, c64>

type Output = Mat<Complex<f64>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Mul<Mat<U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<MatMut<'_, Complex<f32>>> for c32

type Output = Mat<Complex<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, c32>) -> Self::Output

Performs the * operation.

impl Mul<MatMut<'_, Complex<f32>>> for f32

type Output = Mat<Complex<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, c32>) -> Self::Output

Performs the * operation.

impl Mul<MatMut<'_, Complex<f64>>> for c64

type Output = Mat<Complex<f64>>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, c64>) -> Self::Output

Performs the * operation.

impl Mul<MatMut<'_, Complex<f64>>> for f64

type Output = Mat<Complex<f64>>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, c64>) -> Self::Output

Performs the * operation.

impl Mul<MatMut<'_, ComplexConj<f32>>> for c32

type Output = Mat<Complex<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, ComplexConj<f32>>) -> Self::Output

Performs the * operation.

impl Mul<MatMut<'_, ComplexConj<f32>>> for f32

type Output = Mat<Complex<f32>>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, ComplexConj<f32>>) -> Self::Output

Performs the * operation.

impl Mul<MatMut<'_, ComplexConj<f64>>> for c64

type Output = Mat<Complex<f64>>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, ComplexConj<f64>>) -> Self::Output

Performs the * operation.

impl Mul<MatMut<'_, ComplexConj<f64>>> for f64

type Output = Mat<Complex<f64>>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, ComplexConj<f64>>) -> Self::Output

Performs the * operation.

impl Mul<MatMut<'_, f32>> for f32

type Output = Mat<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, f32>) -> Self::Output

Performs the * operation.

impl Mul<MatMut<'_, f64>> for f64

type Output = Mat<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'_, f64>) -> Self::Output

Performs the * operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Mul<MatMut<'a, U>> for &'a Mat<T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the * operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Mul<MatMut<'a, U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the * operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Mul<MatMut<'a, U>> for Mat<T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the * operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Mul<MatMut<'a, U>> for MatRef<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the * operator.

fn mul(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the * operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Mul<MatRef<'a, U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the * operator.

fn mul(self, rhs: MatRef<'a, U>) -> Self::Output

Performs the * operation.

impl Mul<f32> for MatMut<'_, ComplexConj<f32>>

type Output = Mat<Complex<f32>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for MatMut<'_, c32>

type Output = Mat<Complex<f32>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for MatMut<'_, f32>

type Output = Mat<f32>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for MatMut<'_, ComplexConj<f64>>

type Output = Mat<Complex<f64>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for MatMut<'_, c64>

type Output = Mat<Complex<f64>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for MatMut<'_, f64>

type Output = Mat<f64>

The resulting type after applying the * operator.

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

Performs the * operation.

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: Copy + Mul<U::Num, Output = U::Num>, U: Conjugate> Scale<MatMut<'a, U>> for T

type Output = Mat<<U as Conjugate>::Num>

fn scale(self, rhs: MatMut<'a, U>) -> Self::Output

Scale a matrix rhs by self.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Sub<&'a Mat<U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Mat<U>) -> Self::Output

Performs the - operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Sub<Mat<U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the - operator.

fn sub(self, rhs: Mat<U>) -> Self::Output

Performs the - operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Sub<MatMut<'a, U>> for &'a Mat<T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the - operator.

fn sub(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the - operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Sub<MatMut<'a, U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the - operator.

fn sub(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the - operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Sub<MatMut<'a, U>> for Mat<T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the - operator.

fn sub(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the - operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Sub<MatMut<'a, U>> for MatRef<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the - operator.

fn sub(self, rhs: MatMut<'a, U>) -> Self::Output

Performs the - operation.

impl<'a, T: Conjugate, U: Conjugate<Num = T::Num>> Sub<MatRef<'a, U>> for &'a MatMut<'a, T>where T::Num: ComplexField,

type Output = Mat<<T as Conjugate>::Num>

The resulting type after applying the - operator.

fn sub(self, rhs: MatRef<'a, U>) -> Self::Output

Performs the - operation.

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

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