Struct ddo::core::implementation::dp::Minimize

pub struct Minimize<P>(pub P);

This structure provides a simple adapter to express a minimization intent on the objective function instead of the assumed maximization.

Warning

The Minimize() api is still subject to change. Minimize implements the Problem trait by delgating all calls to the target but it flips the signs of the transition costs and initial value. Hence, the the sign of the final 'best' solution should be flipped in order to get the actual solution value.

Example Usage

use ddo::core::implementation::dp::Minimize;
let problem    = Minimize(MockProblem);
let relaxation = MockRelax;
let mdd        = mdd_builder_ref(&problem, relaxation).build();
let mut solver = ParallelSolver::new(mdd);
// val is the optimal value of the objective function. However, because
// the signs of all transition costs and initial values have been flipped,
// the sign of that optimal value should be flipped too.
let (val, sol) = solver.maximize();
// This is the 'true' value obtained by taking the best decisions in the
// original problem
let actual_val = -val;

Trait Implementations

impl<P: Clone> Clone for Minimize<P>

fn clone(&self) -> Minimize<P>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P: Debug> Debug for Minimize<P>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, P: Problem<T>> Problem<T> for Minimize<P>

fn nb_vars(&self) -> usize

Returns the number of decision variables that play a role in the problem.

fn initial_state(&self) -> T

Returns the initial state of the problem (when no decision is taken).

fn initial_value(&self) -> i32

Returns the initial value of the objective function (when no decision is taken).

fn domain_of<'a>(&self, state: &'a T, var: Variable) -> Domain<'a>

Returns the domain of variable var in the given state. These are the possible values that might possibly be affected to var when the system has taken decisions leading to state.

fn transition(&self, state: &T, vars: &VarSet, d: Decision) -> T

Returns the next state reached by the system if the decision d is taken when the system is in the given state and the given set of vars are still free (no value assigned).

fn transition_cost(&self, state: &T, vars: &VarSet, d: Decision) -> i32

Returns the marginal benefit (in terms of objective function to maximize) of taking decision d is when the system is in the given state and the given set of vars are still free (no value assigned).

fn impacted_by(&self, state: &T, variable: Variable) -> bool

Optional method for the case where you'd want to use a pooled mdd implementation. This method returns true iff taking a decision on variable might have an impact (state or longest path) on a node having the given state

fn root_node(&self) -> Node<T>

Returns the root node of an exact MDD standing for this problem.

fn all_vars(&self) -> VarSet

Returns a var set with all the variables of this problem.