Struct Constraint 

pub struct Constraint<S: Stage<Self> = Created> {
    pub equality: Equality,
    pub stage: S::Data,
}

A constraint parameterized by its lifecycle stage.

Holds only the constraint’s intrinsic data (equality plus stage-specific data in stage). Modeling labels and transformation provenance live on the enclosing collection’s ConstraintContextStore keyed by id; per-element storage was retired in the v3 context redesign.

The constraint’s ConstraintID is not stored in this struct — it is held by the enclosing collection (e.g. the BTreeMap key in Instance), which is the single source of truth. Standalone constraints are identity-less until inserted into a collection.

Fields

equality: Equality

stage: S::Data

Implementations

impl Constraint<Created>

pub fn reduce_binary_power( &mut self, binary_ids: &VariableIDSet, ) -> Result<bool, CoefficientError>

Reduce binary powers in the constraint function.

For binary variables, x^n = x for any n >= 1, so we can reduce higher powers to linear terms.

Returns true if any reduction was performed, false otherwise.

impl Constraint<Created>

pub fn function(&self) -> &Function

Access the constraint function.

pub fn function_mut(&mut self) -> &mut Function

Mutable access to the constraint function.

pub fn equal_to_zero(function: Function) -> Self

pub fn less_than_or_equal_to_zero(function: Function) -> Self

impl Constraint<Evaluated>

pub fn is_feasible_with_tolerance(&self, atol: ATol) -> bool

Check if this constraint is feasible given a specific tolerance

pub fn violation(&self) -> f64

Calculate the violation (constraint breach) value for this constraint

Returns the amount by which this constraint is violated:

• For f(x) = 0: returns |f(x)|
• For f(x) ≤ 0: returns max(0, f(x))

Returns 0.0 if the constraint is satisfied.

impl Constraint<Sampled>

pub fn is_feasible(&self, sample_id: SampleID, atol: ATol) -> Option<bool>

Check feasibility for a specific sample.

Returns None if sample_id is not present in the sampled data.

pub fn feasible_ids(&self, atol: ATol) -> FnvHashSet<SampleID>

Get all sample IDs that are feasible

pub fn infeasible_ids(&self, atol: ATol) -> FnvHashSet<SampleID>

Get all sample IDs that are infeasible

Trait Implementations

impl AbsDiffEq for Constraint<Created>

type Epsilon = ATol

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl Arbitrary for Constraint<Created>

type Parameters = PolynomialParameters

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<Constraint>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(params: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl<S: Clone + Stage<Self>> Clone for Constraint<S>

where S::Data: Clone,

fn clone(&self) -> Constraint<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConstraintType for Constraint

Constraint (= Constraint<Created>) serves as the type family for regular constraints.

type ID = ConstraintID

The ID type for this constraint family.

type Created = Constraint

The constraint as defined in the problem.

type Evaluated = Constraint<Evaluated>

The constraint after evaluation against a single state.

type Sampled = Constraint<Sampled>

The constraint after evaluation against multiple samples.

impl<S: Debug + Stage<Self>> Debug for Constraint<S>

where S::Data: Debug,

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

Formats the value using the given formatter.

impl Display for Constraint<Created>

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

Formats the value using the given formatter.

impl Evaluate for Constraint<Created>

type Output = Constraint<Evaluated>

type SampledOutput = Constraint<Sampled>

fn evaluate(&self, solution: &State, atol: ATol) -> Result<Self::Output>

Evaluate to return the output with used variable ids

fn evaluate_samples( &self, samples: &Sampled<State>, atol: ATol, ) -> Result<Self::SampledOutput>

Evaluate for each sample

fn partial_evaluate(&mut self, state: &State, atol: ATol) -> Result<()>

Partially evaluate the function to return the used variable ids

fn required_ids(&self) -> VariableIDSet

Decision variable IDs required for evaluation

impl From<Constraint<Evaluated>> for EvaluatedRegularConstraint

fn from(constraint: EvaluatedConstraint) -> Self

Converts to this type from the input type.

impl From<Constraint<Sampled>> for SampledRegularConstraint

fn from(constraint: SampledConstraint) -> Self

Converts to this type from the input type.

impl From<Constraint> for RegularConstraint

fn from(constraint: Constraint<Created>) -> Self

Converts to this type from the input type.

impl<S: PartialEq + Stage<Self>> PartialEq for Constraint<S>

where S::Data: PartialEq,

fn eq(&self, other: &Constraint<S>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Stage<Constraint<Evaluated>> for Evaluated

type Data = EvaluatedData

impl Stage<Constraint<Sampled>> for Sampled

type Data = SampledData

impl Stage<Constraint> for Created

type Data = CreatedData

impl<S: PartialEq + Stage<Self>> StructuralPartialEq for Constraint<S>

where S::Data: PartialEq,