Struct BiVec 

pub struct BiVec<T> {
    pub(crate) data: Vec<T>,
    pub(crate) min_degree: i32,
}

A BiVec is like a Vec, except we allow indices to be negative. It has a min_degree property which tells us where the starting index is.

Note that properties like length and capacity are defined to be the maximum index allowed. For example, if v.min_degree = -2 and v.len() = 3, it means we can access v[-2], v[-1], v[0], v[1], v[2] but not v[3].

Fields

data: Vec<T>

min_degree: i32

Implementations

impl<T: Clone> BiVec<T>

pub fn extend_negative(&mut self, min_degree: i32, default: T)

If min_degree < self.min_degree, set self.min_degree to min_degree and pad the remaining spaces with default.

Example

let mut v = BiVec::from_vec(-2, vec![3, 4, 6, 2]);
v.extend_negative(-4, 0);
assert_eq!(v[1], 2);
assert_eq!(v[-4], 0);
assert_eq!(v.min_degree(), -4);

impl<T> BiVec<T>

pub fn new(min_degree: i32) -> Self

pub fn from_vec(min_degree: i32, data: Vec<T>) -> Self

pub fn into_vec(self) -> Vec<T>

pub fn with_capacity(min_degree: i32, capacity: i32) -> Self

pub const fn min_degree(&self) -> i32

pub fn max_degree(&self) -> i32

This returns the largest degree in the bivector. This is equal to self.len() - 1.

Example

let v = BiVec::from_vec(-2, vec![3, 4, 6, 8, 2]);
assert_eq!(v.max_degree(), 2);

pub fn len(&self) -> i32

This returns the “length” of the bivector, defined to be the smallest i such that v[i] is not defined.

Example

let v = BiVec::from_vec(-2, vec![3, 4, 6, 8, 2]);
assert_eq!(v.len(), 3);

pub fn is_empty(&self) -> bool

pub fn push(&mut self, x: T)

pub fn get(&self, idx: i32) -> Option<&T>

pub fn get_max(&self, idx: i32) -> &T

Get the idxth element if it exists; the last element otherwise

pub fn last(&self) -> Option<&T>

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

pub fn iter_mut(&mut self) -> IterMut<'_, T>

pub fn iter_enum(&self) -> impl DoubleEndedIterator<Item = (i32, &T)>

pub fn iter_mut_enum( &mut self, ) -> impl DoubleEndedIterator<Item = (i32, &mut T)>

pub fn into_iter_enum(self) -> impl DoubleEndedIterator<Item = (i32, T)>

pub fn extend_with<F>(&mut self, max: i32, f: F)

where F: FnMut(i32) -> T,

Extends the bivec such that max_degree() is at least max. If max_degree() is already at least max, the function does nothing. Otherwise, it fills the new entries with the return value of F(i), where i is the index of the new entry.

pub fn reserve(&mut self, num: usize)

pub fn split_borrow_mut(&mut self, i: i32, j: i32) -> (&mut T, &mut T)

Mutably borrows i and j. Panic if i != j.

Example

let mut v = BiVec::from_vec(1, vec![3, 5, 2]);
let (x, y) = v.split_borrow_mut(1, 3);
assert_eq!(*x, 3);
assert_eq!(*y, 2);

let (x, y) = v.split_borrow_mut(3, 2);
assert_eq!(*x, 2);
assert_eq!(*y, 5);

pub fn range(&self) -> Range<i32>

Trait Implementations

impl<T: Clone> Clone for BiVec<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for BiVec<T>

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

Formats the value using the given formatter.

impl<T> Default for BiVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for BiVec<T>

fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A> Extend<A> for BiVec<A>

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = A>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> Index<i32> for BiVec<T>

type Output = T

The returned type after indexing.

fn index(&self, i: i32) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<i32> for BiVec<T>

fn index_mut(&mut self, i: i32) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<'a, T> IntoIterator for &'a BiVec<T>

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut BiVec<T>

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

type Item = &'a mut T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for BiVec<T>

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

type Item = T

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for BiVec<T>

fn eq(&self, other: &BiVec<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> Serialize for BiVec<T>

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 BiVec<T>

impl<T> StructuralPartialEq for BiVec<T>