Struct MatrixBase 

pub struct MatrixBase<T>
where
    T: DenseData,
{ /* private fields */ }

A view over dense chunk of memory, interpreting that memory as a 2-dimensional matrix laid out in row-major order.

When this class view immutable memory, it is Copy.

Implementations

impl<T> MatrixBase<Box<[T]>>

pub fn new<U>(generator: U, nrows: usize, ncols: usize) -> Self

where U: Generator<T>,

Construct a new Matrix initialized with the contents of the generator.

Elements are initialized in memory order.

impl<T> MatrixBase<T>

where T: DenseData,

pub fn try_from( data: T, nrows: usize, ncols: usize, ) -> Result<Self, TryFromError<T>>

Try to construct a MatrixBase over the provided base. If the size of the base is incorrect, return a TryFromError containing the base.

The length of the base must be equal to nrows * ncols.

pub fn ncols(&self) -> usize

Return the number of columns in the matrix.

pub fn nrows(&self) -> usize

Return the number of rows in the matrix.

pub fn as_slice(&self) -> &[T::Elem]

Return the underlying data as a slice.

pub fn as_mut_slice(&mut self) -> &mut [T::Elem]

where T: MutDenseData,

Return the underlying data as a mutable slice.

pub fn row(&self, row: usize) -> &[T::Elem]

Return row row as a slice.

Panic

Panics if row >= self.nrows().

pub fn row_vector(data: T) -> Self

Construct a new MatrixBase over the raw data.

The returned MatrixBase will only have a single row with contents equal to data.

pub fn get_row(&self, row: usize) -> Option<&[T::Elem]>

Return row row if row < self.nrows(). Otherwise, return None.

pub unsafe fn get_row_unchecked(&self, row: usize) -> &[T::Elem]

Returns the requested row without boundschecking.

Safety

The following conditions must hold to avoid undefined behavior:

• row < self.nrows().

pub fn row_mut(&mut self, row: usize) -> &mut [T::Elem]

where T: MutDenseData,

Return row row as a mutable slice.

Panics

Panics if row >= self.nrows().

pub unsafe fn get_row_unchecked_mut(&mut self, row: usize) -> &mut [T::Elem]

where T: MutDenseData,

Returns the requested row without boundschecking.

Safety

The following conditions must hold to avoid undefined behavior:

• row < self.nrows().

pub fn row_iter(&self) -> impl ExactSizeIterator<Item = &[T::Elem]>

Return a iterator over all rows in the matrix.

Rows are yielded sequentially beginning with row 0.

pub fn row_iter_mut(&mut self) -> impl ExactSizeIterator<Item = &mut [T::Elem]>

where T: MutDenseData,

Return a mutable iterator over all rows in the matrix.

Rows are yielded sequentially beginning with row 0.

pub fn window_iter( &self, batchsize: usize, ) -> impl Iterator<Item = MatrixView<'_, T::Elem>>

where T::Elem: Sync,

Return an iterator that divides the matrix into sub-matrices with (up to) batchsize rows with self.ncols() columns.

It is possible for yielded sub-matrices to have fewer than batchsize rows if the number of rows in the parent matrix is not evenly divisible by batchsize.

Panics

Panics if batchsize = 0.

pub fn par_window_iter( &self, batchsize: usize, ) -> impl IndexedParallelIterator<Item = MatrixView<'_, T::Elem>>

where T::Elem: Sync,

Return a parallel iterator that divides the matrix into sub-matrices with (up to) batchsize rows with self.ncols() columns.

This allows workers in parallel algorithms to work on dense subsets of the whole matrix for better locality.

It is possible for yielded sub-matrices to have fewer than batchsize rows if the number of rows in the parent matrix is not evenly divisible by batchsize.

Panics

Panics if batchsize = 0.

pub fn par_window_iter_mut( &mut self, batchsize: usize, ) -> impl IndexedParallelIterator<Item = MutMatrixView<'_, T::Elem>>

where T: MutDenseData, T::Elem: Send,

Return a parallel iterator that divides the matrix into mutable sub-matrices with (up to) batchsize rows with self.ncols() columns.

This allows workers in parallel algorithms to work on dense subsets of the whole matrix for better locality.

