Struct rulinalg::matrix::RowMut

pub struct RowMut<'a, T: 'a> { /* fields omitted */ }

Mutable row of a matrix.

This struct points to a mutable slice making up a row in a matrix. You can deref this struct to retrieve a MatrixSlice of the row.

Example

use rulinalg::matrix::BaseMatrixMut;

let mut mat = matrix![1.0, 2.0;
                      3.0, 4.0];

{
    let mut row = mat.row_mut(1);
    *row += 2.0;
}
let expected = matrix![1.0, 2.0;
                       5.0, 6.0];
assert_matrix_eq!(mat, expected);

Methods

impl<'a, T: 'a> RowMut<'a, T>

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

Returns the row as a slice.

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

Returns the row as a slice.

Methods from Deref<Target = MatrixSliceMut<'a, T>>

Trait Implementations

impl<'a, T> BaseMatrix<T> for RowMut<'a, T>

fn rows(&self) -> usize

Rows in the matrix.

fn cols(&self) -> usize

Columns in the matrix.

fn row_stride(&self) -> usize

Row stride in the matrix.

fn as_ptr(&self) -> *const T

Top left index of the matrix.

fn is_empty(&self) -> bool

Returns true if the matrix contais no elements

fn as_slice(&self) -> MatrixSlice<T>

Returns a MatrixSlice over the whole matrix.

unsafe fn get_unchecked(&self, index: [usize; 2]) -> &T

Get a reference to a point in the matrix without bounds checking.

fn col(&self, index: usize) -> Column<T>

Returns the column of a matrix at the given index. None if the index is out of bounds.

unsafe fn col_unchecked(&self, index: usize) -> Column<T>

Returns the column of a matrix at the given index without doing a bounds check.

fn row(&self, index: usize) -> Row<T>

Returns the row of a matrix at the given index.

unsafe fn row_unchecked(&self, index: usize) -> Row<T>

Returns the row of a matrix at the given index without doing unbounds checking

Important traits for SliceIter<'a, T>

impl<'a, T> Iterator for SliceIter<'a, T> type Item = &'a T;

fn iter<'a>(&self) -> SliceIter<'a, T> where
    T: 'a, 

Returns an iterator over the matrix data.

Important traits for Cols<'a, T>

impl<'a, T> Iterator for Cols<'a, T> type Item = Column<'a, T>;

fn col_iter(&self) -> Cols<T>

Iterate over the columns of the matrix.

Important traits for Rows<'a, T>

impl<'a, T> Iterator for Rows<'a, T> type Item = Row<'a, T>;

fn row_iter(&self) -> Rows<T>

Iterate over the rows of the matrix.

Important traits for Diagonal<'a, T, M>

impl<'a, T, M: BaseMatrix<T>> Iterator for Diagonal<'a, T, M> type Item = &'a T;

fn diag_iter(&self, k: DiagOffset) -> Diagonal<T, Self>

Iterate over diagonal entries

fn sum_rows(&self) -> Vector<T> where
    T: Copy + Zero + Add<T, Output = T>, 

The sum of the rows of the matrix.

fn sum_cols(&self) -> Vector<T> where
    T: Copy + Zero + Add<T, Output = T>, 

The sum of the columns of the matrix.

fn norm<N: MatrixNorm<T, Self>>(&self, norm: N) -> T where
    T: Float, 

Compute given matrix norm for matrix.

fn metric<'a, 'b, B, M>(&'a self, mat: &'b B, metric: M) -> T where
    B: 'b + BaseMatrix<T>,
    M: MatrixMetric<'a, 'b, T, Self, B>, 

Compute the metric distance between two matrices.

fn sum(&self) -> T where
    T: Copy + Zero + Add<T, Output = T>, 

The sum of all elements in the matrix

fn min(&self, axis: Axes) -> Vector<T> where
    T: Copy + PartialOrd, 

The min of the specified axis of the matrix.

fn max(&self, axis: Axes) -> Vector<T> where
    T: Copy + PartialOrd, 

The max of the specified axis of the matrix.

fn into_matrix(self) -> Matrix<T> where
    T: Copy, 

Convert the matrix struct into a owned Matrix.

fn select_rows<'a, I>(&self, rows: I) -> Matrix<T> where
    T: Copy,
    I: IntoIterator<Item = &'a usize>,
    I::IntoIter: ExactSizeIterator + Clone, 

Select rows from matrix

fn select_cols<'a, I>(&self, cols: I) -> Matrix<T> where
    T: Copy,
    I: IntoIterator<Item = &'a usize>,
    I::IntoIter: ExactSizeIterator + Clone, 

Select columns from matrix

fn elemul(&self, m: &Self) -> Matrix<T> where
    T: Copy + Mul<T, Output = T>, 

The elementwise product of two matrices.

fn elediv(&self, m: &Self) -> Matrix<T> where
    T: Copy + Div<T, Output = T>, 

The elementwise division of two matrices.

fn select(&self, rows: &[usize], cols: &[usize]) -> Matrix<T> where
    T: Copy, 

Select block matrix from matrix

fn hcat<S>(&self, m: &S) -> Matrix<T> where
    T: Copy,
    S: BaseMatrix<T>, 

Horizontally concatenates two matrices. With self on the left.

fn vcat<S>(&self, m: &S) -> Matrix<T> where
    T: Copy,
    S: BaseMatrix<T>, 

Vertically concatenates two matrices. With self on top.

Important traits for Diagonal<'a, T, M>

