use super::Problem;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Status {
Satisfiable,
Unsatisfiable,
Unknown,
}
#[derive(Clone, Debug)]
pub struct Solution {
status: Status,
assignment: Option<Vec<isize>>,
runtime: f64,
compilation_runtime: f64,
iterations: Option<usize>,
}
impl Solution {
pub fn satisfiable(problem: &Problem, assignment: Vec<isize>) -> Self {
if problem.number_variables() != assignment.len() {
panic!(
"A solution is being constructed with {} values for a problem with {} variables",
assignment.len(),
problem.number_variables()
);
}
if !problem.is_solution(&assignment) {
panic!("A solution is being constructed, but some constraints are not satisfied");
}
Self::new(Status::Satisfiable, Some(assignment))
}
pub fn unsatisfiable() -> Self {
Self::new(Status::Unsatisfiable, None)
}
pub fn unknown() -> Self {
Self::new(Status::Unknown, None)
}
fn new(status: Status, assignment: Option<Vec<isize>>) -> Self {
Self {
status,
assignment,
runtime: 0.0,
compilation_runtime: 0.0,
iterations: None,
}
}
pub fn with_runtime(mut self, runtime: f64, compilation_runtime: f64) -> Self {
self.runtime = runtime;
self.compilation_runtime = compilation_runtime;
self
}
pub fn with_iterations(mut self, iterations: usize) -> Self {
self.iterations = Some(iterations);
self
}
pub fn status(&self) -> Status {
self.status
}
pub fn assignment(&self) -> Option<&[isize]> {
self.assignment.as_deref()
}
pub fn runtime(&self) -> f64 {
self.runtime
}
pub fn compilation_runtime(&self) -> f64 {
self.compilation_runtime
}
pub fn iterations(&self) -> Option<usize> {
self.iterations
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::constraints::not_equals;
fn differ() -> Problem {
let mut problem = Problem::default();
let x = problem.add_variable(vec![0, 1]);
let y = problem.add_variable(vec![0, 1]);
not_equals(&mut problem, x, y);
problem
}
#[test]
fn a_satisfiable_solution_holds_the_assignment_and_neutral_costs() {
let solution = Solution::satisfiable(&differ(), vec![0, 1]);
assert_eq!(solution.status(), Status::Satisfiable);
assert_eq!(solution.assignment(), Some(&[0, 1][..]));
assert_eq!(solution.runtime(), 0.0);
assert_eq!(solution.compilation_runtime(), 0.0);
assert_eq!(solution.iterations(), None);
}
#[test]
fn costs_are_recorded() {
let solution = Solution::unknown()
.with_runtime(2.5, 1.0)
.with_iterations(7);
assert_eq!(solution.status(), Status::Unknown);
assert_eq!(solution.assignment(), None);
assert_eq!(solution.runtime(), 2.5);
assert_eq!(solution.compilation_runtime(), 1.0);
assert_eq!(solution.iterations(), Some(7));
}
#[test]
fn an_unsatisfiable_solution_has_no_assignment() {
let solution = Solution::unsatisfiable();
assert_eq!(solution.status(), Status::Unsatisfiable);
assert_eq!(solution.assignment(), None);
}
#[test]
#[should_panic]
fn a_partial_assignment_is_not_a_solution() {
Solution::satisfiable(&differ(), vec![0]);
}
#[test]
#[should_panic]
fn an_assignment_that_violates_a_constraint_is_not_a_solution() {
Solution::satisfiable(&differ(), vec![1, 1]);
}
}