Struct Csp 

pub struct Csp<D: Domain> {
    pub variables: Vec<Variable<D>>,
    /* private fields */
}

The main CSP solver struct.

Generic over the domain type D. Build a problem by adding variables and constraints, call finalize() to build the adjacency graph, then solve().

Fields

variables: Vec<Variable<D>>

Implementations

impl<D: Domain> Csp<D>

pub fn new() -> Self

Create a new empty CSP.

pub fn add_variable(&mut self, domain: D) -> VarId

Add a variable with the given domain. Returns its VarId.

pub fn add_variables(&mut self, domain: &D, count: usize) -> Vec<VarId>

Add multiple variables sharing the same domain. Returns their VarIds.

pub fn add_constraint(&mut self, c: impl Constraint<D> + 'static)

Add a custom constraint (wrapped in the Custom enum variant).

pub fn add_constraint_enum(&mut self, c: ConstraintEnum<D>)

Add a pre-typed constraint enum directly (avoids boxing for built-in types).

pub fn add_soft_constraint(&mut self, c: SoftLambdaConstraint<D>)

Add a soft constraint (contributes penalty cost when violated, never prunes).

pub fn add_not_equal(&mut self, x: VarId, y: VarId)

Add a not-equal constraint (devirtualized fast path).

pub fn add_all_different(&mut self, vars: Vec<VarId>)

Add an all-different constraint (devirtualized fast path).

pub fn add_equals(&mut self, var: VarId, value: D::Value)

where D: 'static,

Fix a variable to a specific value.

pub fn add_less_than(&mut self, x: VarId, y: VarId)

where D: 'static, D::Value: PartialOrd,

Constrain x < y (for Ord-comparable values).

pub fn add_greater_than(&mut self, x: VarId, y: VarId)

where D: 'static, D::Value: PartialOrd,

Constrain x > y (for Ord-comparable values).

pub fn finalize(&mut self)

where D::Value: PartialEq,

Build the adjacency graph. Must be called after all variables and constraints have been added, before calling solve().

pub fn propagate(&mut self) -> Result<(), Unsatisfiable>

where D::Value: PartialEq,

Propagate constraints to a fixed point (auto-select strategy).

pub fn propagate_with( &mut self, strategy: PropagationStrategy, ) -> Result<(), Unsatisfiable>

where D::Value: PartialEq,

Propagate constraints with an explicit strategy.

pub fn solve(&mut self, config: &SolveConfig) -> Vec<Solution<D>>

where D::Value: PartialEq,

Run backtracking (or backjumping) search with the given configuration.

Returns up to config.max_solutions solutions. When optimization_mode is MinimizeCost or MaximizeCost, uses branch-and-bound search and returns solutions sorted by cost (best first).

pub fn solve_with_given( &mut self, config: &SolveConfig, given: &[(VarId, D::Value)], ) -> Vec<Solution<D>>

where D::Value: PartialEq,

Solve with initial propagation for pre-assigned (“given”) values.

Analogous to Python’s solve_with_initial_propagation. Pre-assigns the given values, propagates constraints, then searches.

pub fn solve_with_cost_eval( &mut self, config: &SolveConfig, cost_eval: &dyn DomainCostEval<D>, ) -> Vec<Solution<D>>

where D::Value: PartialEq,

Run optimization search with a custom cost evaluator.

This is the most flexible entry point: you supply a DomainCostEval that defines how domain values are costed. Use solve() with OptimizationMode::MinimizeCost if you only need soft constraint penalties (zero domain cost), or solve_optimized() if your domain implements CostDomain.

pub fn stats(&self) -> &SolveStats

Get solver statistics from the last run.

pub fn adjacency(&self) -> Option<&Adjacency>

Get a reference to the adjacency graph (available after finalize()).

impl<D: CostDomain> Csp<D>

pub fn solve_optimized(&mut self, config: &SolveConfig) -> Vec<Solution<D>>

where D::Value: PartialEq,

Run optimization search using the domain’s CostDomain implementation for value costing. This is the ergonomic entry point when your domain type implements CostDomain.

Trait Implementations

impl<D: Domain> Default for Csp<D>

fn default() -> Self

Returns the “default value” for a type.