Struct Owned 

pub struct Owned<T> { /* private fields */ }

A Matrix/MatrixMut that owns its data.

Implementations

impl<T> Owned<T>

pub fn try_from_data( data: Box<[T]>, nrows: usize, ncols: usize, ) -> Result<Self, TryFromError<Box<[T]>>>

Try to construct directly from data.

Returns an error if Layout::new fails for nrows and ncols or data.len() is not equal to nrows * ncols.

pub fn row_vector(data: Box<[T]>) -> Self

Construct a row vector directly from data.

pub fn column_vector(data: Box<[T]>) -> Self

Construct a column vector directly from data.

pub fn from_fn<F>(nrows: usize, ncols: usize, init: F) -> Self

where F: FnMut(RowCol) -> T,

Construct a new matrix using init.

Elements are initialized in memory order.

use diskann_utils::views::rowmajor::{self, Matrix};

let mat = rowmajor::Owned::from_fn(2, 3, |rc| 3 * rc.row + rc.col);

assert_eq!(mat.row(0), &[0, 1, 2]);
assert_eq!(mat.row(1), &[3, 4, 5]);

Panics

Panics if nrows * ncols overflows usize::MAX, or if the allocation size exceeds isize::MAX.

pub fn try_from_fn<F>( nrows: usize, ncols: usize, init: F, ) -> Result<Self, LayoutError>

where F: FnMut(RowCol) -> T,

Construct a new matrix using init.

Elements are initialized in memory order.

use diskann_utils::views::rowmajor::{self, Matrix};

let mat = rowmajor::Owned::try_from_fn(2, 3, |rc| 3 * rc.row + rc.col).unwrap();

assert_eq!(mat.row(0), &[0, 1, 2]);
assert_eq!(mat.row(1), &[3, 4, 5]);

Errors

Returns an error if nrows * ncols overflows usize::MAX, or if the allocation size exceeds isize::MAX.

pub fn from_element(nrows: usize, ncols: usize, element: T) -> Self

where T: Clone,

Construct a new matrix by cloning element.

Elements are initialized in memory order.

use diskann_utils::views::rowmajor::{self, Matrix};

let mat = rowmajor::Owned::from_element(2, 3, 0u32);

assert_eq!(mat.row(0), &[0, 0, 0]);
assert_eq!(mat.row(1), &[0, 0, 0]);

Panics

Panics if nrows * ncols overflows usize::MAX, or if the allocation size exceeds isize::MAX.

pub fn try_from_element( nrows: usize, ncols: usize, element: T, ) -> Result<Self, LayoutError>

where T: Clone,

Construct a new matrix by cloning element.

Elements are initialized in memory order.

use diskann_utils::views::rowmajor::{self, Matrix};

let mat = rowmajor::Owned::try_from_element(2, 3, 0u32).unwrap();

assert_eq!(mat.row(0), &[0, 0, 0]);
assert_eq!(mat.row(1), &[0, 0, 0]);

Errors

Returns an error if nrows * ncols overflows usize::MAX, or if the allocation size exceeds isize::MAX.

pub fn from_fn_with_layout<F>(layout: Layout<T>, init: F) -> Self

where F: FnMut(RowCol) -> T,

Construct a new matrix using init.

Elements are initialized in memory order.

pub fn from_element_with_layout(layout: Layout<T>, element: T) -> Self

where T: Clone,

Construct a new matrix by cloning element.

Elements are initialized in memory order.

pub fn into_inner(self) -> Box<[T]>

Consume self, returning the unmodified contents as a boxed slice.

use diskann_utils::views::rowmajor::{Matrix, Owned};

let mat = Owned::from_fn(2, 3, |rc| rc.col);
assert_eq!(mat.row(0), &[0, 1, 2]);
assert_eq!(mat.row(1), &[0, 1, 2]);

let b: Box<[usize]> = mat.into_inner();
assert_eq!(&*b, &[0, 1, 2, 0, 1, 2]);

Trait Implementations

impl<T> Clone for Owned<T>

where T: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Owned<T>

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

Formats the value using the given formatter.

impl<T> Drop for Owned<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T> Matrix for Owned<T>

type Element = T

The type of the element stored in the matrix.

fn as_nonnull(&self) -> NonNull<T>

Return the base pointer for the matrix.

fn layout(&self) -> Layout<T>

Return the Layout for the matrix.

fn nrows(&self) -> usize

Return the number of rows in the matrix.

fn ncols(&self) -> usize

Return the number of columns in the matrix.

