Enum Domain 

pub enum Domain {
    FiniteDomain {
        values: HashSet<i64>,
    },
    Interval {
        lower: f64,
        upper: f64,
    },
    Boolean,
    Enumeration {
        values: HashSet<String>,
    },
}

A constraint domain specifies the set of possible values for variables.

Variants

FiniteDomain

Finite domain: discrete set of integers

Fields

values: HashSet<i64>

Interval

Interval domain: continuous range [lower, upper]

Fields

lower: f64

upper: f64

Boolean

Boolean domain: {true, false}

Enumeration

Enumeration: finite set of symbolic values

Fields

values: HashSet<String>

Implementations

impl Domain

pub fn finite_domain(values: Vec<i64>) -> Self

Create a finite domain from a vector of integers.

pub fn range(range: RangeInclusive<i64>) -> Self

Create a finite domain from a range.

pub fn interval(lower: f64, upper: f64) -> Self

Create an interval domain.

pub fn boolean() -> Self

Create a boolean domain.

pub fn enumeration(values: Vec<String>) -> Self

Create an enumeration domain.

pub fn is_empty(&self) -> bool

Check if the domain is empty.

pub fn size(&self) -> Option<usize>

Get the size of the domain (number of possible values).

pub fn contains_int(&self, value: i64) -> bool

Check if a value is in the domain.

pub fn intersect(&self, other: &Domain) -> Result<Domain, IrError>

Intersect two domains.

pub fn remove_value(&mut self, value: i64) -> bool

Remove a value from the domain.

Trait Implementations

impl Clone for Domain

fn clone(&self) -> Domain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Domain

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Domain

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Domain

fn eq(&self, other: &Domain) -> 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 Serialize for Domain

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Domain