Struct ddo::implementation::mdd::shallow::pooled::PooledMDD

pub struct PooledMDD<T, C> where
    T: Eq + Hash + Clone,
    C: Config<T> + Clone,  { /* fields omitted */ }

This structure implements a pooled MDD. This is a kind of bounded width MDD which cannot offer a strong guarantees wrt to the maximum amount of used memory. However, this structure is perfectly suited for problems like MISP, where one decision can affect more than one variable, and expanding a node is expensive but checkinig if a node is going to be impacted by a decision is cheap.

Note

The behavior of this MDD is heavily dependent on the configuration you provide. Therefore, and although a public constructor exists for this structure, it it recommended that you build this type of mdd using the mdd_builder functionality as shown in the following examples.

Example

let problem    = MockProblem;
let relaxation = MockRelax;
// Following line configure and builds a pooled mdd.
let pooled_mdd = mdd_builder(&problem, relaxation).into_pooled();

// Naturally, you can also provide configuration parameters to customize
// the behavior of your MDD. For instance, you can use a custom max width
// heuristic as follows (below, a fixed width)
let problem    = MockProblem;
let relaxation = MockRelax;
let pooled_mdd = mdd_builder(&problem, relaxation)
                .with_max_width(FixedWidth(100))
                .into_pooled();

Implementations

impl<T, C> PooledMDD<T, C> where
    T: Eq + Hash + Clone,
    C: Config<T> + Clone, 

pub fn new(config: C) -> Self

Constructor, uses the given config to parameterize the mdd's behavior

pub fn clear(&mut self)

Resets the state of the mdd to make it reusable and ready to explore an other subproblem-space.

Trait Implementations

impl<T: Clone, C: Clone> Clone for PooledMDD<T, C> where
    T: Eq + Hash + Clone,
    C: Config<T> + Clone, 

fn clone(&self) -> PooledMDD<T, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, C: Debug> Debug for PooledMDD<T, C> where
    T: Eq + Hash + Clone,
    C: Config<T> + Clone, 

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

Formats the value using the given formatter.

impl<T, C> From<C> for PooledMDD<T, C> where
    T: Eq + Hash + Clone,
    C: Config<T> + Clone, 

fn from(c: C) -> Self

Performs the conversion.

impl<T, C> MDD<T, C> for PooledMDD<T, C> where
    T: Eq + Hash + Clone,
    C: Config<T> + Clone, 

As the name suggests, PooledMDD is an implementation of the MDD trait. See the trait definiton for the documentation related to these methods.

fn config(&self) -> &C

Returns a reference to the configuration of this MDD.

fn is_exact(&self) -> bool

Return true iff this MDD is exact. That is to say, it returns true if no nodes have been merged (because of relaxation) or suppressed (because of restriction).

fn best_value(&self) -> isize

Returns the length of the longest path between the root and the terminal node of this MDD.

fn best_solution(&self) -> Option<Solution>

Returns the longest path between the root and terminal node of this MDD.

fn for_each_cutset_node<F>(&self, func: F) where
    F: FnMut(FrontierNode<T>), 

Applies the given function func to all nodes from the exact cutset of this mdd.

fn exact(&mut self, root: &FrontierNode<T>, best_lb: isize)

Expands this MDD into an exact MDD

fn restricted(&mut self, root: &FrontierNode<T>, best_lb: isize)

Expands this MDD into a restricted (lower bound approximation) version of the exact MDD.

fn relaxed(&mut self, root: &FrontierNode<T>, best_lb: isize)

Expands this MDD into a relaxed (upper bound approximation) version of the exact MDD.