Struct sets::RankedSet

pub struct RankedSet<T> {
    pub ascending: bool,
    pub v: Vec<T>,
    pub i: Vec<usize>,
}

Struct holding an unordered set and a vector of its ranks (ascending or descending).

Fields

ascending: bool

v: Vec<T>

i: Vec<usize>

Implementations

impl<T> RankedSet<T>

pub fn from_slice(s: &[T], asc: bool) -> Self where
    T: PartialOrd + Copy, 

Initialiser, ranks an unordered slice

pub fn from_set(s: &Set<T>, asc: bool) -> Self where
    T: PartialOrd + Copy, 

Initialiser, ranks an unordered Set

pub fn from_ordered(s: &OrderedSet<T>, asc: bool) -> Self where
    T: PartialOrd + Copy, 

From Ordered - the index will be trivial

pub fn from_indexed(s: &IndexedSet<T>, asc: bool) -> Self where
    T: PartialOrd + Copy, 

Converts sort index to ranks

Trait Implementations

impl<'a, T: Display> Display for RankedSet<T> where
    T: Copy, 

Display implemented for struct RankedSet.

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

Formats the value using the given formatter.

impl<T> MutSetOps<T> for RankedSet<T> where
    T: Copy + PartialOrd, 

The primitive functions from indxvec all expect indexed sets, so for now we convert from ranks to sort indices using .invindex(). Even though that is a simple operation, for lots of set operations, it will be slightly quicker to work in IndexedSet(s) and only to rank the final result.

fn mreverse(&mut self)

just make the ranks descending

fn mnonrepeat(&mut self)

deletes repetitions.

fn munion(&mut self, s: &Self)

Union of two RankedSets. Converts ranks to sort indices with invindex, merges, then converts back to ranks Data self.v is simply concatenated

fn mintersection(&mut self, s: &Self)

Intersection of two RankedSets

fn mdifference(&mut self, s: &Self)

Complement of s in self (i.e. self-s)

impl<T> SetOps<T> for RankedSet<T> where
    T: Copy + PartialOrd, 

For lots of set operations, it is probably better to work in IndexedSet(s) and then only to rank the final result.

fn reverse(&self) -> Self

switches between ascending and descending ranks, which is what is logically expected here but it is not the same as a literal reversal of the ranks!

fn nonrepeat(&self) -> OrderedSet<T>

Deletes repetitions.

fn infsup(&self) -> MinMax<T>

Finds minimum, minimum’s first index, maximum, maximum’s first index

fn member(&self, m: T) -> bool

True if m is a member of the set

fn search(&self, m: T) -> Option<usize>

Search a Set for m. Returns index of the first m.

fn union(&self, s: &Self) -> RankedSet<T>

Union of two RankedSets. Returns new RankedSet

fn intersection(&self, s: &Self) -> OrderedSet<T>

Intersection of two RankedSets. Via OrderedSet for convenience, for now. Todo: Probably should use intersect_indexed as in union above.

fn difference(&self, s: &Self) -> OrderedSet<T>

Complement of s in self (i.e. self-s)