Struct VecRef 

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

A reference to a single column/row of a matrix.

This is similar to &[T] but with a pitch potentially different from 1 between its elements, i.e. there is no guarantee of contiguity. As a consequence this does not have a simple past-the-end pointer like a slice would have. For an empty slice the only guaranteed-valid pointer is the base pointer itself while for larger slices the last guaranteed-valid pointer is one-past the last element, not one additional pitch.

Created from its constructors or a block reference via the BlockRef::col and BlockRef::row methods.

Implementations

impl<'data, T> VecRef<'data, T>

pub fn new(data: &'data [T], pitch: usize) -> Self

Create a new vector reference from a raw slice and pitch.

The resulting block refers to the first column of the matrix.

Panics

Panics if the pitch is zero.

pub fn from_slice(data: &'data [T]) -> Self

Create a new vector reference from a raw slice with pitch 1.

pub fn len(&self) -> usize

Number of elements in this vector.

pub fn is_empty(&self) -> bool

Whether this vector is empty.

pub fn split_at(self, mid: usize) -> (VecRef<'data, T>, VecRef<'data, T>)

Divide into two vectors at the given element.

Examples

use matrix_slice::VecRef;

let data = &[0, 1, 2, 3, 4, 5];

let block = VecRef::new(data, 1);
let (left, right) = block.split_at(2);

assert_eq!(left[1], 1);
assert_eq!(right[3], 5);

pub fn split_at_checked( self, mid: usize, ) -> Option<(VecRef<'data, T>, VecRef<'data, T>)>

Divide into two vectors at the given element.

See Self::split_at but returns None if out of bounds.

pub fn split_off<R>(&mut self, range: R) -> Option<Self>

where R: OneSidedMatrixIndex,

Take part of the vector.

Examples

use matrix_slice::VecRef;

let data = &[0, 1, 2, 3, 4, 5];
let mut vec = VecRef::new(data, 1);

// Does nothing.
assert!(vec.split_off(6..).is_some_and(|v| v.is_empty()));
assert!(vec.split_off(7..).is_none());
assert!(vec.split_off(..7).is_none());

let right = vec.split_off(2..).unwrap();
assert_eq!(vec.len(), 2);
assert_eq!(right[3], 5);

You can also split off the start:

use matrix_slice::VecRef;

let data = &[0, 1, 2, 3, 4, 5];
let mut vec = VecRef::new(data, 1);
let start = vec.split_off(..=2).unwrap();

assert_eq!(vec[0], 3);
assert_eq!(start[0], 0);

pub fn select<R>(self, range: R) -> Option<VecRef<'data, T>>

where R: MatrixIndex,

Choose a range of elements and contract the vector to that.

pub fn iter(self) -> IterVec<'data, T>

Examples

let data = &[
    [0, 1, 2],
    [3, 4, 5],
    [6, 7, 8],
];

let block = matrix_slice::from_array_rows(data);
let column = block.col(1);

assert!(column.iter().eq(&[1, 4, 7]));

Trait Implementations

impl<'a, T: Clone> Clone for VecRef<'a, T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Index<usize> for VecRef<'_, T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'data, T> IntoIterator for VecRef<'data, T>

type Item = &'data T

The type of the elements being iterated over.

type IntoIter = IterVec<'data, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: Copy> Copy for VecRef<'a, T>

impl<T> Send for VecRef<'_, T>

where T: Sync,

impl<T> Sync for VecRef<'_, T>

where T: Sync,