Struct DiscreteConstraint

pub struct DiscreteConstraint<V, T: Hash + Eq> { /* private fields */ }

A generic form of Constraints on discrete variables.

Note

This is not the most efficient implementation,
as it effectively tries to store all possible assignments.

Whilst this lets it be as flexible as possible, it:

1. uses a lot more space
2. has much worse time complexity

Than specialised implementations of constraints.
If you want a more performant implementation, check out others in crate::systems.

Trait Implementations

impl<V: Hash + Eq + Clone, T: Hash + Eq + Clone> Constraint for DiscreteConstraint<V, T>

type Var = V

The type of variables assigned by the Constraint

type Solution = DiscreteAssignment<V, T>

Any solution to a Constraint

type ConflictErr = ()

The error raised when 2 constraints conflict with each other

fn size(&self) -> usize

An approximation to the number of unique assignments that self has.

fn variables(&self) -> impl Iterator<Item = Self::Var>

All variables that self affects

fn decompositions(&self) -> impl Iterator<Item = Self>

Possible decompositions for this constraint.

fn reduce(&mut self, other: &Self) -> Result<bool, Self::ConflictErr>

Removes the overlap between another constraint and this one.
This is useful as it lets us remove uncertainty from the system
and make it simpler to solve.

fn pop_solution(&mut self) -> Option<Self::Solution>

Pops all variables that have a unique assignment in this constraint

impl<V: Debug, T: Debug + Hash + Eq> Debug for DiscreteConstraint<V, T>

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

Formats the value using the given formatter.

impl<V, T: Hash + Eq> Default for DiscreteConstraint<V, T>

fn default() -> Self

Returns the “default value” for a type.

impl<V: Hash + Eq + Debug, T: Hash + Eq, I: IntoIterator<Item = (V, T)>> FromIterator<I> for DiscreteConstraint<V, T>

fn from_iter<U: IntoIterator<Item = I>>(iter: U) -> Self

Creates a value from an iterator.

impl<V: Hash, T: Hash + Hash + Eq> Hash for DiscreteConstraint<V, T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<V: PartialEq, T: PartialEq + Hash + Eq> PartialEq for DiscreteConstraint<V, T>

fn eq(&self, other: &DiscreteConstraint<V, 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<V: Eq, T: Eq + Hash + Eq> Eq for DiscreteConstraint<V, T>

impl<V, T: Hash + Eq> StructuralPartialEq for DiscreteConstraint<V, T>