unsafe fn row_unchecked(&self, row: usize) -> &[Self::Element]

Returns the requested row without bounds checking.

fn as_ptr(&self) -> *const Self::Element

Return a pointer to the base of the matrix.

fn as_slice(&self) -> &[Self::Element]

Return the underlying data as a slice.

fn row(&self, row: usize) -> &[Self::Element]

Return row row as a slice.

fn get_row(&self, row: usize) -> Option<&[Self::Element]>

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

fn rows(&self) -> Rows<'_, Self::Element>

Return a iterator over all rows in the matrix.

unsafe fn element_unchecked(&self, row: usize, col: usize) -> &Self::Element

Returns a reference to an element without bounds checking.

fn get_element(&self, row: usize, col: usize) -> Option<&Self::Element>

Return the value at the specified row and col.

fn element(&self, row: usize, col: usize) -> &Self::Element

Return the value at the specified row and col.

fn as_view(&self) -> Ref<'_, Self::Element>

Return a view over the matrix.

fn subview(&self, rows: Range<usize>) -> Option<Ref<'_, Self::Element>>

Return a view over the rows in rows, or None when the range is invalid.

fn window_iter(&self, batchsize: NonZeroUsize) -> Windows<'_, Self::Element>

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

fn to_rowmajor_owned(&self) -> Owned<Self::Element>

where Self::Element: Clone,

Return an Owned with the same shape as self and cloned contents.

fn try_map<F, R>(&self, f: F) -> Result<Owned<R>, LayoutError>

where F: FnMut(&Self::Element) -> R,

Create a new Matrix by applying the closure f to each element.

fn map<F, R>(&self, f: F) -> Owned<R>

where F: FnMut(&Self::Element) -> R,

Create a new Matrix by applying the closure f to each element.

fn transpose(&self) -> Owned<Self::Element>

where Self::Element: Clone,

Transpose the elements in self.

fn par_rows(&self) -> impl IndexedParallelIterator<Item = &[Self::Element]>

where Self::Element: Sync,

Return a parallel iterator over the rows of the matrix.

fn par_window_iter( &self, batchsize: usize, ) -> impl IndexedParallelIterator<Item = Ref<'_, Self::Element>>

where Self::Element: Sync,

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

impl<T> MatrixMut for Owned<T>

fn as_nonnull_mut(&mut self) -> NonNull<T>

Return the base pointer for the matrix.

unsafe fn row_unchecked_mut(&mut self, row: usize) -> &mut [Self::Element]

Returns the requested row without bounds checking.

fn as_mut_ptr(&mut self) -> *mut Self::Element

Return a pointer to the base of the matrix.

fn as_mut_slice(&mut self) -> &mut [Self::Element]

Return the underlying data as a mutable slice.

fn row_mut(&mut self, row: usize) -> &mut [Self::Element]

Return row row as a mutable slice.

fn get_row_mut(&mut self, row: usize) -> Option<&mut [Self::Element]>

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

fn rows_mut(&mut self) -> RowsMut<'_, Self::Element>

Return a mutable iterator over all rows in the matrix.

unsafe fn element_unchecked_mut( &mut self, row: usize, col: usize, ) -> &mut Self::Element

Returns a mutable reference to an element without bounds checking.

fn get_element_mut( &mut self, row: usize, col: usize, ) -> Option<&mut Self::Element>

Return the value at the specified row and col.

fn element_mut(&mut self, row: usize, col: usize) -> &mut Self::Element

Return the value at the specified row and col.

fn as_view_mut(&mut self) -> Mut<'_, Self::Element>

Return a view over the matrix.

fn par_rows_mut( &mut self, ) -> impl IndexedParallelIterator<Item = &mut [Self::Element]>

where Self::Element: Send,

Return a parallel iterator over the rows of the matrix.

fn par_window_iter_mut( &mut self, batchsize: usize, ) -> impl IndexedParallelIterator<Item = Mut<'_, Self::Element>>

where Self::Element: Send,

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

impl<T> PartialEq for Owned<T>

where T: PartialEq,

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a, T> Reborrow<'a> for Owned<T>

type Target = Ref<'a, T>

fn reborrow(&'a self) -> Self::Target

Borrow self into a generalized reference type and reborrow

impl<'a, T> ReborrowMut<'a> for Owned<T>

type Target = Mut<'a, T>

fn reborrow_mut(&'a mut self) -> Self::Target

Mutably borrow self into a generalized reference type and reborrow.

impl<T> Send for Owned<T>

where T: Send,

impl<T> Sync for Owned<T>

where T: Sync,