Struct Resizable 

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

A row-major matrix that owns its storage and can change shape in place.

Use it as reusable scratch storage for matrices of different shapes. Resizable::resize and Resizable::resize_with may reuse the existing allocation. After a resize, every element holds a valid T, but the values are unspecified: write the matrix before you read it.

use diskann_utils::views::rowmajor::{Matrix, MatrixMut, Resizable};

let mut scratch = Resizable::<f32>::new();
scratch.resize(2, 3).unwrap();
scratch.as_mut_slice().fill(1.0);
assert_eq!((scratch.nrows(), scratch.ncols()), (2, 3));
assert_eq!(scratch.row(1), &[1.0, 1.0, 1.0]);

Implementations

impl<T> Resizable<T>

pub fn new() -> Self

Construct an empty 0 x 0 matrix. No memory is allocated.

pub fn with_capacity(capacity: usize) -> Self

Construct an empty 0 x 0 matrix with room for at least capacity elements.

pub fn capacity(&self) -> usize

The number of elements that the matrix can hold without allocating.

pub fn resize_with<F>( &mut self, nrows: usize, ncols: usize, f: F, ) -> Result<(), LayoutError>

where F: FnMut() -> T,

Set the shape to nrows x ncols. The element values are unspecified.

f creates the elements that the current storage cannot supply.

Returns an error if nrows x ncols is not a valid Layout. The shape is then unchanged.

pub fn resize(&mut self, nrows: usize, ncols: usize) -> Result<(), LayoutError>

where T: Default,

Set the shape to nrows x ncols. The element values are unspecified.

Returns an error if nrows x ncols is not a valid Layout. The shape is then unchanged.

pub fn clear(&mut self)

Set the shape to 0 x 0. The allocation is kept.

pub fn shrink_to_fit(&mut self)

Drop the elements past the current shape and release unused memory.

Trait Implementations

impl<T: Clone> Clone for Resizable<T>

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 Resizable<T>

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

Formats the value using the given formatter.

impl<T> Default for Resizable<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> From<Owned<T>> for Resizable<T>

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

Take the storage of matrix without copying it.

impl<T> From<Resizable<T>> for Owned<T>

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

Keep the elements of the current shape and drop the rest.

impl<T> Matrix for Resizable<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 Resizable<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 subview_mut(&mut self, rows: Range<usize>) -> Option<Mut<'_, Self::Element>>

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

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 Resizable<T>

where T: PartialEq,

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

Compare the shapes and the elements of the shapes.

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

Inequality operator !=.

impl<'a, T> Reborrow<'a> for Resizable<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 Resizable<T>

type Target = Mut<'a, T>

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

Mutably borrow self into a generalized reference type and reborrow.