Struct Matrix 

pub struct Matrix<T: Send + Sync> { /* private fields */ }

A lightweight Matrix abstraction that does almost nothing.

Implementations

impl<T: Send + Sync> Matrix<T>

pub fn from_raw_parts(values: Vec<T>, n_rows: usize) -> Self

pub fn from_vecs(vecs: Vec<Vec<T>>) -> Self

Create a new Matrix from a vector of vectors

pub fn nelem(&self) -> usize

pub fn raw_values(&self) -> &Vec<T>

pub fn raw_values_mut(&mut self) -> &mut Vec<T>

pub fn rows_mut(&mut self) -> ChunksExactMut<'_, T>

Create a mutable iterator through rows

Example

let vecs: Vec<Vec<u8>> = vec![
    vec![0, 1, 2],
    vec![3, 4, 5],
];

let mut mat = Matrix::from_vecs(vecs);

mat.rows_mut().for_each(|mut row| {
    row.iter_mut().for_each(|mut x| *x += 1 );
});

assert_eq!(mat.raw_values(), &vec![1, 2, 3, 4, 5, 6])

pub fn par_rows_mut(&mut self) -> ChunksExactMut<'_, T>

Parallel version of rows_mut

pub fn rows(&self) -> ChunksExact<'_, T>

Create an iterator through rows

Example

let vecs: Vec<Vec<u8>> = vec![
    vec![0, 1, 2],
    vec![3, 4, 5],
];

let mut mat = Matrix::from_vecs(vecs);

let rowsum: Vec<u8> = mat.rows().map(|row| {
    row.iter().sum::<u8>()
})
.collect();

assert_eq!(rowsum, vec![3_u8, 12_u8])

pub fn par_rows(&self) -> ChunksExact<'_, T>

Parallel version of rows

pub fn implicit_transpose(self) -> ImplicitlyTransposedMatrix<T>

Does an implicit transpose by inverting coordinates.

Notes

The matrix is not rebuild, so if you are attempting to access the transposed matrix row-wise many times, there will be a lot of cache misses. This method is best used if you plan to traverse the transposed matrix a small number of times.

Example

use lace_utils::Shape;

let vecs: Vec<Vec<u32>> = vec![
    vec![0, 1, 2],
    vec![3, 4, 5],
    vec![6, 7, 8],
    vec![9, 10, 11],
];

let mat = Matrix::from_vecs(vecs);
let mat_t = mat.clone().implicit_transpose();

assert_eq!(mat.n_rows(), mat_t.n_cols());
assert_eq!(mat.n_cols(), mat_t.n_rows());

for i in 0..3 {
    for j in 0..3 {
        assert_eq!(mat[(i, j)], mat_t[(j, i)]);
    }
}

impl<T: Send + Sync + Clone> Matrix<T>

pub fn vtile(col: Vec<T>, n_cols: usize) -> Self

Treat the input vector, col like a column vector and replicate it n_cols times.

Example

let col: Vec<u32> = vec![0, 1, 2];

let mat = Matrix::vtile(col, 12);

assert_eq!(mat[(0, 0)], 0);
assert_eq!(mat[(0, 11)], 0);

assert_eq!(mat[(1, 0)], 1);
assert_eq!(mat[(1, 11)], 1);

assert_eq!(mat[(2, 0)], 2);
assert_eq!(mat[(2, 11)], 2);

pub unsafe fn get_unchecked(&self, (i, j): (usize, usize)) -> &T

Get a reference to the item at (i, j) without bounds checks

Safety

Behavior is undefined if (i, j) is out of bounds

pub unsafe fn get_unchecked_mut(&mut self, (i, j): (usize, usize)) -> &mut T

Get a mutable reference to the item at (i, j) without bounds checks

Safety

Behavior is undefined if (i, j) is out of bounds

Trait Implementations

impl<T: Clone + Send + Sync> Clone for Matrix<T>

fn clone(&self) -> Matrix<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Send + Sync> Debug for Matrix<T>

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

Formats the value using the given formatter.

impl<T> Index<(usize, usize)> for &Matrix<T>

where T: Send + Sync,

type Output = T

The returned type after indexing.

fn index(&self, (i, j): (usize, usize)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> Index<(usize, usize)> for Matrix<T>

where T: Send + Sync,

type Output = T

The returned type after indexing.

fn index(&self, (i, j): (usize, usize)) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Send + Sync> Shape for &Matrix<T>

fn n_rows(&self) -> usize

fn n_cols(&self) -> usize

fn shape(&self) -> (usize, usize)

impl<T: Send + Sync> Shape for Matrix<T>

fn n_rows(&self) -> usize

fn n_cols(&self) -> usize

fn shape(&self) -> (usize, usize)