Struct SparseMapVector 

pub struct SparseMapVector<R: RingStore> { /* private fields */ }

Implementations

impl<R: RingStore> SparseMapVector<R>

pub fn new(len: usize, ring: R) -> Self

pub fn set_len(&mut self, new_len: usize)

Available on crate feature unstable-enable only.

Availability

This API is marked as unstable and is only available when the unstable-enable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn scan<F>(&mut self, f: F)

where F: FnMut(usize, &mut El<R>),

Available on crate feature unstable-enable only.

Availability

This API is marked as unstable and is only available when the unstable-enable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

Trait Implementations

impl<R: RingStore + Clone> Clone for SparseMapVector<R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: RingStore + Clone> Debug for SparseMapVector<R>

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

Formats the value using the given formatter.

impl<R: RingStore> VectorView<<<R as RingStore>::Type as RingBase>::Element> for SparseMapVector<R>

fn at(&self, i: usize) -> &El<R>

fn len(&self) -> usize

fn specialize_sparse<'a, Op: SparseVectorViewOperation<El<R>>>( &'a self, op: Op, ) -> Result<Op::Output<'a>, ()>

Calls op with self if this vector view supports sparse access. Otherwise, () is returned.

unsafe fn at_unchecked<'a>(&self, i: usize) -> &T

Returns a refernce to the i-th entry of the vector view, causing UB if i >= self.len().

fn as_iter<'a>(&'a self) -> VectorFnIter<VectorViewFn<'a, Self, T>, &'a T>

Returns an iterator over all elements in this vector.

fn as_fn<'a>(&'a self) -> VectorViewFn<'a, Self, T>

Converts this vector into a VectorFn that yields references &T.

fn as_slice<'a>(&'a self) -> Option<&'a [T]>

where T: Sized,

If the underlying data of this VectorView can be represented as a slice, returns it. Otherwise, None is returned.

fn into_clone_ring_els<R: RingStore>( self, ring: R, ) -> CloneElFn<Self, T, CloneRingEl<R>>

where Self: Sized, T: Sized, R::Type: RingBase<Element = T>,

Moves this vector into a VectorFn that clones ring elements on access using the given ring.

fn clone_ring_els<'a, R: RingStore>( &'a self, ring: R, ) -> CloneElFn<&'a Self, T, CloneRingEl<R>>

where T: Sized, R::Type: RingBase<Element = T>,

Converts this vector into a VectorFn that clones ring elements on access using the given ring.

fn into_clone_els_by<F>(self, clone_entry: F) -> CloneElFn<Self, T, F>

where Self: Sized, T: Sized, F: Fn(&T) -> T,

Moves this vector into a VectorFn that clones elements on access using the given function.

fn clone_els_by<'a, F>(&'a self, clone_entry: F) -> CloneElFn<&'a Self, T, F>

where T: Sized, F: Fn(&T) -> T,

Converts this vector into a VectorFn that clones elements on access using the given function.

fn into_clone_els(self) -> CloneElFn<Self, T, CloneValue>

where Self: Sized, T: Sized + Clone,

Moves this vector into a VectorFn that clones elements on access.

fn clone_els<'a>(&'a self) -> CloneElFn<&'a Self, T, CloneValue>

where T: Sized + Clone,

Converts this vector into a VectorFn that clones elements on access.

fn into_copy_els(self) -> CloneElFn<Self, T, CloneValue>

where Self: Sized, T: Sized + Copy,

Moves this vector into a VectorFn that copies elements on access.

fn copy_els<'a>(&'a self) -> CloneElFn<&'a Self, T, CloneValue>

where T: Sized + Copy,

Converts this vector into a VectorFn that copies elements on access.

fn map_view<F: for<'a> Fn(&'a T) -> &'a U, U>( self, func: F, ) -> VectorViewMap<Self, T, U, F>

where Self: Sized,

Creates a new VectorView whose elements are the results of the given function applied to the elements of this vector.

fn step_by_view(self, step_by: usize) -> StepBy<Self, T>

where Self: Sized,

Called step_by_view() to prevent name conflicts with Iterator::step_by().

impl<R: RingStore> VectorViewMut<<<R as RingStore>::Type as RingBase>::Element> for SparseMapVector<R>

fn at_mut(&mut self, i: usize) -> &mut El<R>

fn map_mut<F_const: for<'a> Fn(&'a T) -> &'a U, F_mut: for<'a> FnMut(&'a mut T) -> &'a mut U, U>( self, map_const: F_const, map_mut: F_mut, ) -> VectorViewMapMut<Self, T, U, F_const, F_mut>

where Self: Sized,

fn as_slice_mut<'a>(&'a mut self) -> Option<&'a mut [T]>

where T: Sized,

If the underlying data of this VectorView can be represented as a slice, returns it. Otherwise, None is returned.

unsafe fn at_unchecked_mut<'a>(&mut self, i: usize) -> &mut T

Returns a refernce to the i-th entry of the vector view, causing UB if i >= self.len().

impl<R: RingStore> VectorViewSparse<<<R as RingStore>::Type as RingBase>::Element> for SparseMapVector<R>

type Iter<'a> = SparseMapVectorIter<'a, R> where Self: 'a

fn nontrivial_entries<'a>(&'a self) -> Self::Iter<'a>

Returns an iterator over all elements of the sequence with their indices that are “nonzero” (T must have an appropriate notion of zero).