artus/CookAssistant
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

adds Key generic parameters, use custom Key type from template.rs

Browse Source
This commit is contained in:
Arthur Gerbaud
2019-02-10 14:43:18 +01:00
parent 29b2f076bf
commit 2f3993bb9e
11 changed files with 241 additions and 279 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
planner/src/bin/weekly.rs
View File

@@ -1,117 +1,35 @@
//! The weekly menu planner
//!
extern crate cookbook;
extern crate planner;
extern crate cookbook;
use self::cookbook::*;
use self::cookbook::recipes::Recipe;
use self::planner::solver::{Variables, Domain, Problem};
type DomainValues<'a, V> = Vec<&'a V>;
/// We want a mapping of the week meals (matin, midi, soir)
/// Breakfast => RecipeCategory::Breakfast
/// Lunch => RecipeCategory::MainCourse
/// Dinner => RecipeCategory::MainCourse
mod template {
//! Exports the [`Template`] struct.
use super::{Domain, DomainValues, Variables, Recipe};
type Day = String;
const DAYS: &[&str] = &[
"Lundi", "Mardi", "Mercredi",
"Jeudi", "Vendredi", "Samedi",
"Dimanche"];
/// An enum to discriminate every meals
#[allow(dead_code)]
pub enum Meals {
Breakfast(Day),
Lunch(Day),
Dinner(Day)
}
impl From<Meals> for String {
fn from(item: Meals) -> String {
match item {
Meals::Breakfast(d) => format!("{}_Breakfast", d),
Meals::Lunch(d) => format!("{}_Lunch", d),
Meals::Dinner(d) => format!("{}_Dinner", d),
}
}
use std::fmt::Debug;
use std::fmt::Display;
use std::hash::Hash;
use cookbook::*;
use planner::{
*, Value,
solver::{
Variables,
Domain,
Problem
}
};
/// A fixed template of meals
///
/// TODO: mask -> disabled choosen meals
/// initials -> fixed values
pub struct Template;
impl Template {
fn keys() -> Vec<Meals> {
let mut keys = Vec::new();
for day in DAYS {
for meal in &[Meals::Breakfast, Meals::Lunch, Meals::Dinner] {
keys.push(meal(day.to_string()))
}
}
keys
}
/// Build a [`Template`] from a variables assignment map,
/// usually a solution returned by solver
pub(super) fn from_variables<'a, V>(_vars: Variables<'a,V>) -> Template{
Template
}
/// Builds a vector of variables, to be used with
/// [`ProblemBuilder`].
pub(super) fn generate_variables(domain: &Domain<Recipe>)
-> Vec<(String, DomainValues<Recipe>, Option<&Recipe>)>
{
use cookbook::recipes::RecipeCategory;
let mut vars = Vec::new();
for key in Self::keys().into_iter() {
//TODO: Use key variants to set filters on domain
//TODO: Initial values
let _filter: fn(&&Recipe) -> bool = match key {
Meals::Breakfast(_) => |r: &&Recipe| {
r.category == RecipeCategory::Breakfast // Breakfast
},
Meals::Lunch(_) => |r: &&Recipe| {
r.category as i16 == 2i16 // MainCourse
},
Meals::Dinner(_) => |r: &&Recipe| {
r.category as i16 == 1i16 // Starter
}
};
vars.push((key.into(), domain.filter(_filter), None));
}
vars
}
}
}
fn ingredients_contains<'a>(_assign: &Variables<'a,Recipe>) -> bool {
true
}
fn pretty_output(res: &Variables<Recipe>) -> String {
fn pretty_output<K: Eq + Hash + Debug>(res: &Variables<Value, K>) -> String {
let mut repr = String::new();
for (var,value) in res {
let value = match value {
Some(rec) => &rec.title,
None => "---",
};
repr.push_str(&format!("{} => {}\n", var, value));
repr.push_str(&format!("{:?} => {}\n", var, value));
}
repr
}
fn get_planning_all_results() -> String {
fn main() {
let conn = establish_connection();
let possible_values = recipes::load_all(&conn);
let domain = Domain::new(possible_values);
@@ -119,15 +37,7 @@ fn get_planning_all_results() -> String {
for (var, dom, ini) in template::Template::generate_variables(&domain) {
problem = problem.add_variable(var, dom, ini);
}
let mut problem = problem
.add_constraint(
ingredients_contains
)
.finish();
let mut problem = problem.finish();
let results = problem.solve_all();
format!("{}\nTotal = {}", pretty_output(&results.first().unwrap()), results.len())
}
fn main() {
println!("{}", get_planning_all_results());
println!("{:?}", pretty_output(results.first().unwrap()));
}

13
planner/src/lib.rs
View File

@@ -1,11 +1,10 @@
extern crate cookbook;
use cookbook::recipes::Recipe;
pub mod solver;
pub mod template;
#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
}
}
pub use solver::{Domain, DomainValues};
/// We mainly use Recipe as the domain value type
pub type Value = Recipe;

83
planner/src/solver.rs
View File

@@ -2,15 +2,16 @@
//!
//! Provides `Variables`, `Domain` structs and `solve_all` function.
use std::fmt;
use std::hash::Hash;
use std::clone::Clone;
use std::collections::HashMap;
/// An assignments map of variables
pub type Variables<'a, V> = HashMap<String, Option<&'a V>>;
pub type Variables<'a, V, K> = HashMap<K, Option<&'a V>>;
enum Assignment<'a, V> {
Update(String, &'a V),
Clear(String)
enum Assignment<'a, V, K> {
Update(K, &'a V),
Clear(K)
}
@@ -38,13 +39,17 @@ impl<V> Domain<V> {
/// # extern crate planner;
/// # use planner::solver::Domain;
/// let domain = Domain::new(vec![1,2,3]);
/// fn even(i: &i32) -> bool { i % 2 == 0 };
/// assert_eq!(&domain.filter(even).values, &vec![2]);
/// fn even(i: &i32) -> bool {
/// i % 2 == 0
/// };
/// assert_eq!(domain.filter(even), vec![&2]);
/// assert_eq!(domain.filter(|i: &i32| i % 2 == 1), vec![&1,&3]);
/// ```
pub fn filter(&self, f: fn(&&V) -> bool) -> DomainValues<V>
where V: std::clone::Clone
{
self.values.iter().filter(f).collect()
pub fn filter(&self, filter_func: fn(&V) -> bool) -> DomainValues<V> {
self.values
.iter()
.filter(|v: &&V| filter_func(*v))
.collect()
}
}
@@ -55,26 +60,31 @@ impl<V: fmt::Debug> fmt::Debug for Domain<V> {
}
pub type Constraint<'a,V> = fn(&Variables<'a,V>) -> bool;
pub type Constraint<'a,V, K> = fn(&Variables<'a,V, K>) -> bool;
pub struct Problem<'a, V> {
pub struct Problem<'a, V, K> {
/// The initial assignements map
variables: Variables<'a, V>,
variables: Variables<'a, V, K>,
/// Each variable has its associated domain
domains: HashMap<String, DomainValues<'a,V>>,
domains: HashMap<K, DomainValues<'a,V>>,
/// Set of constraints to validate
constraints: Vec<Constraint<'a,V>>,
constraints: Vec<Constraint<'a,V,K>>,
}
impl<'a,V> Problem<'a, V> {
impl<'a,V, K: Eq + Hash + Clone> Problem<'a, V, K> {
pub fn build() -> ProblemBuilder<'a,V> {
pub fn build() -> ProblemBuilder<'a,V, K> {
ProblemBuilder::new()
}
pub fn from_template(_template: i32) -> Problem<'a, V, K> {
Self::build()
.finish()
}
/// Returns all possible Updates for next assignements, prepended with
/// a Clear to ensure the variable is unset before when leaving the branch.
fn _push_updates(&self) -> Option<Vec<Assignment<'a,V>>> {
fn _push_updates(&self) -> Option<Vec<Assignment<'a,V, K>>> {
// TODO: should be able to inject a choosing strategy
if let Some((key,_)) = self.variables.iter().find(|(_, val)| val.is_none()) {
let domain_values = self.domains.get(key).expect("No domain for variable !");
@@ -100,12 +110,13 @@ impl<'a,V> Problem<'a, V> {
return true;
}
/// Visit all possible solutions, using a stack (DFS).
pub fn solve_all(&mut self) -> Vec<Variables<'a,V>>
where V: Clone + fmt::Debug
/// Returns all complete solutions, after visiting all possible outcomes using a stack (DFS).
pub fn solve_all(&mut self) -> Vec<Variables<'a,V,K>>
where V: Clone + fmt::Debug,
K: Clone + fmt::Debug,
{
let mut solutions: Vec<Variables<V>> = vec![];
let mut stack: Vec<Assignment<'a, V>> = vec![];
let mut solutions: Vec<Variables<V, K>> = vec![];
let mut stack: Vec<Assignment<'a, V, K>> = vec![];
stack.append(&mut self._push_updates().unwrap());
loop {
let node = stack.pop();
@@ -134,10 +145,10 @@ impl<'a,V> Problem<'a, V> {
}
}
pub struct ProblemBuilder<'a, V>(Problem<'a, V>);
pub struct ProblemBuilder<'a, V, K>(Problem<'a, V, K>);
impl<'a, V> ProblemBuilder<'a, V> {
fn new() -> ProblemBuilder<'a, V> {
impl<'a, V, K: Eq + Hash + Clone> ProblemBuilder<'a, V, K> {
fn new() -> ProblemBuilder<'a, V, K> {
ProblemBuilder(
Problem{
variables: Variables::new(),
@@ -146,21 +157,19 @@ impl<'a, V> ProblemBuilder<'a, V> {
})
}
pub fn add_variable<S>(mut self, name: S, domain: Vec<&'a V>, value: Option<&'a V>) -> Self
where S: Into<String>
pub fn add_variable(mut self, name: K, domain: Vec<&'a V>, value: Option<&'a V>) -> Self
{
let name = name.into();
self.0.variables.insert(name.clone(), value);
self.0.domains.insert(name, domain);
self
}
pub fn add_constraint(mut self, cons: Constraint<'a,V>) -> Self {
pub fn add_constraint(mut self, cons: Constraint<'a,V, K>) -> Self {
self.0.constraints.push(cons);
self
}
pub fn finish(self) -> Problem<'a, V> {
pub fn finish(self) -> Problem<'a, V, K> {
self.0
}
}
@@ -172,15 +181,15 @@ mod tests {
fn test_solver_find_pairs() {
use super::*;
let domain = Domain::new(vec![1,2,3]);
let mut problem: Problem<_> = Problem::build()
let mut problem: Problem<_, _> = Problem::build()
.add_variable(String::from("Left"), domain.all(), None)
.add_variable(String::from("Right"), domain.all(), None)
.add_constraint(|assign: &Variables<i32>| {
.add_constraint(|assign: &Variables<i32, _>| {
assign.get("Left").unwrap() == assign.get("Right").unwrap()
})
.finish();
let solutions: Vec<Variables<i32>> = vec![
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(),
@@ -193,15 +202,15 @@ mod tests {
fn test_solver_find_pairs_with_initial() {
use super::*;
let domain = Domain::new(vec![1,2,3]);
let mut problem: Problem<_> = Problem::build()
let mut problem: Problem<_, _> = Problem::build()
.add_variable("Left".to_string(), domain.all(), None)
.add_variable("Right".to_string(), domain.all(), Some(&2))
.add_constraint( |assign: &Variables<i32>| {
.add_constraint( |assign: &Variables<i32, _>| {
assign.get("Left").unwrap() == assign.get("Right").unwrap()
})
.finish();
let solutions: Vec<Variables<i32>> = vec![
let solutions: Vec<Variables<i32, _>> = vec![
[("Left".to_string(), Some(&2)), ("Right".to_string(), Some(&2)),].iter().cloned().collect(),
];

77
planner/src/template.rs Normal file
View File

@@ -0,0 +1,77 @@
use super::{Domain, DomainValues, Value};
const DAYS: &[&str] = &[
"Lundi", "Mardi", "Mercredi",
"Jeudi", "Vendredi", "Samedi",
"Dimanche"];
/// An enum to discriminate every meals
#[allow(dead_code)]
#[derive(Debug, PartialEq, Eq, Clone, Hash)]
pub enum Meal {
Breakfast,
Lunch,
Dinner
}
type Key<'a> = (&'a str, &'a Meal);
/// Options set on a meal
#[derive(Debug, Default)]
struct MealOpts<V> {
is_used: bool,
initial: Option<V>,
}
/// Lets do a fixed template for now
/// * Breakfast only on weekends.
/// * Lunch has a starter and main course.
/// * Plus dessert on weekend ?
/// * Dinner is just a starter (hot in winter, cold in summer)
pub struct Template;
impl<'a> Template {
/// Returns all possible meals
fn keys() -> Vec<Key<'a>> {
let mut keys = Vec::new();
for day in DAYS {
for meal in &[Meal::Breakfast, Meal::Lunch, Meal::Dinner] {
keys.push((*day, meal))
}
}
keys
}
/// Builds a vector of variables, to be used with
/// [ProblemBuilder](struct.ProblemBuilder.html).
pub fn generate_variables(domain: &Domain<Value>)
-> Vec<(Key, DomainValues<Value>, Option<&Value>)>
{
use cookbook::recipes::RecipeCategory;
let mut vars_opts = Vec::new();
for key in Self::keys().into_iter() {
//TODO: is key used ? MealOpts.is_used
//TODO: Initial values
let category_filter: fn(&Value) -> bool = match key {
(_, Meal::Breakfast) => |r: &Value| {
r.category == RecipeCategory::Breakfast // Breakfast
},
(_, Meal::Lunch) => |r: &Value| {
r.category == RecipeCategory::MainCourse // MainCourse
},
(_, Meal::Dinner) => |r: &Value| {
r.category == RecipeCategory::Starter // Starter
}
};
// TODO: has initial ?
//let key_name = format!("{}_{:?}", key.0, key.1);
let initial = None;
vars_opts.push((key, domain.filter(category_filter), initial));
}
vars_opts
}
}