Struct rusty_machine::linalg::MatrixSlice [−]

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

A MatrixSlice

This struct provides a slice into a matrix.

The struct contains the upper left point of the slice and the width and height of the slice.

Methods

`impl<'a, T> MatrixSlice<'a, T>`

`fn from_matrix(mat: &'a Matrix<T>, start: [usize; 2], rows: usize, cols: usize) -> MatrixSlice<'a, T>`

Produce a MatrixSlice from a Matrix

Examples

use rulinalg::matrix::{Matrix, MatrixSlice};

let a = Matrix::new(3,3, (0..9).collect::<Vec<usize>>());
let slice = MatrixSlice::from_matrix(&a, [1,1], 2, 2);

`unsafe fn from_raw_parts(ptr: *const T, rows: usize, cols: usize, row_stride: usize) -> MatrixSlice<'a, T>`

Creates a MatrixSlice from raw parts.

Examples

use rulinalg::matrix::MatrixSlice;

let mut a = vec![4.0; 16];

unsafe {
    // Create a matrix slice with 3 rows, and 3 cols
    // The row stride of 4 specifies the distance between the start of each row in the data.
    let b = MatrixSlice::from_raw_parts(a.as_ptr(), 3, 3, 4);
}

Safety

The pointer must be followed by a contiguous slice of data larger than row_stride * rows. If not then other operations will produce undefined behaviour.

Additionally cols should be less than the row_stride. It is possible to use this function safely whilst violating this condition. So long as max(cols, row_stride) * rows is less than the data size.

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

Produce a MatrixSlice from an existing MatrixSlice.

This function will be deprecated. Prefer using BaseMatrix::sub_slice.

Examples

use rulinalg::matrix::{Matrix, MatrixSlice};

let a = Matrix::new(3,3, (0..9).collect::<Vec<usize>>());
let slice = MatrixSlice::from_matrix(&a, [1,1], 2, 2);
let new_slice = slice.reslice([0,0], 1, 1);

Trait Implementations

`impl<'a, T> Metric<T> for MatrixSlice<'a, T> where T: Float`

`fn norm(&self) -> T`

Compute euclidean norm for matrix.

Examples

use rulinalg::matrix::{Matrix, MatrixSlice};
use rulinalg::Metric;

let a = Matrix::new(2,1, vec![3.0,4.0]);
let b = MatrixSlice::from_matrix(&a, [0,0], 2, 1);
let c = b.norm();

assert_eq!(c, 5.0);

`impl<'a, T> BaseMatrix<T> for MatrixSlice<'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. Read more

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

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

`fn get_row(&self, index: usize) -> Option<&[T]>`

Returns the row of a matrix at the given index. None if the index is out of bounds. Read more

`unsafe fn get_row_unchecked(&self, index: usize) -> &[T]`

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

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

Returns an iterator over the matrix data. Read more

`fn iter_rows(&self) -> Rows<T>`

Iterate over the rows of the matrix. Read more

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

Iterate over diagonal entries Read more

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

The sum of the rows of the matrix. Read more

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

The sum of the columns of the matrix. Read more

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

The sum of all elements in the matrix Read more

`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 I: IntoIterator<Item=&'a usize>, T: Copy, I::IntoIter: ExactSizeIterator, I::IntoIter: Clone`

Select rows from matrix Read more

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

Select columns from matrix Read more

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

The elementwise product of two matrices. Read more

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

The elementwise division of two matrices. Read more

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

Select block matrix from matrix Read more

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

Horizontally concatenates two matrices. With self on the left. Read more

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

Vertically concatenates two matrices. With self on top. Read more

`fn diag(&self) -> Vector<T> where T: Copy`

Extract the diagonal of the matrix Read more

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

Tranposes the given matrix Read more

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

Checks if matrix is diagonal. Read more

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

Solves an upper triangular linear system. Read more

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

Solves a lower triangular linear system. Read more

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

Split the matrix at the specified axis returning two MatrixSlices. Read more

