140 lines
4.5 KiB
Rust
140 lines
4.5 KiB
Rust
//! # Solver
|
|
//!
|
|
//! Provides `Variables`, `Domain` structs and `solve_all` function.
|
|
use std::fmt;
|
|
use std::clone::Clone;
|
|
use std::collections::HashMap;
|
|
|
|
/// An assignments map of variables
|
|
pub type Variables<'a, V> = HashMap<String, Option<&'a V>>;
|
|
|
|
enum Assignment<'a, V> {
|
|
Update(String, &'a V),
|
|
Clear(String)
|
|
}
|
|
|
|
|
|
/// The domain of values that can be assigned to variables
|
|
#[derive(Clone)]
|
|
pub struct Domain<V> {
|
|
values: Vec<V>
|
|
}
|
|
|
|
impl<V> Domain<V> {
|
|
pub fn new(values: Vec<V>) -> Domain<V> {
|
|
Domain { values }
|
|
}
|
|
}
|
|
|
|
impl<V: fmt::Debug> fmt::Debug for Domain<V> {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(f, "Domain<{:?}>", self.values)
|
|
}
|
|
}
|
|
|
|
|
|
/// Returns all possible Updates for next assignements, prepended with
|
|
/// a Clear to ensure the variable is unset before when leaving the branch.
|
|
fn assign_next<'a,'b, V>(assign: &'b Variables<'a, V>, domain: &'a Domain<V>)
|
|
-> Option<Vec<Assignment<'a, V>>>
|
|
where V: fmt::Debug
|
|
{
|
|
// Panics on empty domain
|
|
// If domain values are filtered, then the branch is a dead end
|
|
if domain.values.is_empty() { panic!("No values in domain : {:?}", domain); };
|
|
|
|
// TODO: should be able to inject a choosing strategy
|
|
if let Some((key,_)) = assign.iter().find(|(_, val)| val.is_none()) {
|
|
let mut updates = vec![Assignment::Clear(key.clone())];
|
|
// TODO: should be able to filter domain values (inference, pertinence)
|
|
for value in domain.values.iter() {
|
|
updates.push(Assignment::Update(key.clone(), value));
|
|
}
|
|
Some(updates)
|
|
} else { // End of assignements
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Visit all possible solutions, using a stack.
|
|
pub fn solve_all<'a, V>(
|
|
mut assign: Variables<'a, V>,
|
|
domain: &'a Domain<V>,
|
|
is_valid: fn(&Variables<'a,V>) -> bool
|
|
) -> Vec<Variables<'a, V>>
|
|
where V: Clone + fmt::Debug
|
|
{
|
|
let mut solutions: Vec<Variables<V>> = vec![];
|
|
let mut stack: Vec<Assignment<'a, V>> = vec![];
|
|
stack.append(&mut assign_next(&assign,domain).unwrap());
|
|
loop {
|
|
let node = stack.pop();
|
|
if node.is_none() { break; };
|
|
match node.unwrap() {
|
|
Assignment::Update(key, val) => {
|
|
// Assign the variable and open new branches, if any.
|
|
*assign.get_mut(&key).unwrap() = Some(val);
|
|
// TODO: handle case of empty domain.values
|
|
if let Some(mut nodes) = assign_next(&assign, domain) {
|
|
stack.append(&mut nodes);
|
|
} else {
|
|
// Assignements are completed
|
|
if is_valid(&assign) {
|
|
solutions.push(assign.clone());
|
|
};
|
|
};
|
|
},
|
|
Assignment::Clear(key) => {
|
|
// We are closing this branch, unset the variable
|
|
*assign.get_mut(&key).unwrap() = None;
|
|
},
|
|
};
|
|
};
|
|
solutions
|
|
}
|
|
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
#[test]
|
|
fn test_solver_find_pairs() {
|
|
use super::*;
|
|
// Find all pairs of two differents
|
|
let assign: Variables<i32> = [
|
|
("Left".to_string(), None),
|
|
("Right".to_string(), None),
|
|
].iter().cloned().collect();
|
|
let domain = Domain::new(vec![1,2,3]);
|
|
let constraint = |assign: &Variables<i32>| {
|
|
assign.get("Left").unwrap() == assign.get("Right").unwrap()
|
|
};
|
|
let solutions: Vec<Variables<i32>> = vec![
|
|
[("Left".to_string(), Some(&3)), ("Right".to_string(), Some(&3)),].iter().cloned().collect(),
|
|
[("Left".to_string(), Some(&2)), ("Right".to_string(), Some(&2)),].iter().cloned().collect(),
|
|
[("Left".to_string(), Some(&1)), ("Right".to_string(), Some(&1)),].iter().cloned().collect(),
|
|
];
|
|
|
|
assert_eq!(solve_all(assign, &domain, constraint), solutions);
|
|
}
|
|
|
|
#[test]
|
|
fn test_solver_find_pairs_with_initial() {
|
|
use super::*;
|
|
// Find all pairs of two differents
|
|
let assign: Variables<i32> = [
|
|
("Left".to_string(), None),
|
|
("Right".to_string(), Some(&2)),
|
|
].iter().cloned().collect();
|
|
let domain = Domain::new(vec![1,2,3]);
|
|
let constraint = |assign: &Variables<i32>| {
|
|
assign.get("Left").unwrap() == assign.get("Right").unwrap()
|
|
};
|
|
let solutions: Vec<Variables<i32>> = vec![
|
|
[("Left".to_string(), Some(&2)), ("Right".to_string(), Some(&2)),].iter().cloned().collect(),
|
|
];
|
|
|
|
assert_eq!(solve_all(assign, &domain, constraint), solutions);
|
|
}
|
|
}
|
|
|