Struct sprs::IndPtrBase

pub struct IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>,  { /* fields omitted */ }

Implementations

impl<Iptr, Storage> IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>, 

pub fn new_checked(storage: Storage) -> Result<Self, (Storage, StructureError)>

pub fn view(&self) -> IndPtrView<'_, Iptr>

pub fn len(&self) -> usize

The length of the underlying storage

pub fn is_empty(&self) -> bool

Tests whether this indptr is empty

pub fn outer_dims(&self) -> usize

The number of outer dimensions this indptr represents

pub fn is_proper(&self) -> bool

Indicates whether the underlying storage is proper, which means the indptr corresponds to a non-sliced matrix.

An empty matrix is considered non-proper.

pub fn as_slice(&self) -> Option<&[Iptr]>

Return a view on the underlying slice if it is a proper indptr slice, which is the case if its first element is 0. None will be returned otherwise.

pub fn raw_storage(&self) -> &[Iptr]

Return a view of the underlying storage. Should be used with care in sparse algorithms, as this won’t check if the storage corresponds to a proper matrix

pub fn into_raw_storage(self) -> Storage

Consume self and return the underlying storage

pub fn to_owned(&self) -> IndPtr<Iptr>

pub fn to_proper(&self) -> Cow<'_, [Iptr]>

Returns a proper indptr representation, cloning if we do not have a proper indptr.

Warning

For ffi usage, one needs to call Cow::as_ptr, but it’s important to keep the Cow alive during the lifetime of the pointer. Example of a correct and incorrect ffi usage:

let mat: sprs::CsMat<f64> = sprs::CsMat::eye(5);
let mid = mat.view().middle_outer_views(1, 2);
let ptr = {
    let indptr = mid.indptr(); // needed for lifetime
    let indptr_proper = indptr.to_proper();
    println!(
        "ptr {:?} is valid as long as _indptr_proper_owned is in scope",
        indptr_proper.as_ptr()
    );
    indptr_proper.as_ptr()
};
// This line is UB.
// println!("ptr deref: {}", *ptr);

It is much easier to directly use the proper_indptr method of CsMatBase directly:

let mat: sprs::CsMat<f64> = sprs::CsMat::eye(5);
let mid = mat.view().middle_outer_views(1, 2);
let ptr = {
    let indptr_proper = mid.proper_indptr();
    println!(
        "ptr {:?} is valid as long as _indptr_proper_owned is in scope",
        indptr_proper.as_ptr()
    );
    indptr_proper.as_ptr()
};
// This line is UB.
// println!("ptr deref: {}", *ptr);

pub fn iter_outer_nnz_inds(
    &self
) -> impl DoubleEndedIterator<Item = usize> + ExactSizeIterator<Item = usize> + '_

Iterate over the nonzeros represented by this indptr, yielding the outer dimension for each nonzero

pub fn iter_outer(
    &self
) -> impl DoubleEndedIterator<Item = Range<Iptr>> + ExactSizeIterator<Item = Range<Iptr>> + '_

Iterate over outer dimensions, yielding start and end indices for each outer dimension.

pub fn iter_outer_sz(
    &self
) -> impl DoubleEndedIterator<Item = Range<usize>> + ExactSizeIterator<Item = Range<usize>> + '_

Iterate over outer dimensions, yielding start and end indices for each outer dimension.

Returns a range of usize to ensure iteration of indices and data is easy

pub fn index(&self, i: usize) -> Iptr

Return the value of the indptr at index i. This method is intended for low-level usage only, outer_inds should be preferred most of the time

pub fn outer_inds(&self, i: usize) -> Range<Iptr>

Get the start and end indices for the requested outer dimension

Panics

If i >= self.outer_dims()

pub fn outer_inds_sz(&self, i: usize) -> Range<usize>

Get the start and end indices for the requested outer dimension

Returns a range of usize to ensure iteration of indices and data is easy

Panics

If i >= self.outer_dims()

pub fn nnz_in_outer(&self, i: usize) -> Iptr

Get the number of nonzeros in the requested outer dimension

Panics

If i >= self.outer_dims()

pub fn nnz_in_outer_sz(&self, i: usize) -> usize

Get the number of nonzeros in the requested outer dimension

Returns a usize

Panics

If i >= self.outer_dims()

pub fn outer_inds_slice(&self, start: usize, end: usize) -> Range<usize>

Get the start and end indices for the requested outer dimension slice

Panics

If start >= self.outer_dims() || end > self.outer_dims()

pub fn nnz(&self) -> usize

The number of nonzero elements described by this indptr

pub fn nnz_i(&self) -> Iptr

The number of nonzero elements described by this indptr, using the actual storage type

Trait Implementations

impl<Iptr: Clone, Storage: Clone> Clone for IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>, 

fn clone(&self) -> IndPtrBase<Iptr, Storage>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Iptr: Copy, Storage: Copy> Copy for IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>, 

impl<Iptr: Debug, Storage: Debug> Debug for IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>, 

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

Formats the value using the given formatter.

impl<'de, Iptr, Storage> Deserialize<'de> for IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>,
    Storage: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<Iptr: Eq, Storage: Eq> Eq for IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>, 

impl<Iptr: Hash, Storage: Hash> Hash for IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>, 

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<Iptr: PartialEq, Storage: PartialEq> PartialEq<IndPtrBase<Iptr, Storage>> for IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>, 

fn eq(&self, other: &IndPtrBase<Iptr, Storage>) -> bool

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

fn ne(&self, other: &IndPtrBase<Iptr, Storage>) -> bool

This method tests for !=.

impl<Iptr: SpIndex, IptrStorage, IptrStorage2> PartialEq<IptrStorage2> for IndPtrBase<Iptr, IptrStorage> where
    IptrStorage: Deref<Target = [Iptr]>,
    IptrStorage2: Deref<Target = [Iptr]>, 

Allows comparison to vectors and slices

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Iptr, Storage> Serialize for IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>,
    Storage: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<Iptr, Storage> StructuralEq for IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>, 

impl<Iptr, Storage> StructuralPartialEq for IndPtrBase<Iptr, Storage> where
    Iptr: SpIndex,
    Storage: Deref<Target = [Iptr]>,