`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. Read more

`impl<'a, T> Sub<T> for MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Scalar subtraction with matrix slice.

`type Output = Matrix<T>`

`fn sub(self, f: T) -> Matrix<T>`

`impl<'a, 'b, T> Sub<&'b T> for MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Scalar subtraction with matrix slice.

`type Output = Matrix<T>`

`fn sub(self, f: &T) -> Matrix<T>`

`impl<'a, 'b, T> Sub<T> for &'b MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Scalar subtraction with matrix slice.

`type Output = Matrix<T>`

`fn sub(self, f: T) -> Matrix<T>`

`impl<'a, 'b, 'c, T> Sub<&'c T> for &'b MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Scalar subtraction with matrix slice.

`type Output = Matrix<T>`

`fn sub(self, f: &T) -> Matrix<T>`

`impl<'a, 'b, T> Sub<MatrixSlice<'b, T>> for MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between the slices.

`type Output = Matrix<T>`

`fn sub(self, s: MatrixSlice<T>) -> Matrix<T>`

`impl<'a, 'b, 'c, T> Sub<MatrixSlice<'b, T>> for &'c MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between the slices.

`type Output = Matrix<T>`

`fn sub(self, s: MatrixSlice<T>) -> Matrix<T>`

`impl<'a, 'b, 'c, T> Sub<&'c MatrixSlice<'b, T>> for MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between the slices.

`type Output = Matrix<T>`

`fn sub(self, s: &MatrixSlice<T>) -> Matrix<T>`

`impl<'a, 'b, 'c, 'd, T> Sub<&'d MatrixSlice<'b, T>> for &'c MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between the slices.

`type Output = Matrix<T>`

`fn sub(self, s: &MatrixSlice<T>) -> Matrix<T>`

`impl<'a, 'b, T> Sub<MatrixSliceMut<'b, T>> for MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between the slices.

`type Output = Matrix<T>`

`fn sub(self, s: MatrixSliceMut<T>) -> Matrix<T>`

`impl<'a, 'b, 'c, T> Sub<MatrixSliceMut<'b, T>> for &'c MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between the slices.

`type Output = Matrix<T>`

`fn sub(self, s: MatrixSliceMut<T>) -> Matrix<T>`

`impl<'a, 'b, 'c, T> Sub<&'c MatrixSliceMut<'b, T>> for MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between the slices.

`type Output = Matrix<T>`

`fn sub(self, s: &MatrixSliceMut<T>) -> Matrix<T>`

`impl<'a, 'b, 'c, 'd, T> Sub<&'d MatrixSliceMut<'b, T>> for &'c MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between the slices.

`type Output = Matrix<T>`

`fn sub(self, s: &MatrixSliceMut<T>) -> Matrix<T>`

`impl<'a, T> Sub<Matrix<T>> for MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between Matrix and MatrixSlice.

`type Output = Matrix<T>`

`fn sub(self, m: Matrix<T>) -> Matrix<T>`

`impl<'a, 'b, T> Sub<Matrix<T>> for &'b MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between Matrix and MatrixSlice.

`type Output = Matrix<T>`

`fn sub(self, m: Matrix<T>) -> Matrix<T>`

`impl<'a, 'b, T> Sub<&'b Matrix<T>> for MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between Matrix and MatrixSlice.

`type Output = Matrix<T>`

`fn sub(self, m: &Matrix<T>) -> Matrix<T>`

`impl<'a, 'b, 'c, T> Sub<&'c Matrix<T>> for &'b MatrixSlice<'a, T> where T: Copy + Sub<T, Output=T>`

Performs elementwise subtraction between Matrix and MatrixSlice.

`type Output = Matrix<T>`

`fn sub(self, m: &Matrix<T>) -> Matrix<T>`

`impl<'a, T> Clone for MatrixSlice<'a, T> where T: 'a + Clone`

`fn clone(&self) -> MatrixSlice<'a, T>`

Returns a copy of the value. Read more

`fn clone_from(&mut self, source: &Self)`
1.0.0

Performs copy-assignment from source. Read more