This project aims at implementing a fast, and clean constraint programming solver with a focus on correctness, simplicity, maintainability and performance. It is largely inspired by both minicp (https://www.minicp.org) and maxicp (https://github.com/pschaus/maxicp/).
NOTE: This is pretty much a pet project and a work in progress. We'll see where this leads.
- State
- Implement a trailing mechanism
- Implement reversible sparse set
- Implement reversible interval
- Engine
- Implement bool var
- Implement int variables
- Define constraint and propagator traits
- Implement the solver with propagation fixpoint
- Test the solver propagation
- Implement views
- Implement the basic constraints
- Abs value :: x == |y|
- not equal const :: x != v
- not equal :: x != y
- is not equal :: b <==> (x != v)
- is not equal (var) :: b <==> (x != y)
- equal :: x == y
- is equal :: b <==> x == v
- is equal (var) :: b <==> x == y
- LE :: x <= v
- LE :: x <= y
- GE :: x >= v
- GE :: x >= y
- is LE :: b <==> x <= v
- is LE (var) :: b <==> x <= y
- is GE :: b <==> (x >= v)
- is GE (var) :: b <==> (x >= y)
- must be true x + must be false
- or :: (w || x || y || z || ...)
- is or (var) :: b <==> (w || x || y || z || ...)
- and :: (w && x && y && z && ...)
- is and :: b <==> (w && x && y && z && ...)
- is maximum :: y = maximum(a, b, c, d, ...)
- is minimum :: y = minimum(a, b, c, d, ...)
- sum :: sum(a, b, c, d, ...) == 0
- is sum :: y = sum(a, b, c, d, ...)
- All diff
- circuit
- cumulative
- disjunctive
- element_1d
- element_2d
- Search
- Implement search strategies
- Bindings
- For Python3 (with pyo3)
- For C++ (with cxx)
- For Java (maybe consider)
- State
- Implement reversible lazy sparse set
- Implement fast and efficient bitsets
- Implement reversible bitset
- Implement reversible tri partition
- Implement reversible stack (push only)
- Engine
- Implement sequence variables
- Implement more constraints (tables, argmin, argmax)