Trait na::Storage

pub unsafe trait Storage<N, R, C = U1>: Debug where
    C: Dim,
    N: Scalar,
    R: Dim, {
    type RStride: Dim;
    type CStride: Dim;
    fn ptr(&self) -> *const N;
    fn shape(&self) -> (R, C);
    fn strides(&self) -> (Self::RStride, Self::CStride);
    fn is_contiguous(&self) -> bool;
    fn as_slice(&self) -> &[N];
    fn into_owned(self) -> <DefaultAllocator as Allocator<N, R, C>>::Buffer
    where
        DefaultAllocator: Allocator<N, R, C>;
    fn clone_owned(&self) -> <DefaultAllocator as Allocator<N, R, C>>::Buffer
    where
        DefaultAllocator: Allocator<N, R, C>;

    fn linear_index(&self, irow: usize, icol: usize) -> usize { ... }
    unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const N { ... }
    unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const N { ... }
    unsafe fn get_unchecked_linear(&self, i: usize) -> &N { ... }
    unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N { ... }
}

The trait shared by all matrix data storage.

FIXME: doc

Note that Self must always have a number of elements compatible with the matrix length (given by R and C if they are known at compile-time). For example, implementors of this trait should not allow the user to modify the size of the underlying buffer with safe methods (for example the MatrixVec::data_mut method is unsafe because the user could change the vector's size so that it no longer contains enough elements: this will lead to UB.

Associated Types

type RStride: Dim

The static stride of this storage's rows.

type CStride: Dim

The static stride of this storage's columns.

Required Methods

fn ptr(&self) -> *const N

The matrix data pointer.

fn shape(&self) -> (R, C)

The dimension of the matrix at run-time. Arr length of zero indicates the additive identity element of any dimension. Must be equal to Self::dimension() if it is not None.

fn strides(&self) -> (Self::RStride, Self::CStride)

The spacing between concecutive row elements and consecutive column elements.

For example this returns (1, 5) for a row-major matrix with 5 columns.

fn is_contiguous(&self) -> bool

Indicates whether this data buffer stores its elements contiguously.

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn as_slice(&self) -> &[N]

Retrieves the data buffer as a contiguous slice.

The matrix components may not be stored in a contiguous way, depending on the strides.

fn into_owned(self) -> <DefaultAllocator as Allocator<N, R, C>>::Buffer where
    DefaultAllocator: Allocator<N, R, C>, 

Builds a matrix data storage that does not contain any reference.

fn clone_owned(&self) -> <DefaultAllocator as Allocator<N, R, C>>::Buffer where
    DefaultAllocator: Allocator<N, R, C>, 

Clones this data storage to one that does not contain any reference.

Provided Methods

fn linear_index(&self, irow: usize, icol: usize) -> usize

Compute the index corresponding to the irow-th row and icol-th column of this matrix. The index must be such that the following holds:

let lindex = self.linear_index(irow, icol);
assert!(*self.get_unchecked(irow, icol) == *self.get_unchecked_linear(lindex)

unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const N

Gets the address of the i-th matrix component without performing bound-checking.

unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const N

Gets the address of the i-th matrix component without performing bound-checking.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked_linear(&self, i: usize) -> &N

Retrieves a reference to the i-th element without bound-checking.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N

Retrieves a reference to the i-th element without bound-checking.

Implementations on Foreign Types

impl<'a, N, R, C, RStride, CStride> Storage<N, R, C> for SliceStorage<'a, N, R, C, RStride, CStride> where     C: Dim,     CStride: Dim,     N: Scalar,     R: Dim,     RStride: Dim,

type RStride = RStride

type CStride = CStride

fn ptr(&self) -> *const N

fn shape(&self) -> (R, C)

fn strides(     &self ) -> (<SliceStorage<'a, N, R, C, RStride, CStride> as Storage<N, R, C>>::RStride, <SliceStorage<'a, N, R, C, RStride, CStride> as Storage<N, R, C>>::CStride)

fn is_contiguous(&self) -> bool

fn into_owned(self) -> <DefaultAllocator as Allocator<N, R, C>>::Buffer where     DefaultAllocator: Allocator<N, R, C>,

fn clone_owned(&self) -> <DefaultAllocator as Allocator<N, R, C>>::Buffer where     DefaultAllocator: Allocator<N, R, C>,

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn as_slice(&self) -> &[N]

fn linear_index(&self, irow: usize, icol: usize) -> usize

unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const N

unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const N

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked_linear(&self, i: usize) -> &N

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N

impl<'a, N, R, C, RStride, CStride> Storage<N, R, C> for SliceStorageMut<'a, N, R, C, RStride, CStride> where     C: Dim,     CStride: Dim,     N: Scalar,     R: Dim,     RStride: Dim,

type RStride = RStride

type CStride = CStride

fn ptr(&self) -> *const N

fn shape(&self) -> (R, C)

fn strides(     &self ) -> (<SliceStorageMut<'a, N, R, C, RStride, CStride> as Storage<N, R, C>>::RStride, <SliceStorageMut<'a, N, R, C, RStride, CStride> as Storage<N, R, C>>::CStride)

fn is_contiguous(&self) -> bool

fn into_owned(self) -> <DefaultAllocator as Allocator<N, R, C>>::Buffer where     DefaultAllocator: Allocator<N, R, C>,

fn clone_owned(&self) -> <DefaultAllocator as Allocator<N, R, C>>::Buffer where     DefaultAllocator: Allocator<N, R, C>,

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn as_slice(&self) -> &[N]

fn linear_index(&self, irow: usize, icol: usize) -> usize

unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const N

unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const N

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked_linear(&self, i: usize) -> &N

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N

impl<N, R, C> Storage<N, R, C> for MatrixArray<N, R, C> where     C: DimName,     N: Scalar,     R: DimName,     <R as DimName>::Value: Mul<<C as DimName>::Value>,     <<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>,     DefaultAllocator: Allocator<N, R, C>,     <DefaultAllocator as Allocator<N, R, C>>::Buffer == MatrixArray<N, R, C>,

type RStride = U1

type CStride = R

fn ptr(&self) -> *const N

fn shape(&self) -> (R, C)

fn strides(     &self ) -> (<MatrixArray<N, R, C> as Storage<N, R, C>>::RStride, <MatrixArray<N, R, C> as Storage<N, R, C>>::CStride)

fn is_contiguous(&self) -> bool

fn into_owned(self) -> <DefaultAllocator as Allocator<N, R, C>>::Buffer where     DefaultAllocator: Allocator<N, R, C>,

fn clone_owned(&self) -> <DefaultAllocator as Allocator<N, R, C>>::Buffer where     DefaultAllocator: Allocator<N, R, C>,

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn as_slice(&self) -> &[N]

fn linear_index(&self, irow: usize, icol: usize) -> usize

unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const N

unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const N

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked_linear(&self, i: usize) -> &N

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N

impl<N, C> Storage<N, Dynamic, C> for MatrixVec<N, Dynamic, C> where     C: Dim,     N: Scalar,     DefaultAllocator: Allocator<N, Dynamic, C>,     <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer == MatrixVec<N, Dynamic, C>,

type RStride = U1

type CStride = Dynamic

fn ptr(&self) -> *const N

fn shape(&self) -> (Dynamic, C)

fn strides(     &self ) -> (<MatrixVec<N, Dynamic, C> as Storage<N, Dynamic, C>>::RStride, <MatrixVec<N, Dynamic, C> as Storage<N, Dynamic, C>>::CStride)

fn is_contiguous(&self) -> bool

fn into_owned(self) -> <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer where     DefaultAllocator: Allocator<N, Dynamic, C>,

fn clone_owned(&self) -> <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer where     DefaultAllocator: Allocator<N, Dynamic, C>,

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn as_slice(&self) -> &[N]

fn linear_index(&self, irow: usize, icol: usize) -> usize

unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const N

unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const N

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked_linear(&self, i: usize) -> &N

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N

impl<N, R> Storage<N, R, Dynamic> for MatrixVec<N, R, Dynamic> where     N: Scalar,     R: DimName,     DefaultAllocator: Allocator<N, R, Dynamic>,     <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer == MatrixVec<N, R, Dynamic>,

type RStride = U1

type CStride = R

fn ptr(&self) -> *const N

fn shape(&self) -> (R, Dynamic)

fn strides(     &self ) -> (<MatrixVec<N, R, Dynamic> as Storage<N, R, Dynamic>>::RStride, <MatrixVec<N, R, Dynamic> as Storage<N, R, Dynamic>>::CStride)

fn is_contiguous(&self) -> bool

fn into_owned(self) -> <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer where     DefaultAllocator: Allocator<N, R, Dynamic>,

fn clone_owned(&self) -> <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer where     DefaultAllocator: Allocator<N, R, Dynamic>,

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

fn as_slice(&self) -> &[N]

fn linear_index(&self, irow: usize, icol: usize) -> usize

unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const N

unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const N

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked_linear(&self, i: usize) -> &N

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N

Implementors