Struct strata::OneOf

pub struct OneOf<A, B> where
    A: Algebra,
    B: Algebra,  { /* fields omitted */ }

Finds extents that an extent from either list would be a subextent of.

Errors in the paper

Using the implementation in the paper, OneOf::tau and OneOf::rho do not produce the same list. As an example:

         k
|--*==*--|--|
*==|==|==|==*
1  2  3  4  5

tau would be correct for k=[0,5], but rho fails at k=[4,5], producing (1,5).

To work around this, we work backward using tau_prime and then forward again with tau, until we find a valid extent.

Methods

impl<A, B> OneOf<A, B> where
    A: Algebra,
    B: Algebra, 

pub fn new(a: A, b: B) -> Self

Trait Implementations

impl<A, B> Algebra for OneOf<A, B> where
    A: Algebra,
    B: Algebra, 

fn tau(&self, k: Position) -> Extent

The first extent starting at or after the position k.

fn tau_prime(&self, k: Position) -> Extent

The last extent ending at or before the position k.

fn rho(&self, k: Position) -> Extent

The first extent ending at or after the position k.

fn rho_prime(&self, k: Position) -> Extent

The last extent starting at or before the position k.

Important traits for IterTau<T>

impl<T> Iterator for IterTau<T> where
    T: Algebra,  type Item = ValidExtent;

fn iter_tau(self) -> IterTau<Self> where
    Self: Sized, 

Find all extents in a forward direction using the tau primitive

Important traits for IterRho<T>

impl<T> Iterator for IterRho<T> where
    T: Algebra,  type Item = ValidExtent;

fn iter_rho(self) -> IterRho<Self> where
    Self: Sized, 

Find all extents in a forward direction using the rho primitive

Important traits for IterTauPrime<T>

impl<T> Iterator for IterTauPrime<T> where
    T: Algebra,  type Item = ValidExtent;

fn iter_tau_prime(self) -> IterTauPrime<Self> where
    Self: Sized, 

Find all extents in a backward direction using the tau-prime primitive

Important traits for IterRhoPrime<T>

impl<T> Iterator for IterRhoPrime<T> where
    T: Algebra,  type Item = ValidExtent;

fn iter_rho_prime(self) -> IterRhoPrime<Self> where
    Self: Sized, 

Find all extents in a backward direction using the rho-prime primitive

impl<A: Clone, B: Clone> Clone for OneOf<A, B> where
    A: Algebra,
    B: Algebra, 

fn clone(&self) -> OneOf<A, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Copy, B: Copy> Copy for OneOf<A, B> where
    A: Algebra,
    B: Algebra, 

impl<A: Debug, B: Debug> Debug for OneOf<A, B> where
    A: Algebra,
    B: Algebra, 

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

Formats the value using the given formatter.