Struct ddo::core::common::NodeInfo

pub struct NodeInfo {
    pub is_exact: bool,
    pub is_relaxed: bool,
    pub lp_len: i32,
    pub lp_arc: Option<Edge>,
    pub ub: i32,
}

The partial assignments (derived from longest paths in the MDD) form a chained structure. This structure is made of NodeInfo inter-connected by Edges. An NodeInfo keeps track of the metadata associated to a node. Namely, it is the NodeInfo which is capable of telling if the node is exact, the length of the longest path to it, etc..

Because the chained structure is reference counted, the NodeInfo + Edge representation is very efficient as it allows to pune the tree-shaped structure and forget about paths that are no longer relevant.

Fields

is_exact: bool

This flag is true iff the node owning this node-info is exact

is_relaxed: bool

This flag is true iff the node owning this node-info was created as the result of a node-merger during a relaxation step (see Relaxation.merge_nodes()).

lp_len: i32

The length of the longest path from the root node of the problem to the node owner of this NodeInfo.

lp_arc: Option<Edge>

The edge to the parent of this node along the longest path from root to here. The only case where this field should be None is at the root node of the problem. All other nodes should know their "best parent" and have a way to access it through here.

ub: i32

An upper bound on the best objective value attainable going through this node. (It is not the role of a nodeinfo to compute this value. The upper bound information is computed by the problem relaxation).

Methods

impl NodeInfo

pub fn new(
    lp_len: i32,
    lp_arc: Option<Edge>,
    is_exact: bool,
    is_relaxed: bool
) -> NodeInfo

Constructor.

Creates a new node info from the longest path information (lp_len and lp_arc) along with a flag indicating if this denotes an exaxct node or not. The upper bound is set to a default value (the greatest i32)

pub fn merge(&mut self, other: Self)

Merge other into this node. That is to say, it combines the information from two nodes that are logically equivalent (should be the same). Concretely, it means that it possibly updates the current node to keep the best longest path info, track the 'exactitude' of the node and keep the tightest upper bound.

Important note

This has nothing to do with the user-provided merge_* operators !

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

Returns the longest path (sequence of decisions) from the root of the problem until this node.

pub fn has_exact_best(&self) -> bool

Returns true iff the parent of this node is either non existent or not a relaxed node.

Trait Implementations

impl Clone for NodeInfo

fn clone(&self) -> NodeInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NodeInfo

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

Formats the value using the given formatter.

impl Eq for NodeInfo

impl Ord for NodeInfo

NodeInfos can be ordered by considering their upper bound, the length of their longest path and their exactitude.

fn cmp(&self, other: &Self) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<NodeInfo> for NodeInfo

Two NodeInfo are (partially) equivalent if they are both exact, have the same longest path and upper bound.

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<NodeInfo> for NodeInfo

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for NodeInfo