Struct ReversibleColoring

pub struct ReversibleColoring<S: Set + ?Sized> { /* private fields */ }

A reversible ordered coloring.

Implementations

impl<S: Set + ?Sized> ReversibleColoring<S>

pub fn new(set: &S) -> Self

Creates a new reversible coloring.

pub fn from_coloring(set: &S, coloring: Coloring<S>) -> Self

pub fn color_index_of(&self, item: &S::Item) -> Option<usize>

pub fn as_permutation(&self) -> Option<&S::Map<usize>>

Returns the permutation represented by this coloring, if any.

If the coloring discrete then it defines a mapping p : x -> self.reverse(x) that is a permutation of the partitioned set. In that case, Some(p) is returned. Otherwise, if the coloring is not discrete, None is returned.

pub fn individualize(&mut self, item: &S::Item) -> bool

Refine the coloring such that item is in its own cell of size 1.

Returns true if the individualization succeeded, or false if item was already individualized.

pub fn deindividualize(&mut self, item: &S::Item) -> bool

pub fn is_finer_or_equal_to(&self, other: &Self) -> bool

Checks if self is a finer than or equal to other, assuming they target the same set.

pub fn refine<F, C: Ord>(&mut self, f: F) -> bool

where F: Fn(&S::Item) -> C,

pub fn refine_with<F, C: Ord>( &mut self, refined_colors: &mut Vec<usize>, f: F, ) -> bool

where F: Fn(&S::Item) -> C,

Refine this coloring using the given sub-coloring.

The refined_colors array will be expended to include the newly added colors indexes. Colors that have not been refined are not added to the array, even if their index changes. If the array already contains old color indexes, they will be updated in place to the new color index.

pub fn make_equitable<'i, F, I>(&mut self, set: &S, neighbors: F)

where F: Fn(&S::Item) -> I, I: IntoIterator<Item = &'i S::Item>, S::Item: 'i,

pub fn make_equitable_with<'i, F, I>( &mut self, stack: &mut Vec<usize>, map: &mut S::Map<usize>, neighbors: F, )

where F: Fn(&S::Item) -> I, I: IntoIterator<Item = &'i S::Item>, S::Item: 'i,

Make this coloring equitable.

The stack is empty when this function returns. The map must be initialized so that each element is mapped (the value does not matter).

Methods from Deref<Target = Coloring<S>>

pub fn color_index_of(&self, item: &S::Item) -> Option<usize>

pub fn colors(&self) -> Colors<'_, S>

pub fn len(&self) -> usize

Returns the number of colors in the coloring.

pub fn is_empty(&self) -> bool

pub fn is_unit(&self) -> bool

Checks if the coloring is a unit coloring.

pub fn is_discrete(&self) -> bool

pub fn color_start(&self, i: usize) -> Option<usize>

pub fn get(&self, i: usize) -> Option<&[S::Item]>

Returns the ith cell of the coloring, partitioning the given input set.

Trait Implementations

impl<S: Set + ?Sized> Clone for ReversibleColoring<S>

where S::Map<usize>: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Set + ?Sized> Debug for ReversibleColoring<S>

where S::Item: Debug,

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

Formats the value using the given formatter.

impl<S: Set + ?Sized> Deref for ReversibleColoring<S>

type Target = Coloring<S>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S: Set + ?Sized> PartialEq for ReversibleColoring<S>

fn eq(&self, other: &Self) -> bool

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

const 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<S: Set + ?Sized> Eq for ReversibleColoring<S>