Struct sprs::IndPtrBase

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

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, Storage> Clone for IndPtrBase<Iptr, Storage>where Iptr: SpIndex + Clone, Storage: Deref<Target = [Iptr]> + Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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]> + 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, Storage> Hash for IndPtrBase<Iptr, Storage>where Iptr: SpIndex + Hash, Storage: Deref<Target = [Iptr]> + Hash,

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

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

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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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 ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Iptr, Storage> Serialize for IndPtrBase<Iptr, Storage>where Iptr: SpIndex, Storage: Deref<Target = [Iptr]> + 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> Copy for IndPtrBase<Iptr, Storage>where Iptr: SpIndex + Copy, Storage: Deref<Target = [Iptr]> + Copy,

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

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]>,