cspsolver/
lib.rs

1//! # CSP Solver
2//!
3//! A constraint satisfaction problem (CSP) solver library.
4//!
5//! ## Variable Types
6//!
7//! - **Integer variables**: `m.int(min, max)` - continuous range
8//! - **Float variables**: `m.float(min, max)` - continuous range with precision control
9//! - **Custom domains**: `m.ints(vec![values])` - specific integer values only
10//! - **Boolean variables**: `m.bool()` - equivalent to `m.int(0, 1)`
11//!
12//! ## Constraint Types
13//!
14//! - **Arithmetic**: `+`, `-`, `*`, `/`, `%`, `abs()`, `min()`, `max()`, `sum()`
15//! - **Comparison**: `==`, `!=`, `<`, `<=`, `>`, `>=`
16//! - **Boolean logic**: `and()`, `or()`, `not()`
17//! - **Global constraints**: `alldiff()`
18//!
19//! 
20//! ## post() - Post a mathematical constraint to the model
21//!
22//! Supported constraint patterns:
23//!
24//! **Basic comparisons**: `var op var`, `var op literal`, `var op (expr)`, `var op int(value)`, `var op float(value)`
25//!
26//! **Arithmetic**: `var op var +/- var`, `var op var */÷ var`, `var op var % divisor`
27//! 
28//! **Functions**: `func(var) op target` where `func` is `abs`, `min`, `max`, `sum`
29//! 
30//! **Boolean**: `and(vars...)`, `or(vars...)`, `not(var)`
31//! 
32//! **Global**: `alldiff([vars...])`
33//! 
34//! **Multiplication with constants**: `target op var * int(value)`, `target op var * float(value)`
35//! 
36//! Where `op` is any of: `==`, `!=`, `<`, `<=`, `>`, `>=`
37//! 
38//! 
39//! 
40//! ## postall() - Post multiple constraints to the model in a single call
41//!
42//! Accepts comma-separated constraint expressions, each following the same patterns as `post!`:
43//! 
44//! **Basic comparisons**: `var op var`, `var op literal`, `var op (expr)`, `var op int(value)`, `var op float(value)`
45//! 
46//! **Arithmetic**: `var op var +/- var`, `var op var */÷ var`, `var op var % divisor`
47//! 
48//! **Functions**: `func(var) op target` where `func` is `abs`, `min`, `max`, `sum`
49//! 
50//! **Boolean**: `and(vars...)`, `or(vars...)`, `not(var)`
51//! 
52//! **Global**: `alldiff([vars...])`
53//! 
54//! **Multiplication with constants**: `target op var * int(value)`, `target op var * float(value)`
55//! 
56//! Where `op` is any of: `==`, `!=`, `<`, `<=`, `>`, `>=`
57//! 
58//! 
59//!
60//! ## Example 1: Basic Integer Problem
61//!
62//! ```rust
63//! use cspsolver::prelude::*;
64//!
65//! let mut m = Model::default();
66//! let x = m.int(1, 10);
67//! let y = m.int(1, 10);
68//!
69//! post!(m, x + y == int(12));
70//! post!(m, x > y);
71//!
72//! if let Ok(solution) = m.solve() {
73//!     println!("x = {:?}, y = {:?}", solution[x], solution[y]);
74//! }
75//! ```
76//!
77//! ## Example 2: Mixed Integer-Float Optimization
78//!
79//! ```rust
80//! use cspsolver::prelude::*;
81//!
82//! let mut m = Model::default();
83//! let items = m.int(1, 100);        // Number of items
84//! let cost = m.float(0.0, 1000.0);  // Total cost
85//!
86//! post!(m, cost == items * float(12.5));  // $12.50 per item
87//! post!(m, cost <= float(500.0));         // Budget constraint
88//!
89//! // Maximize number of items within budget
90//! if let Ok(solution) = m.maximize(items) {
91//!     println!("Optimal: {:?} items, cost: {:?}", 
92//!              solution[items], solution[cost]);
93//! }
94//! ```
95//!
96//! ## Example 3: Custom Domains and Global Constraints
97//!
98//! ```rust
99//! use cspsolver::prelude::*;
100//!
101//! let mut m = Model::default();
102//! 
103//! // Variables with custom domains
104//! let red = m.ints(vec![1, 3, 5, 7]);      // Odd numbers
105//! let blue = m.ints(vec![2, 4, 6, 8]);     // Even numbers  
106//! let green = m.ints(vec![2, 3, 5, 7]);    // Prime numbers
107//!
108//! // All must be different
109//! post!(m, alldiff([red, blue, green]));
110//!
111//! if let Ok(solution) = m.solve() {
112//!     println!("Red: {:?}, Blue: {:?}, Green: {:?}",
113//!              solution[red], solution[blue], solution[green]);
114//! }
115//! ```
116
117
118pub mod model;
119pub mod vars;
120pub mod solution;
121pub mod config;
122pub mod error;
123pub mod validation;
124#[doc(hidden)]
125pub mod operators;
126
127#[doc(hidden)]
128pub mod utils;
129#[doc(hidden)]
130pub mod utils64;
131
132
133#[doc(hidden)]
134pub mod views;
135
136#[doc(hidden)]
137pub mod props;
138#[doc(hidden)]
139pub mod search;
140#[doc(hidden)]
141pub mod gac;
142#[doc(hidden)]
143pub mod domain;
144#[doc(hidden)]
145pub mod optimization;
146pub mod prelude;
147
148#[doc(hidden)]
149// Clean constraint API modules
150pub mod constraint_builder;
151pub mod boolean_operators;
152#[doc(hidden)]
153pub mod math_syntax;
154
155#[doc(hidden)]
156pub mod constraint_macros;
157
158
159#[cfg(test)]
160mod tests;
161#[cfg(test)]
162mod debug;
163
164// Benchmarks module for performance validation
165#[doc(hidden)]
166pub mod benchmarks;
167
168
169