Trait rulinalg::matrix::BaseMatrixMut
[−]
[src]
pub trait BaseMatrixMut<T>: BaseMatrix<T> { fn as_mut_ptr(&mut self) -> *mut T; fn as_mut_slice(&mut self) -> MatrixSliceMut<T> { ... } unsafe fn get_unchecked_mut(&mut self, index: [usize; 2]) -> &mut T { ... } fn iter_mut<'a>(&mut self) -> SliceIterMut<'a, T> where T: 'a { ... } fn col_mut(&mut self, index: usize) -> ColumnMut<T> { ... } unsafe fn col_unchecked_mut(&mut self, index: usize) -> ColumnMut<T> { ... } fn row_mut(&mut self, index: usize) -> RowMut<T> { ... } unsafe fn row_unchecked_mut(&mut self, index: usize) -> RowMut<T> { ... } fn swap_rows(&mut self, a: usize, b: usize) { ... } fn swap_cols(&mut self, a: usize, b: usize) { ... } fn col_iter_mut(&mut self) -> ColsMut<T> { ... } fn row_iter_mut(&mut self) -> RowsMut<T> { ... } fn diag_iter_mut(&mut self, k: DiagOffset) -> DiagonalMut<T, Self> { ... } fn set_to<M: BaseMatrix<T>>(self, target: M) where T: Copy { ... } fn apply(self, f: &Fn(T) -> T) -> Self where T: Copy { ... } fn split_at_mut(&mut self,
mid: usize,
axis: Axes)
-> (MatrixSliceMut<T>, MatrixSliceMut<T>) { ... } fn sub_slice_mut<'a>(&mut self,
start: [usize; 2],
rows: usize,
cols: usize)
-> MatrixSliceMut<'a, T> where T: 'a { ... } }
Trait for mutable matrices.
Required Methods
fn as_mut_ptr(&mut self) -> *mut T
Top left index of the slice.
Provided Methods
fn as_mut_slice(&mut self) -> MatrixSliceMut<T>
Returns a MatrixSliceMut
over the whole matrix.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut a = Matrix::new(3, 3, vec![2.0; 9]); let b = a.as_mut_slice();
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.
fn iter_mut<'a>(&mut self) -> SliceIterMut<'a, T> where T: 'a
Returns a mutable iterator over the matrix.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut a = Matrix::new(3,3, (0..9).collect::<Vec<usize>>()); { let mut slice = a.sub_slice_mut([1,1], 2, 2); for d in slice.iter_mut() { *d = *d + 2; } } // Only the matrix slice is updated. assert_matrix_eq!(a, matrix![0, 1, 2; 3, 6, 7; 6, 9, 10]);
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.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut mat = matrix![0, 1, 2; 3, 4, 5; 6, 7, 8]; let mut slice = mat.sub_slice_mut([1,1], 2, 2); { let col = slice.col_mut(1); let mut expected = matrix![5usize; 8]; assert_matrix_eq!(*col, expected); }
Panics
Will panic if the column 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.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut mat = matrix![0, 1, 2; 3, 4, 5; 6, 7, 8]; let mut slice = mat.sub_slice_mut([1,1], 2, 2); let col = unsafe { slice.col_unchecked_mut(1) }; let mut expected = matrix![5usize; 8]; assert_matrix_eq!(*col, expected);
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.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut mat = matrix![0, 1, 2; 3, 4, 5; 6, 7, 8]; let mut slice = mat.sub_slice_mut([1,1], 2, 2); { let row = slice.row_mut(1); let mut expected = matrix![7usize, 8]; assert_matrix_eq!(*row, expected); }
Panics
Will panic if the row 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.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut mat = matrix![0, 1, 2; 3, 4, 5; 6, 7, 8]; let mut slice = mat.sub_slice_mut([1,1], 2, 2); let row = unsafe { slice.row_unchecked_mut(1) }; let mut expected = matrix![7usize, 8]; assert_matrix_eq!(*row, expected);
fn swap_rows(&mut self, a: usize, b: usize)
Swaps two rows in a matrix.
If a == b
, this method does nothing.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut x = matrix![0, 1; 2, 3; 4, 5; 6, 7]; x.swap_rows(1, 3); let expected = matrix![0, 1; 6, 7; 4, 5; 2, 3]; assert_matrix_eq!(x, expected);
Panics
Panics if a
or b
are out of bounds.
fn swap_cols(&mut self, a: usize, b: usize)
Swaps two columns in a matrix.
If a == b
, this method does nothing.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut x = matrix![0, 1; 2, 3; 4, 5]; x.swap_cols(0, 1); let expected = matrix![1, 0; 3, 2; 5, 4]; assert_matrix_eq!(x, expected);
Panics
Panics if a
or b
are out of bounds.
fn col_iter_mut(&mut self) -> ColsMut<T>
Iterate over the mutable columns of the matrix.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut a = matrix![0, 1; 2, 3; 4, 5]; for mut col in a.col_iter_mut() { *col += 1; } // Now contains the range 1..7 println!("{}", a);
fn row_iter_mut(&mut self) -> RowsMut<T>
Iterate over the mutable rows of the matrix.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut a = matrix![0, 1; 2, 3; 4, 5]; for mut row in a.row_iter_mut() { *row += 1; } // Now contains the range 1..7 println!("{}", a);
fn diag_iter_mut(&mut self, k: DiagOffset) -> DiagonalMut<T, Self>
Iterate over diagonal entries mutably
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut, DiagOffset}; let mut a = matrix![0, 1, 2; 3, 4, 5; 6, 7, 8]; // Increment super diag for d in a.diag_iter_mut(DiagOffset::Above(1)) { *d = *d + 1; } // Zero the sub-diagonal (sets 3 and 7 to 0) // Equivalent to `diag_iter(DiagOffset::Below(1))` for sub_d in a.diag_iter_mut(DiagOffset::from(-1)) { *sub_d = 0; } println!("{}", a);
Panics
If using an Above
or Below
offset which is
out-of-bounds this function will panic.
This function will never panic if the Main
diagonal
offset is used.
fn set_to<M: BaseMatrix<T>>(self, target: M) where T: Copy
Sets the underlying matrix data to the target data.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; let mut mat = Matrix::<f32>::zeros(4,4); let one_block = Matrix::<f32>::ones(2,2); // Get a mutable slice of the upper left 2x2 block. let mat_block = mat.sub_slice_mut([0,0], 2, 2); // Set the upper left 2x2 block to be ones. mat_block.set_to(one_block);
Panics
Panics if the dimensions of self
and target
are not the same.
fn apply(self, f: &Fn(T) -> T) -> Self where T: Copy
Applies a function to each element in the matrix.
Examples
use rulinalg::matrix::{Matrix, BaseMatrixMut}; fn add_two(a: f64) -> f64 { a + 2f64 } let a = Matrix::new(2, 2, vec![0.;4]); let b = a.apply(&add_two); assert_eq!(b, matrix![2.0, 2.0; 2.0, 2.0]);
fn split_at_mut(&mut self,
mid: usize,
axis: Axes)
-> (MatrixSliceMut<T>, MatrixSliceMut<T>)
mid: usize,
axis: Axes)
-> (MatrixSliceMut<T>, MatrixSliceMut<T>)
Split the matrix at the specified axis returning two MatrixSliceMut
s.
Examples
use rulinalg::matrix::{Axes, Matrix, BaseMatrixMut}; let mut a = Matrix::new(3,3, vec![2.0; 9]); let (b, c) = a.split_at_mut(1, Axes::Col);
fn sub_slice_mut<'a>(&mut self,
start: [usize; 2],
rows: usize,
cols: usize)
-> MatrixSliceMut<'a, T> where T: 'a
start: [usize; 2],
rows: usize,
cols: usize)
-> MatrixSliceMut<'a, T> where T: 'a
Produce a MatrixSliceMut
from an existing matrix.
Examples
use rulinalg::matrix::{Matrix, MatrixSliceMut, BaseMatrixMut}; let mut a = Matrix::new(3,3, (0..9).collect::<Vec<usize>>()); let mut slice = MatrixSliceMut::from_matrix(&mut a, [1,1], 2, 2); let new_slice = slice.sub_slice_mut([0,0], 1, 1);
Implementors
impl<T> BaseMatrixMut<T> for Matrix<T>
impl<'a, T> BaseMatrixMut<T> for MatrixSliceMut<'a, T>
impl<'a, T> BaseMatrixMut<T> for RowMut<'a, T>
impl<'a, T> BaseMatrixMut<T> for ColumnMut<'a, T>