Struct SparseBinVecBase

pub struct SparseBinVecBase<T> { /* private fields */ }

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

impl SparseBinVecBase<Vec<usize>>

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);

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);

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]);

impl<T: Deref<Target = [usize]>> SparseBinVecBase<T>

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);

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));

pub fn len(&self) -> usize

Returns the length (number of elements) of the vector.

pub fn weight(&self) -> usize

Returns the number of elements with value 1 in the vector.

pub fn is_empty(&self) -> bool

Returns true if the length of the vector is 0.

pub fn is_zero(&self) -> bool

Returns true if all the element in the vector are 0.

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());

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);

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);

pub fn non_trivial_positions<'a>(&'a self) -> NonTrivialPositions<'a>

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);

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);

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);

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));

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));

pub fn as_view(&self) -> SparseBinSlice<'_>

Returns a view over the vector.

pub fn as_slice(&self) -> &[usize]

Returns a slice of the non trivial positions.

pub fn to_vec(self) -> SparseBinVec

Returns an owned version of the vector.

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())));

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));

pub fn as_json(&self) -> Result<String, Error>

where T: Serialize,

Returns a json string for the vector.

Trait Implementations

impl<S, T> Add<&SparseBinVecBase<S>> for &SparseBinVecBase<T>

where S: Deref<Target = [usize]>, T: Deref<Target = [usize]>,

type Output = SparseBinVecBase<Vec<usize>>

The resulting type after applying the + operator.

fn add(self, other: &SparseBinVecBase<S>) -> Self::Output

Performs the + operation.

impl<T: Clone> Clone for SparseBinVecBase<T>

fn clone(&self) -> SparseBinVecBase<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SparseBinVecBase<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for SparseBinVecBase<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Deref<Target = [usize]>> Display for SparseBinVecBase<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for SparseBinVecBase<T>

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<S, T> Mul<&SparseBinVecBase<S>> for &SparseBinVecBase<T>

where S: Deref<Target = [usize]>, T: Deref<Target = [usize]>,

type Output = BinNum

The resulting type after applying the * operator.

fn mul(self, other: &SparseBinVecBase<S>) -> Self::Output

Performs the * operation.

impl<T: Deref<Target = [usize]>> Mul<&SparseBinVecBase<T>> for &SparseBinMat

type Output = SparseBinVecBase<Vec<usize>>

The resulting type after applying the * operator.

fn mul(self, other: &SparseBinVecBase<T>) -> SparseBinVec

Performs the * operation.

impl<T: PartialEq> PartialEq for SparseBinVecBase<T>

fn eq(&self, other: &SparseBinVecBase<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Serialize for SparseBinVecBase<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for SparseBinVecBase<T>

impl<T> StructuralPartialEq for SparseBinVecBase<T>