Enum BddPtr

pub enum BddPtr<'a> {
    Compl(&'a BddNode<'a>),
    Reg(&'a BddNode<'a>),
    PtrTrue,
    PtrFalse,
}

Core BDD pointer datatype

Variants

Compl(&'a BddNode<'a>)

Reg(&'a BddNode<'a>)

PtrTrue

PtrFalse

Implementations

impl<'a> BddPtr<'a>

pub fn var_safe(&self) -> Option<VarLabel>

Gets the varlabel of &self

pub fn to_reg(&self) -> BddPtr<'_>

convert a BddPtr into a regular (non-complemented) pointer, but does not change the underlying node.

use rsdd::repr::{
    BddNode, BddPtr,
    VarLabel
};

assert_eq!(BddPtr::PtrTrue, BddPtr::PtrTrue.to_reg());
assert_eq!(BddPtr::PtrTrue, BddPtr::PtrFalse.to_reg());

// this node represents the positive literal 0
let node = BddNode::new(VarLabel::new(0), BddPtr::PtrFalse, BddPtr::PtrTrue);

assert_eq!(BddPtr::Reg(&node), BddPtr::Compl(&node).to_reg());
assert_eq!(BddPtr::Reg(&node), BddPtr::Reg(&node).to_reg());

pub fn low(&self) -> BddPtr<'a>

use rsdd::repr::{
    BddNode, BddPtr,
    VarLabel
};

// this node represents the positive literal 0
let node = BddNode::new(VarLabel::new(0), BddPtr::PtrFalse, BddPtr::PtrTrue);

// for regular BDDs, this behaves "normally"
assert_eq!(BddPtr::Reg(&node).low(), BddPtr::PtrFalse);
// but, for complemented edges, it negates the low edge
assert_eq!(BddPtr::Compl(&node).low(), BddPtr::PtrTrue);

pub fn low_raw(&self) -> BddPtr<'a>

use rsdd::repr::{
    BddNode, BddPtr,
    VarLabel
};

// this node represents the positive literal 0
let node = BddNode::new(VarLabel::new(0), BddPtr::PtrFalse, BddPtr::PtrTrue);

// for regular BDDs, this behaves "normally"
assert_eq!(BddPtr::Reg(&node).low_raw(), BddPtr::PtrFalse);
// but, for complemented edges, it does not negate the low edge
assert_eq!(BddPtr::Compl(&node).low_raw(), BddPtr::PtrFalse);

pub fn high_raw(&self) -> BddPtr<'a>

use rsdd::repr::{
    BddNode, BddPtr,
    VarLabel
};

// this node represents the positive literal 0
let node = BddNode::new(VarLabel::new(0), BddPtr::PtrFalse, BddPtr::PtrTrue);

// for regular BDDs, this behaves "normally"
assert_eq!(BddPtr::Reg(&node).high_raw(), BddPtr::PtrTrue);
// but, for complemented edges, it does not negate the high edge
assert_eq!(BddPtr::Compl(&node).high_raw(), BddPtr::PtrTrue);

pub fn high(&self) -> BddPtr<'a>

use rsdd::repr::{
    BddNode, BddPtr,
    VarLabel
};

// this node represents the positive literal 0
let node = BddNode::new(VarLabel::new(0), BddPtr::PtrFalse, BddPtr::PtrTrue);

// for regular BDDs, this behaves "normally"
assert_eq!(BddPtr::Reg(&node).high(), BddPtr::PtrTrue);
// but, for complemented edges, it negates the high edge
assert_eq!(BddPtr::Compl(&node).high(), BddPtr::PtrFalse);

pub fn clear_scratch(&self)

Traverses the BDD and clears all scratch memory (sets it equal to 0)

pub fn is_const(&self) -> bool

true if the BddPtr points to a constant (i.e., True or False)

use rsdd::repr::{
    BddNode, BddPtr,
    VarLabel
};

assert!(BddPtr::is_const(&BddPtr::PtrTrue));
assert!(BddPtr::is_const(&BddPtr::PtrFalse));

