Struct CsrBase 

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

Raw representation of a scipy.sparse.csr_matrix.

In spirit, each field is simply a Vec. (see the type alias Csr). 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].

data: Data

A vector of length nnz containing all of the nonzero elements, sorted by row.

indices: Indices

A vector of length nnz indicating the column of each element.

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

indptr: Indptr

A vector of length nrow + 1 indicating the indices that partition Self::data and Self::indices into data for each row.

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

Implementations

impl<T: Deserialize> CsrBase<T, Vec<T>, Vec<u64>, Vec<usize>>

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

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

impl<T, Data, Indices, Indptr> CsrBase<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 csr_matrix matrix, like scipy.sparse.save_npz.

Panics

This method does not currently perform any significant validation of input, but validation (with panics) may be added later in a future semver major bump.

Trait Implementations

impl<T: Clone, Data, Indices, Indptr> Clone for CsrBase<T, Data, Indices, Indptr>

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

fn clone(&self) -> CsrBase<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 CsrBase<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 CsrBase<T, Data, Indices, Indptr>

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

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

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