It is possible for yielded sub-matrices to have fewer than batchsize rows if the number of rows in the parent matrix is not evenly divisible by batchsize.

Panics

Panics if batchsize = 0.

pub fn par_row_iter(&self) -> impl IndexedParallelIterator<Item = &[T::Elem]>

where T::Elem: Sync,

Return a parallel iterator over the rows of the matrix.

pub fn par_row_iter_mut( &mut self, ) -> impl IndexedParallelIterator<Item = &mut [T::Elem]>

where T: MutDenseData, T::Elem: Send,

Return a parallel iterator over the rows of the matrix.

pub fn into_inner(self) -> T

Consume the matrix, returning the inner representation.

This loses the information about the number of rows and columnts.

pub fn as_view(&self) -> MatrixView<'_, T::Elem>

Return a view over the matrix.

pub fn as_mut_view(&mut self) -> MutMatrixView<'_, T::Elem>

where T: MutDenseData,

Return a mutable view over the matrix.

pub fn subview(&self, rows: Range<usize>) -> Option<MatrixView<'_, T::Elem>>

Return a view over the specified rows of the matrix.

If the specified range is out of bounds, return None.

use diskann_utils::views::Matrix;

let mut mat = Matrix::new(0usize, 4, 3);

// Fill the matrix with some data.
mat.row_iter_mut().enumerate().for_each(|(i, row)| row.fill(i));

// Creating a subview into an offset portion of the matrix.
let subview = mat.subview(1..3).unwrap();
assert_eq!(subview.nrows(), 2);
assert_eq!(subview.row(0), &[1, 1, 1]);
assert_eq!(subview.row(1), &[2, 2, 2]);

// A trying to access out-of-bounds returns `None`
assert!(mat.subview(3..5).is_none());

pub fn as_ptr(&self) -> *const T::Elem

Return a pointer to the base of the matrix.

pub fn as_mut_ptr(&mut self) -> *mut T::Elem

where T: MutDenseData,

Return a pointer to the base of the matrix.

pub unsafe fn get_unchecked(&self, row: usize, col: usize) -> &T::Elem

Returns a reference to an element without boundschecking.

Safety

The following conditions must hold to avoid undefined behavior:

• row < self.nrows().
• col < self.ncols().

pub unsafe fn get_unchecked_mut( &mut self, row: usize, col: usize, ) -> &mut T::Elem

where T: MutDenseData,

Returns a mutable reference to an element without boundschecking.

Safety

The following conditions must hold to avoid undefined behavior:

• row < self.nrows().
• col < self.ncols().

pub fn to_owned(&self) -> Matrix<T::Elem>

where T::Elem: Clone,

Trait Implementations

impl<T> Clone for MatrixBase<T>

where T: DenseData + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for MatrixBase<T>

where T: DenseData + Debug,

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

Formats the value using the given formatter.

impl<'a, T> From<MatrixBase<&'a [T]>> for &'a [T]

Allow matrix views to be converted directly to slices.

fn from(view: MatrixView<'a, T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<MatrixBase<&'a mut [T]>> for &'a [T]

Allow mutable matrix views to be converted directly to slices.

fn from(view: MutMatrixView<'a, T>) -> Self

Converts to this type from the input type.

impl<T, U> From<MatrixBase<T>> for StridedBase<U>

where T: DenseData + Into<U>, U: DenseData,

fn from(matrix: MatrixBase<T>) -> Self

Converts to this type from the input type.

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

where T: DenseData,

Return a reference to the item at entry (row, col) in the matrix.

Panics

Panics if row >= self.nrows() or col >= self.ncols().

type Output = <T as DenseData>::Elem

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<(usize, usize)> for MatrixBase<T>

where T: MutDenseData,

Return a mutable reference to the item at entry (row, col) in the matrix.

Panics

Panics if row >= self.nrows() or col >= self.ncols().

fn index_mut(&mut self, (row, col): (usize, usize)) -> &mut Self::Output

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

impl<T> PartialEq for MatrixBase<T>

where T: DenseData + PartialEq,

fn eq(&self, other: &MatrixBase<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Copy for MatrixBase<T>

where T: DenseData + Copy,

impl<T> StructuralPartialEq for MatrixBase<T>

where T: DenseData,