Struct CompressedBinaryIndexedTree 

pub struct CompressedBinaryIndexedTree<M, X, Inner>
where
    M: Monoid,
{
    compress: Vec<X>,
    bits: Vec<Inner>,
    _marker: PhantomData<fn() -> M>,
}

Fields

compress: Vec<X>

bits: Vec<Inner>

_marker: PhantomData<fn() -> M>

Implementations

impl<M, A> CompressedBinaryIndexedTree<M, A, Tag<M>>

where M: Monoid, A: Clone + Ord,

pub fn new(points: &[(A,)]) -> Self

fn from_iter<'a, Iter>(points: Iter) -> Self

where A: 'a, Iter: IntoIterator<Item = &'a (A,)> + Clone,

pub fn accumulate<QA>(&self, range: &(QA,)) -> M::T

where QA: RangeBounds<A>,

pub fn update(&mut self, key: &(A,), x: &M::T)

pub fn partition_point_acc<P>(&self, pred: P) -> (Option<&A>, M::T)

where P: FnMut(&M::T) -> bool,

impl<M, A, B> CompressedBinaryIndexedTree<M, A, CompressedBinaryIndexedTree<M, B, Tag<M>>>

where M: Monoid, A: Clone + Ord, B: Clone + Ord,

pub fn new(points: &[(A, (B,))]) -> Self

fn from_iter<'a, Iter>(points: Iter) -> Self

where A: 'a, B: 'a, Iter: IntoIterator<Item = &'a (A, (B,))> + Clone,

pub fn accumulate<QA, QB>(&self, range: &(QA, (QB,))) -> M::T

where QA: RangeBounds<A>, QB: RangeBounds<B>,

pub fn update(&mut self, key: &(A, (B,)), x: &M::T)

pub fn partition_point_acc<P, QB>( &self, inner_ranges: &(QB,), pred: P, ) -> (Option<&A>, M::T)

where P: FnMut(&M::T) -> bool, QB: RangeBounds<B>,

impl<M, A, B, C> CompressedBinaryIndexedTree<M, A, CompressedBinaryIndexedTree<M, B, CompressedBinaryIndexedTree<M, C, Tag<M>>>>

where M: Monoid, A: Clone + Ord, B: Clone + Ord, C: Clone + Ord,

pub fn new(points: &[(A, (B, (C,)))]) -> Self

fn from_iter<'a, Iter>(points: Iter) -> Self

where A: 'a, B: 'a, C: 'a, Iter: IntoIterator<Item = &'a (A, (B, (C,)))> + Clone,

pub fn accumulate<QA, QB, QC>(&self, range: &(QA, (QB, (QC,)))) -> M::T

where QA: RangeBounds<A>, QB: RangeBounds<B>, QC: RangeBounds<C>,

pub fn update(&mut self, key: &(A, (B, (C,))), x: &M::T)

pub fn partition_point_acc<P, QB, QC>( &self, inner_ranges: &(QB, (QC,)), pred: P, ) -> (Option<&A>, M::T)

where P: FnMut(&M::T) -> bool, QB: RangeBounds<B>, QC: RangeBounds<C>,

impl<M, A, B, C, D> CompressedBinaryIndexedTree<M, A, CompressedBinaryIndexedTree<M, B, CompressedBinaryIndexedTree<M, C, CompressedBinaryIndexedTree<M, D, Tag<M>>>>>

where M: Monoid, A: Clone + Ord, B: Clone + Ord, C: Clone + Ord, D: Clone + Ord,

pub fn new(points: &[(A, (B, (C, (D,))))]) -> Self

fn from_iter<'a, Iter>(points: Iter) -> Self

where A: 'a, B: 'a, C: 'a, D: 'a, Iter: IntoIterator<Item = &'a (A, (B, (C, (D,))))> + Clone,

pub fn accumulate<QA, QB, QC, QD>( &self, range: &(QA, (QB, (QC, (QD,)))), ) -> M::T

where QA: RangeBounds<A>, QB: RangeBounds<B>, QC: RangeBounds<C>, QD: RangeBounds<D>,

pub fn update(&mut self, key: &(A, (B, (C, (D,)))), x: &M::T)

pub fn partition_point_acc<P, QB, QC, QD>( &self, inner_ranges: &(QB, (QC, (QD,))), pred: P, ) -> (Option<&A>, M::T)

where P: FnMut(&M::T) -> bool, QB: RangeBounds<B>, QC: RangeBounds<C>, QD: RangeBounds<D>,

Trait Implementations

impl<M, X, Inner> Clone for CompressedBinaryIndexedTree<M, X, Inner>

where M: Monoid, X: Clone, Inner: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M, X, Inner> Debug for CompressedBinaryIndexedTree<M, X, Inner>

where M: Monoid, X: Debug, Inner: Debug,

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

Formats the value using the given formatter.

impl<M, X, Inner> Default for CompressedBinaryIndexedTree<M, X, Inner>

where M: Monoid,

fn default() -> Self

Returns the “default value” for a type.