let node = BddNode::new(VarLabel::new(0), BddPtr::PtrFalse, BddPtr::PtrTrue);

assert!(!BddPtr::is_const(&BddPtr::Reg(&node)));
assert!(!BddPtr::is_const(&BddPtr::Compl(&node)));

pub fn scratch<T: ?Sized + Clone + 'static>(&self) -> Option<T>

Gets the scratch value stored in &self

Panics if not node.

pub fn set_scratch<T: 'static>(&self, v: T)

Set the scratch in this node to the value v.

Panics if not a node.

Invariant: values stored in set_scratch must not outlive the provided allocator alloc (i.e., calling scratch involves dereferencing a pointer stored in alloc)

pub fn is_scratch_cleared(&self) -> bool

true if the scratch is current cleared

pub fn to_string_debug(&self) -> String

pub fn print_bdd_lbl(&self, map: &HashMap<VarLabel, VarLabel>) -> String

Print a debug form of the BDD with the label remapping given by map

pub fn print_bdd(&self) -> String

pub fn bdd_fold<T, F: Fn(VarLabel, T, T) -> T>( &self, f: &F, low_v: T, high_v: T, ) -> T

where T: 'static + Clone + Copy + Debug,

pub fn marginal_map( &self, vars: &[VarLabel], num_vars: usize, wmc: &WmcParams<RealSemiring>, ) -> (f64, PartialModel)

Computes the marginal map over variables vars of ptr I.e., computes argmax_{v in vars} \sum_{v not in vars} w(ptr)

pub fn meu( &self, decision_vars: &[VarLabel], num_vars: usize, wmc: &WmcParams<ExpectedUtility>, ) -> (ExpectedUtility, PartialModel)

maximum expected utility calc

pub fn bb<T>( &self, join_vars: &[VarLabel], num_vars: usize, wmc: &WmcParams<T>, ) -> (T, PartialModel)

where T: 'static + BBSemiring,

branch and bound generic over T a BBAlgebra.

pub fn cached_semantic_hash<const P: u128>( &self, order: &VarOrder, map: &WmcParams<FiniteField<P>>, ) -> FiniteField<P>

performs a semantic hash and caches the result on the node

Trait Implementations

impl<'a> Clone for BddPtr<'a>

fn clone(&self) -> BddPtr<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> DDNNFPtr<'a> for BddPtr<'a>

fn is_neg(&self) -> bool

True is this is a complemented edge pointer

fn true_ptr() -> BddPtr<'a>

Generate a pointer to the true constant

fn false_ptr() -> BddPtr<'a>

Generate a pointer to the false constant

fn is_true(&self) -> bool

True if self is a true constant, false otherwise

fn is_false(&self) -> bool

True if self is a false constant, false otherwise

fn fold<T, F: Fn(DDNNF<T>) -> T>(&self, f: F) -> T

where T: 'static + Clone + Copy + Debug,

performs a memoized bottom-up pass with aggregating function f calls

fn count_nodes(&self) -> usize

count the number of nodes in this representation

fn neg(&self) -> Self

Negate the pointer

fn unsmoothed_wmc<T>(&self, params: &WmcParams<T>) -> T

where T: 'static + Semiring + Add<Output = T> + Mul<Output = T>,

Unsmoothed weighted-model count

fn evaluate(&self, instantations: &[bool]) -> bool

fn semantic_hash<const P: u128>( &self, map: &WmcParams<FiniteField<P>>, ) -> FiniteField<P>

compute the semantic hash for this pointer

impl<'a> Debug for BddPtr<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for BddPtr<'a>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for BddPtr<'a>

fn cmp(&self, other: &BddPtr<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for BddPtr<'a>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for BddPtr<'a>

fn partial_cmp(&self, other: &BddPtr<'a>) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<'a> PartialVariableOrder for BddPtr<'a>

fn var(&self) -> Option<VarLabel>

impl<'a> Copy for BddPtr<'a>

impl<'a> Eq for BddPtr<'a>