impl<'a, T, M: BaseMatrix<T>> Iterator for Diagonal<'a, T, M> type Item = &'a T;

fn diag(&self) -> Diagonal<T, Self>

Extract the diagonal of the matrix

fn transpose(&self) -> Matrix<T> where
    T: Copy, 

Tranposes the given matrix

fn is_diag(&self) -> bool where
    T: Zero + PartialEq, 

Checks if matrix is diagonal.

fn solve_u_triangular(&self, y: Vector<T>) -> Result<Vector<T>, Error> where
    T: Any + Float, 

Solves an upper triangular linear system.

fn solve_l_triangular(&self, y: Vector<T>) -> Result<Vector<T>, Error> where
    T: Any + Float, 

Solves a lower triangular linear system.

fn split_at(&self, mid: usize, axis: Axes) -> (MatrixSlice<T>, MatrixSlice<T>)

Split the matrix at the specified axis returning two MatrixSlices.

fn sub_slice<'a>(
    &self,
    start: [usize; 2],
    rows: usize,
    cols: usize
) -> MatrixSlice<'a, T> where
    T: 'a, 

Produce a MatrixSlice from an existing matrix.

impl<'a, T> BaseMatrixMut<T> for RowMut<'a, T>

fn as_mut_ptr(&mut self) -> *mut T

Top left index of the slice.

fn as_mut_slice(&mut self) -> MatrixSliceMut<T>

Returns a MatrixSliceMut over the whole matrix.

unsafe fn get_unchecked_mut(&mut self, index: [usize; 2]) -> &mut T

Get a mutable reference to a point in the matrix without bounds checks.

Important traits for SliceIterMut<'a, T>

impl<'a, T> Iterator for SliceIterMut<'a, T> type Item = &'a mut T;

fn iter_mut<'a>(&mut self) -> SliceIterMut<'a, T> where
    T: 'a, 

Returns a mutable iterator over the matrix.

fn col_mut(&mut self, index: usize) -> ColumnMut<T>

Returns a mutable reference to the column of a matrix at the given index. None if the index is out of bounds.

unsafe fn col_unchecked_mut(&mut self, index: usize) -> ColumnMut<T>

Returns a mutable reference to the column of a matrix at the given index without doing a bounds check.

fn row_mut(&mut self, index: usize) -> RowMut<T>

Returns a mutable reference to the row of a matrix at the given index. None if the index is out of bounds.

unsafe fn row_unchecked_mut(&mut self, index: usize) -> RowMut<T>

Returns a mutable reference to the row of a matrix at the given index without doing a bounds check.

fn swap_rows(&mut self, a: usize, b: usize)

Swaps two rows in a matrix.

fn swap_cols(&mut self, a: usize, b: usize)

Swaps two columns in a matrix.

Important traits for ColsMut<'a, T>

impl<'a, T> Iterator for ColsMut<'a, T> type Item = ColumnMut<'a, T>;

fn col_iter_mut(&mut self) -> ColsMut<T>

Iterate over the mutable columns of the matrix.

Important traits for RowsMut<'a, T>

impl<'a, T> Iterator for RowsMut<'a, T> type Item = RowMut<'a, T>;

fn row_iter_mut(&mut self) -> RowsMut<T>

Iterate over the mutable rows of the matrix.

Important traits for DiagonalMut<'a, T, M>

impl<'a, T, M: BaseMatrixMut<T>> Iterator for DiagonalMut<'a, T, M> type Item = &'a mut T;

fn diag_iter_mut(&mut self, k: DiagOffset) -> DiagonalMut<T, Self>

Iterate over diagonal entries mutably

fn set_to<M: BaseMatrix<T>>(self, target: M) where
    T: Copy, 

Sets the underlying matrix data to the target data.

fn apply(self, f: &dyn Fn(T) -> T) -> Self where
    T: Copy, 

Applies a function to each element in the matrix.

fn split_at_mut(
    &mut self,
    mid: usize,
    axis: Axes
) -> (MatrixSliceMut<T>, MatrixSliceMut<T>)

Split the matrix at the specified axis returning two MatrixSliceMuts.

fn sub_slice_mut<'a>(
    &mut self,
    start: [usize; 2],
    rows: usize,
    cols: usize
) -> MatrixSliceMut<'a, T> where
    T: 'a, 

Produce a MatrixSliceMut from an existing matrix.

impl<'a, T: Clone> From<RowMut<'a, T>> for Vector<T>

fn from(row: RowMut<'a, T>) -> Self

Performs the conversion.

impl<'a, T: 'a> Deref for RowMut<'a, T>

type Target = MatrixSliceMut<'a, T>

The resulting type after dereferencing.

fn deref(&self) -> &MatrixSliceMut<'a, T>

Dereferences the value.

impl<'a, T: 'a> DerefMut for RowMut<'a, T>

fn deref_mut(&mut self) -> &mut MatrixSliceMut<'a, T>

Mutably dereferences the value.

impl<'a, T> Index<usize> for RowMut<'a, T>

type Output = T

The returned type after indexing.

fn index(&self, idx: usize) -> &T

Performs the indexing (container[index]) operation.

impl<'a, T> IndexMut<usize> for RowMut<'a, T>

fn index_mut(&mut self, idx: usize) -> &mut T

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

impl<'a, T: Debug + 'a> Debug for RowMut<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: 'a + Copy> FromIterator<RowMut<'a, T>> for Matrix<T>

fn from_iter<I: IntoIterator<Item = RowMut<'a, T>>>(iterable: I) -> Self

Creates a value from an iterator.