Struct 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>, Vec<u64>, Vec<usize>>

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, Indices, Indptr> Clone for BsrBase<T, Data, Indices, Indptr>

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, Data, Indices, Indptr> Debug for BsrBase<T, Data, Indices, Indptr>

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

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

Formats the value using the given formatter.

impl<T: PartialEq, Data, Indices, Indptr> PartialEq for BsrBase<T, Data, Indices, Indptr>

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

fn eq(&self, other: &BsrBase<T, Data, Indices, Indptr>) -> 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: Eq, Data, Indices, Indptr> Eq for BsrBase<T, Data, Indices, Indptr>

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

impl<T, Data, Indices, Indptr> StructuralPartialEq for BsrBase<T, Data, Indices, Indptr>

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