Struct rulinalg::matrix::ColumnMut

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

Mutable column of a matrix.

This struct points to a MatrixSliceMut making up a column in a matrix. You can deref this struct to retrieve the raw column MatrixSliceMut.

Example

use rulinalg::matrix::BaseMatrixMut;

let mut mat = matrix![1.0, 2.0;
                  3.0, 4.0];
{
    let mut column = mat.col_mut(1);
    *column += 2.0;
}
let expected = matrix![1.0, 4.0;
                       3.0, 6.0];
assert_matrix_eq!(mat, expected);

Implementations

impl<'a, T> ColumnMut<'a, T>where
    T: Clone,

pub fn clone_from_slice(&mut self, slice: &[T])

Clones the elements of the given slice of compatible size into this column.

Panics

• The slice does not have the same length as the number of rows in the column.

pub fn clone_into_slice(&self, slice: &mut [T])

Clones the elements of this column into a slice of compatible size.

Panics

• The slice does not have the same length as the number of rows in the column.

Trait Implementations

impl<'a, T> BaseMatrix<T> for ColumnMut<'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 an element in the matrix without bounds checking.

fn get(&self, index: [usize; 2]) -> Option<&T>

Get a reference to an element in the matrix.

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

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

Returns an iterator over the matrix data.

fn col_iter(&self) -> Cols<'_, T>

Iterate over the columns of the matrix.

fn row_iter(&self) -> Rows<'_, T>

Iterate over the rows of the matrix.

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

Iterate over diagonal entries

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

Compute the metric distance between two matrices.

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

Extract the diagonal of the matrix

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 ColumnMut<'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 an element in the matrix without bounds checks.

fn get_mut(&mut self, index: [usize; 2]) -> Option<&mut T>

Get a mutable reference to an element in the matrix.

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.

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

Iterate over the mutable columns of the matrix.

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

Iterate over the mutable rows of the matrix.

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

Iterate over diagonal entries mutably

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: Debug + 'a> Debug for ColumnMut<'a, T>

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

Formats the value using the given formatter.

impl<'a, T: 'a> Deref for ColumnMut<'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 ColumnMut<'a, T>

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

Mutably dereferences the value.

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

fn from(column: ColumnMut<'a, T>) -> Self

Converts to this type from the input type.

impl<'a, T> Index<usize> for ColumnMut<'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 ColumnMut<'a, T>

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

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