Struct npyz::sparse::BsrBase

pub struct BsrBase<T, Data, Indices, Indptr> where
    Data: Deref<Target = [T]>,
    Indices: AsRef<[u64]>,
    Indptr: AsRef<[usize]>,  {
    pub shape: [u64; 2],
    pub blocksize: [usize; 2],
    pub data: Data,
    pub indices: Indices,
    pub indptr: Indptr,
}

Raw representation of a scipy.sparse.bsr_matrix.

In spirit, each field is simply a Vec. (see the type alias Bsr). This generic base class exists in order to allow you to use slices when writing.

Fields

shape: [u64; 2]

Dimensions of the matrix [nrow, ncol].

These dimensions must be divisible by the respective elements of blocksize.

blocksize: [usize; 2]

Size of the blocks in the matrix.

data: Data

Contains the C-order data of a shape [nnzb, block_nrow, block_ncol] ndarray.

(effectively concatenating the flattened data of all nonzero blocks, sorted by superrow)

indices: Indices

A vector of length nnzb indicating the supercolumn index of each block.

Beware: scipy does not require or guarantee that the column indices within each row are sorted.

indptr: Indptr

A vector of length (nrow / block_nrow) + 1 indicating the indices which partition Self::indices and the outermost axis of Self::data into data for each superrow.

Typically, the elements are nondecreasing, with the first equal to 0 and the final equal to nnzb (though the set of requirements that are actually validated by scipy are weaker and somewhat arbitrary).

Implementations

impl<T: Deserialize> BsrBase<T, Vec<T, Global>, Vec<u64, Global>, Vec<usize, Global>>

pub fn from_npz<R: Read + Seek>(npz: &mut NpzArchive<R>) -> Result<Self>

Read a sparse bsr_matrix saved by scipy.sparse.save_npz.

impl<T, Data, Indices, Indptr> BsrBase<T, Data, Indices, Indptr> where
    T: AutoSerialize,
    Data: Deref<Target = [T]>,
    Indices: AsRef<[u64]>,
    Indptr: AsRef<[usize]>, 

pub fn write_npz<W: Write + Seek>(&self, npz: &mut NpzWriter<W>) -> Result<()>

Write a sparse bsr_matrix matrix, like scipy.sparse.save_npz.

Panics

Panics if data.len() is not equal to indices.len() * blocksize[0] * blocksize[1].

Trait Implementations

impl<T: Clone, Data: Clone, Indices: Clone, Indptr: Clone> Clone for BsrBase<T, Data, Indices, Indptr> where
    Data: Deref<Target = [T]>,
    Indices: AsRef<[u64]>,
    Indptr: AsRef<[usize]>, 

fn clone(&self) -> BsrBase<T, Data, Indices, Indptr>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, Data: Debug, Indices: Debug, Indptr: Debug> Debug for BsrBase<T, Data, Indices, Indptr> where
    Data: Deref<Target = [T]>,
    Indices: AsRef<[u64]>,
    Indptr: AsRef<[usize]>, 

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

Formats the value using the given formatter.

impl<T: PartialEq, Data: PartialEq, Indices: PartialEq, Indptr: PartialEq> PartialEq<BsrBase<T, Data, Indices, Indptr>> for BsrBase<T, Data, Indices, Indptr> where
    Data: Deref<Target = [T]>,
    Indices: AsRef<[u64]>,
    Indptr: AsRef<[usize]>, 

fn eq(&self, other: &BsrBase<T, Data, Indices, Indptr>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &BsrBase<T, Data, Indices, Indptr>) -> bool

This method tests for !=.

impl<T: Eq, Data: Eq, Indices: Eq, Indptr: Eq> Eq for BsrBase<T, Data, Indices, Indptr> where
    Data: Deref<Target = [T]>,
    Indices: AsRef<[u64]>,
    Indptr: AsRef<[usize]>, 

impl<T, Data, Indices, Indptr> StructuralEq for BsrBase<T, Data, Indices, Indptr> where
    Data: Deref<Target = [T]>,
    Indices: AsRef<[u64]>,
    Indptr: AsRef<[usize]>, 

impl<T, Data, Indices, Indptr> StructuralPartialEq for BsrBase<T, Data, Indices, Indptr> where
    Data: Deref<Target = [T]>,
    Indices: AsRef<[u64]>,
    Indptr: AsRef<[usize]>,