Struct ddo::core::implementation::mdd::pooled::PooledMDD

pub struct PooledMDD<T, C> where
    T: Eq + Hash + Clone,
    C: Config<T>,  { /* 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

use ddo::core::abstraction::dp::{Problem, Relaxation};
use ddo::core::common::{Variable, Domain, VarSet, Decision, Node};
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();

Methods

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

Private functions

pub fn new(config: C) -> Self

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

Trait Implementations

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

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, C> MDD<T> for PooledMDD<T, C> where
    T: Eq + Hash + Clone,
    C: Config<T>, 

PooledMDD implements the MDD abstract data type. Check its documentation for further details.

fn mdd_type(&self) -> MDDType

Tells whether this MDD is exact, relaxed, or restricted.

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

Generates the root node of the problem

fn exact(&mut self, root: &Node<T>, best_lb: i32)

Expands this MDD into an exact MDD

fn restricted(&mut self, root: &Node<T>, best_lb: i32)

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

fn relaxed(&mut self, root: &Node<T>, best_lb: i32)

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

fn consume_cutset<F>(&mut self, f: F) where
    F: FnMut(T, NodeInfo), 

Consumes (removes) all nodes from the cutset of this mdd ands applies the given function f to each pair of (state, node_info) present in 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) -> i32

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

fn best_node(&self) -> &Option<NodeInfo>

Returns the terminal node having the longest associated path in this MDD.

fn longest_path(&self) -> Vec<Decision>

Returns the list of decisions along the longest path between the root node and the best terminal node of this MDD.