Struct sparse_bin_mat::SparseBinVecBase
source · [−]pub struct SparseBinVecBase<T> { /* private fields */ }
Expand description
A sparse binary vector.
There are two main variants of a vector,
the owned one, SparseBinVec
, and the borrowed one,
SparseBinSlice
.
Most of the time, you want to create a owned version.
However, some iterators, such as those defined on SparseBinMat
returns the borrowed version.
Implementations
sourceimpl SparseBinVecBase<Vec<usize, Global>>
impl SparseBinVecBase<Vec<usize, Global>>
sourcepub fn zeros(length: usize) -> Self
pub fn zeros(length: usize) -> Self
Creates a vector fill with zeros of the given length.
Example
let vector = SparseBinVec::zeros(3);
assert_eq!(vector.len(), 3);
assert_eq!(vector.weight(), 0);
sourcepub fn empty() -> Self
pub fn empty() -> Self
Creates an empty vector.
This allocate minimally, so it is a good placeholder.
Example
let vector = SparseBinVec::empty();
assert_eq!(vector.len(), 0);
assert_eq!(vector.weight(), 0);
sourcepub fn to_positions_vec(self) -> Vec<usize>
pub fn to_positions_vec(self) -> Vec<usize>
Converts the sparse binary vector to a Vec
of
the non trivial positions.
Example
let vector = SparseBinVec::new(3, vec![0, 2]);
assert_eq!(vector.to_positions_vec(), vec![0, 2]);
sourceimpl<T: Deref<Target = [usize]>> SparseBinVecBase<T>
impl<T: Deref<Target = [usize]>> SparseBinVecBase<T>
sourcepub fn new(length: usize, positions: T) -> Self
pub fn new(length: usize, positions: T) -> Self
Creates a new vector with the given length and list of non trivial positions.
Example
use sparse_bin_mat::error::InvalidPositions;
let vector = SparseBinVec::new(5, vec![0, 2]);
assert_eq!(vector.len(), 5);
assert_eq!(vector.weight(), 2);
sourcepub fn try_new(length: usize, positions: T) -> Result<Self, InvalidPositions>
pub fn try_new(length: usize, positions: T) -> Result<Self, InvalidPositions>
Creates a new vector with the given length and list of non trivial positions or returns as error if the positions are unsorted, greater or equal to length or contain duplicates.
Example
use sparse_bin_mat::error::InvalidPositions;
let vector = SparseBinVec::try_new(5, vec![0, 2]);
assert_eq!(vector, Ok(SparseBinVec::new(5, vec![0, 2])));
let vector = SparseBinVec::try_new(5, vec![2, 0]);
assert_eq!(vector, Err(InvalidPositions::Unsorted));
let vector = SparseBinVec::try_new(5, vec![0, 10]);
assert_eq!(vector, Err(InvalidPositions::OutOfBound));
let vector = SparseBinVec::try_new(5, vec![0, 0]);
assert_eq!(vector, Err(InvalidPositions::Duplicated));
sourcepub fn get(&self, position: usize) -> Option<BinNum>
pub fn get(&self, position: usize) -> Option<BinNum>
Returns the value at the given position or None if the position is out of bound.
Example
let vector = SparseBinVec::new(3, vec![0, 2]);
assert!(vector.get(0).unwrap().is_one());
assert!(vector.get(1).unwrap().is_zero());
assert!(vector.get(2).unwrap().is_one());
assert!(vector.get(3).is_none());
sourcepub fn is_zero_at(&self, position: usize) -> Option<bool>
pub fn is_zero_at(&self, position: usize) -> Option<bool>
Returns true if the value at the given position is 0 or None if the position is out of bound.
Example
let vector = SparseBinVec::new(3, vec![0, 2]);
assert_eq!(vector.is_zero_at(0), Some(false));
assert_eq!(vector.is_zero_at(1), Some(true));
assert_eq!(vector.is_zero_at(2), Some(false));
assert_eq!(vector.is_zero_at(3), None);
sourcepub fn is_one_at(&self, position: usize) -> Option<bool>
pub fn is_one_at(&self, position: usize) -> Option<bool>
Returns true if the value at the given position is 1 or None if the position is out of bound.
Example
let vector = SparseBinVec::new(3, vec![0, 2]);
assert_eq!(vector.is_one_at(0), Some(true));
assert_eq!(vector.is_one_at(1), Some(false));
assert_eq!(vector.is_one_at(2), Some(true));
assert_eq!(vector.is_one_at(3), None);
sourcepub fn non_trivial_positions<'a>(&'a self) -> NonTrivialPositions<'a>ⓘNotable traits for NonTrivialPositions<'vec>impl<'vec> Iterator for NonTrivialPositions<'vec> type Item = usize;
pub fn non_trivial_positions<'a>(&'a self) -> NonTrivialPositions<'a>ⓘNotable traits for NonTrivialPositions<'vec>impl<'vec> Iterator for NonTrivialPositions<'vec> type Item = usize;
Returns an iterator over all positions where the value is 1.
Example
let vector = SparseBinVec::new(5, vec![0, 1, 3]);
let mut iter = vector.non_trivial_positions();
assert_eq!(iter.next(), Some(0));
assert_eq!(iter.next(), Some(1));
assert_eq!(iter.next(), Some(3));
assert_eq!(iter.next(), None);
sourcepub fn iter_dense<'a>(&'a self) -> IterDense<'a, T>
pub fn iter_dense<'a>(&'a self) -> IterDense<'a, T>
Returns an iterator over all value in the vector.
Example
let vector = SparseBinVec::new(4, vec![0, 2]);
let mut iter = vector.iter_dense();
assert_eq!(iter.next(), Some(BinNum::one()));
assert_eq!(iter.next(), Some(BinNum::zero()));
assert_eq!(iter.next(), Some(BinNum::one()));
assert_eq!(iter.next(), Some(BinNum::zero()));
assert_eq!(iter.next(), None);
sourcepub fn concat(&self, other: &Self) -> SparseBinVec
pub fn concat(&self, other: &Self) -> SparseBinVec
Returns the concatenation of two vectors.
Example
let left_vector = SparseBinVec::new(3, vec![0, 1]);
let right_vector = SparseBinVec::new(4, vec![2, 3]);
let concatened = left_vector.concat(&right_vector);
let expected = SparseBinVec::new(7, vec![0, 1, 5, 6]);
assert_eq!(concatened, expected);
sourcepub fn keep_only_positions(
&self,
positions: &[usize]
) -> Result<SparseBinVec, InvalidPositions>
pub fn keep_only_positions(
&self,
positions: &[usize]
) -> Result<SparseBinVec, InvalidPositions>
Returns a new vector keeping only the given positions or an error if the positions are unsorted, out of bound or contain deplicate.
Positions are relabeled to the fit new number of positions.
Example
use sparse_bin_mat::SparseBinVec;
let vector = SparseBinVec::new(5, vec![0, 2, 4]);
let truncated = SparseBinVec::new(3, vec![0, 2]);
assert_eq!(vector.keep_only_positions(&[0, 1, 2]), Ok(truncated));
assert_eq!(vector.keep_only_positions(&[1, 2]).map(|vec| vec.len()), Ok(2));
sourcepub fn without_positions(
&self,
positions: &[usize]
) -> Result<SparseBinVec, InvalidPositions>
pub fn without_positions(
&self,
positions: &[usize]
) -> Result<SparseBinVec, InvalidPositions>
Returns a truncated vector where the given positions are remove or an error if the positions are unsorted or out of bound.
Positions are relabeled to fit the new number of positions.
Example
let vector = SparseBinVec::new(5, vec![0, 2, 4]);
let truncated = SparseBinVec::new(3, vec![0, 2]);
assert_eq!(vector.without_positions(&[3, 4]), Ok(truncated));
assert_eq!(vector.without_positions(&[1, 2]).map(|vec| vec.len()), Ok(3));
sourcepub fn as_view(&self) -> SparseBinSlice<'_>
pub fn as_view(&self) -> SparseBinSlice<'_>
Returns a view over the vector.
sourcepub fn to_vec(self) -> SparseBinVec
pub fn to_vec(self) -> SparseBinVec
Returns an owned version of the vector.
sourcepub fn dot_with<S: Deref<Target = [usize]>>(
&self,
other: &SparseBinVecBase<S>
) -> Result<BinNum, IncompatibleDimensions<usize, usize>>
pub fn dot_with<S: Deref<Target = [usize]>>(
&self,
other: &SparseBinVecBase<S>
) -> Result<BinNum, IncompatibleDimensions<usize, usize>>
Returns the dot product of two vectors or an error if the vectors have different length.
Example
let first = SparseBinVec::new(4, vec![0, 1, 2]);
let second = SparseBinVec::new(4, vec![1, 2, 3]);
let third = SparseBinVec::new(4, vec![0, 3]);
assert_eq!(first.dot_with(&second), Ok(0.into()));
assert_eq!(first.dot_with(&third), Ok((1.into())));
sourcepub fn bitwise_xor_with<S: Deref<Target = [usize]>>(
&self,
other: &SparseBinVecBase<S>
) -> Result<SparseBinVec, IncompatibleDimensions<usize, usize>>
pub fn bitwise_xor_with<S: Deref<Target = [usize]>>(
&self,
other: &SparseBinVecBase<S>
) -> Result<SparseBinVec, IncompatibleDimensions<usize, usize>>
Returns the bitwise xor of two vectors or an error if the vectors have different length.
Use the Add (+) operator if you want a version that panics instead or returning an error.
Example
let first = SparseBinVec::new(4, vec![0, 1, 2]);
let second = SparseBinVec::new(4, vec![1, 2, 3]);
let third = SparseBinVec::new(4, vec![0, 3]);
assert_eq!(first.bitwise_xor_with(&second), Ok(third));
Trait Implementations
sourceimpl<S, T> Add<&'_ SparseBinVecBase<S>> for &SparseBinVecBase<T> where
S: Deref<Target = [usize]>,
T: Deref<Target = [usize]>,
impl<S, T> Add<&'_ SparseBinVecBase<S>> for &SparseBinVecBase<T> where
S: Deref<Target = [usize]>,
T: Deref<Target = [usize]>,
type Output = SparseBinVec
type Output = SparseBinVec
The resulting type after applying the +
operator.
sourcefn add(self, other: &SparseBinVecBase<S>) -> Self::Output
fn add(self, other: &SparseBinVecBase<S>) -> Self::Output
Performs the +
operation. Read more
sourceimpl<T: Clone> Clone for SparseBinVecBase<T>
impl<T: Clone> Clone for SparseBinVecBase<T>
sourcefn clone(&self) -> SparseBinVecBase<T>
fn clone(&self) -> SparseBinVecBase<T>
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl<T: Debug> Debug for SparseBinVecBase<T>
impl<T: Debug> Debug for SparseBinVecBase<T>
sourceimpl<'de, T> Deserialize<'de> for SparseBinVecBase<T> where
T: Deserialize<'de>,
impl<'de, T> Deserialize<'de> for SparseBinVecBase<T> where
T: Deserialize<'de>,
sourcefn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
sourceimpl<T: Hash> Hash for SparseBinVecBase<T>
impl<T: Hash> Hash for SparseBinVecBase<T>
sourceimpl<S, T> Mul<&'_ SparseBinVecBase<S>> for &SparseBinVecBase<T> where
S: Deref<Target = [usize]>,
T: Deref<Target = [usize]>,
impl<S, T> Mul<&'_ SparseBinVecBase<S>> for &SparseBinVecBase<T> where
S: Deref<Target = [usize]>,
T: Deref<Target = [usize]>,
sourceimpl<T: Deref<Target = [usize]>> Mul<&'_ SparseBinVecBase<T>> for &SparseBinMat
impl<T: Deref<Target = [usize]>> Mul<&'_ SparseBinVecBase<T>> for &SparseBinMat
type Output = SparseBinVec
type Output = SparseBinVec
The resulting type after applying the *
operator.
sourcefn mul(self, other: &SparseBinVecBase<T>) -> SparseBinVec
fn mul(self, other: &SparseBinVecBase<T>) -> SparseBinVec
Performs the *
operation. Read more
sourceimpl<T: PartialEq> PartialEq<SparseBinVecBase<T>> for SparseBinVecBase<T>
impl<T: PartialEq> PartialEq<SparseBinVecBase<T>> for SparseBinVecBase<T>
sourcefn eq(&self, other: &SparseBinVecBase<T>) -> bool
fn eq(&self, other: &SparseBinVecBase<T>) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
sourcefn ne(&self, other: &SparseBinVecBase<T>) -> bool
fn ne(&self, other: &SparseBinVecBase<T>) -> bool
This method tests for !=
.
sourceimpl<T> Serialize for SparseBinVecBase<T> where
T: Serialize,
impl<T> Serialize for SparseBinVecBase<T> where
T: Serialize,
impl<T: Eq> Eq for SparseBinVecBase<T>
impl<T> StructuralEq for SparseBinVecBase<T>
impl<T> StructuralPartialEq for SparseBinVecBase<T>
Auto Trait Implementations
impl<T> RefUnwindSafe for SparseBinVecBase<T> where
T: RefUnwindSafe,
impl<T> Send for SparseBinVecBase<T> where
T: Send,
impl<T> Sync for SparseBinVecBase<T> where
T: Sync,
impl<T> Unpin for SparseBinVecBase<T> where
T: Unpin,
impl<T> UnwindSafe for SparseBinVecBase<T> where
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more