Struct ddo::core::implementation::mdd::builder::PbRef

pub struct PbRef<X, P> { /* fields omitted */ }

This structure provides typesafewrapper to turn a reference (a borrow) to some problem into something that actually implements the Problem trait.

Such a pbref may be created directly with a call to new But these instances are typically built using a call to mdd_builder_ref.

Example

let problem = MockProblem;
let relax   = MockRelax;
// This call creates an mdd configured with a configuration object that
// holds a copy of PbRef to the actual problem object.
let mdd     = mdd_builder_ref(&problem, relax)
                 .with_max_width(FixedWidth(100))
                 .build();
// thus, the problem can still be used here.
assert_eq!(0, problem.nb_vars());

Methods

impl<X, P> PbRef<X, P>

pub fn new(x: X) -> Self

This creates a new problem wrapper for the given reference.

Trait Implementations

impl<X: Clone, P: Clone> Clone for PbRef<X, P>

fn clone(&self) -> PbRef<X, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, P, X> Problem<T> for PbRef<X, P> where
    P: Problem<T>,
    X: Borrow<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.