Struct vectors::sparse::stack::SparseVector

pub struct SparseVector<A> where
    A: Array,  { /* fields omitted */ }

A sparse stack-allocated multi-dimensional vector.

Methods

impl<T, A> SparseVector<A> where
    A: Array<Item = (usize, T)>, 

pub fn len(&self) -> usize

The number of components in self

pub fn is_empty(&self) -> bool

true if self.len() == 0, otherwise false

Important traits for Iter<'a, T>

impl<'a, T> Iterator for Iter<'a, T> where
    T: Copy,  type Item = (usize, T);

pub fn iter<'a>(&'a self) -> Iter<'a, T>

A borrowing iterator over self

Trait Implementations

impl<T, A, V> Add<V> for SparseVector<A> where
    T: Copy + Zero + Add<T, Output = T>,
    A: Array<Item = (usize, T)>,
    V: IntoIterator<Item = (usize, T)>,
    <V as IntoIterator>::IntoIter: ExactSizeIterator + OrderedMapIterator<Key = usize, Val = T>, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: V) -> Self::Output

Performs the + operation.

impl<T, A, V> AddAssign<V> for SparseVector<A> where
    T: Copy + Zero + Add<T, Output = T>,
    A: Array<Item = (usize, T)>,
    V: IntoIterator<Item = (usize, T)>,
    <V as IntoIterator>::IntoIter: ExactSizeIterator + OrderedMapIterator<Key = usize, Val = T>, 

fn add_assign(&mut self, rhs: V)

Performs the += operation.

impl<T, A, V> Sub<V> for SparseVector<A> where
    T: Copy + Zero + Sub<T, Output = T>,
    A: Array<Item = (usize, T)>,
    V: IntoIterator<Item = (usize, T)>,
    <V as IntoIterator>::IntoIter: ExactSizeIterator + OrderedMapIterator<Key = usize, Val = T>, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: V) -> Self::Output

Performs the - operation.

impl<T, A, V> SubAssign<V> for SparseVector<A> where
    T: Copy + Zero + Sub<T, Output = T>,
    A: Array<Item = (usize, T)>,
    V: IntoIterator<Item = (usize, T)>,
    <V as IntoIterator>::IntoIter: ExactSizeIterator + OrderedMapIterator<Key = usize, Val = T>, 

fn sub_assign(&mut self, rhs: V)

Performs the -= operation.

impl<T, A> Mul<T> for SparseVector<A> where
    T: Copy + Zero + Mul<T, Output = T>,
    A: Array<Item = (usize, T)>, 

type Output = SparseVector<A>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T, A> MulAssign<T> for SparseVector<A> where
    T: Copy + Zero + Mul<T, Output = T>,
    A: Array<Item = (usize, T)>, 

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T, A> Div<T> for SparseVector<A> where
    T: Copy + Zero + Div<T, Output = T>,
    A: Array<Item = (usize, T)>, 

type Output = SparseVector<A>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T, A> DivAssign<T> for SparseVector<A> where
    T: Copy + Zero + Div<T, Output = T>,
    A: Array<Item = (usize, T)>, 

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T, A, V> MulAdd<T, V> for SparseVector<A> where
    T: Copy + Zero + MulAdd<T, T, Output = T>,
    A: Array<Item = (usize, T)>,
    V: IntoIterator<Item = (usize, T)>,
    <V as IntoIterator>::IntoIter: ExactSizeIterator + OrderedMapIterator<Key = usize, Val = T>, 

type Output = Self

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: T, b: V) -> Self::Output

Performs the fused multiply-add operation.

impl<T, A, V> MulAddAssign<T, V> for SparseVector<A> where
    T: Copy + Zero + MulAdd<T, T, Output = T>,
    A: Array<Item = (usize, T)>,
    V: IntoIterator<Item = (usize, T)>,
    <V as IntoIterator>::IntoIter: ExactSizeIterator + OrderedMapIterator<Key = usize, Val = T>, 

fn mul_add_assign(&mut self, a: T, b: V)

Performs the fused multiply-add operation.

impl<T, A> Dot for SparseVector<A> where
    T: Copy + Add<T, Output = T> + Mul<T, Output = T> + Zero,
    A: Array<Item = (usize, T)>, 

type Scalar = T

The scalar type returned by self's dot product

fn dot(&self, rhs: &Self) -> Self::Scalar

Calculates the dot-product between self and rhs.

impl<T, A> Distance for SparseVector<A> where
    T: Copy + Signed,
    A: Array<Item = (usize, T)>, 

type Scalar = T

The scalar type returned by self's distance

fn squared_distance(&self, rhs: &Self) -> Self::Scalar

Calculates the squared euclidian distance between self and rhs.

fn distance(&self, rhs: &Self) -> Self::Scalar where
    Self::Scalar: Real, 

Calculates the euclidian distance between self and rhs.

impl<T, A> Debug for SparseVector<A> where
    T: Copy + Debug,
    A: Array<Item = (usize, T)>, 

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

Formats the value using the given formatter.

impl<T, A> FromIterator<(usize, T)> for SparseVector<A> where
    A: Array<Item = (usize, T)>, 

fn from_iter<I: IntoIterator<Item = (usize, T)>>(iter: I) -> Self

Creates a value from an iterator.

impl<T, A> IntoIterator for SparseVector<A> where
    A: Array<Item = (usize, T)>, 

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = IntoIter<ArrayVec<A>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, A> IntoIterator for &'a SparseVector<A> where
    T: 'a + Copy,
    A: Array<Item = (usize, T)>, 

type Item = <Self::IntoIter as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, A> Clone for SparseVector<A> where
    T: Clone,
    A: Array<Item = (usize, T)>, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, A> PartialEq for SparseVector<A> where
    T: PartialEq,
    A: Array<Item = (usize, T)>, 

fn eq(&self, other: &Self) -> 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 !=.

impl<T, A> From<A> for SparseVector<A> where
    A: Array<Item = (usize, T)>, 

fn from(items: A) -> Self

Performs the conversion.

impl<V, T, A> VectorOps<V, T> for SparseVector<A> where
    Self: Add<V, Output = Self> + Sub<V, Output = Self> + Mul<T, Output = Self> + Div<T, Output = Self> + MulAdd<T, V, Output = Self>,
    T: Copy + NumAssign + MulAdd<T, T, Output = T>,
    A: Array<Item = (usize, T)>, 

impl<V, T, A> VectorAssignOps<V, T> for SparseVector<A> where
    Self: AddAssign<V> + SubAssign<V> + MulAssign<T> + DivAssign<T> + MulAddAssign<T, V>,
    T: Copy + NumAssign + MulAddAssign,
    A: Array<Item = (usize, T)>, 

impl<T, A> Vector<T> for SparseVector<A> where
    Self: VectorOps<Self, T>,
    T: Copy + PartialOrd + NumAssign + MulAdd<T, T, Output = T>,
    A: Array<Item = (usize, T)>, 

type Scalar = T

The type of the Vector's scalar components.