Struct Powerset 

pub struct Powerset { /* private fields */ }

Powerset lattice

Implementations

impl Powerset

pub fn new(nb_leaves: usize, max_iter_len: usize) -> Result<Powerset, String>

Powerset constructor

• Leaves labels are generated automatically
• nb_leaves: usize : number of leaves
• max_iter_len: usize : maximal size for an iterator on the powerset
• Output: the powerset or an error, when the number of leaves exceeds 128

pub fn new_with_label( leaves_names: &[String], max_iter_len: usize, ) -> Result<Powerset, String>

Powerset constructor with predefined leaves labels

• Leaves labels are provided
  • The labels should be different: if this condition is not met, this should not affect the computations, but it would make the results less readable
• leaves_names: &[String] : list of leaves described by their names
• max_iter_len: usize : maximal size for an iterator on the powerset
• Output: the powerset or an error, when the number of leaves exceeds 128

pub fn set_iterators(self) -> Self

Implement powerset iterators with a view to use methods IterableLattice::unsafe_bottom_to_top and IterableLattice::unsafe_top_to_bottom

• These iterators are not defined by the powerset constructor due to the amount of resources required for some large powersets
• Output: powerset implementing the iterators

Trait Implementations

impl Archive for Powerset

where u128slx: Archive, SafeElement<u128slx>: Archive, BTreeMap<u128slx, String>: Archive, HashMap<String, u128slx>: Archive, Vec<u128slx>: Archive, HashMap<u128slx, f64slx>: Archive, Option<Vec<u128slx>>: Archive,

type Archived = ArchivedPowerset

The archived representation of this type.

type Resolver = PowersetResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for Powerset

fn clone(&self) -> Powerset

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComplementedLattice for Powerset

unsafe fn unsafe_not(&self, element: &Self::Item) -> Self::Item

Unsafe logical negation

fn not( &self, safe_element: &SafeElement<Self::Item>, ) -> Result<SafeElement<Self::Item>, String>

Logical negation

fn co_assignment( &self, assignment: &Assignment<Self::Item>, ) -> Result<Assignment<Self::Item>, String>

where Self::Item: Ord + Hash,

Compute the co-assignment of an assignment

impl Debug for Powerset

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Powerset

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<Powerset, __D> for Archived<Powerset>

where u128slx: Archive, Archived<u128slx>: Deserialize<u128slx, __D>, SafeElement<u128slx>: Archive, Archived<SafeElement<u128slx>>: Deserialize<SafeElement<u128slx>, __D>, BTreeMap<u128slx, String>: Archive, Archived<BTreeMap<u128slx, String>>: Deserialize<BTreeMap<u128slx, String>, __D>, HashMap<String, u128slx>: Archive, Archived<HashMap<String, u128slx>>: Deserialize<HashMap<String, u128slx>, __D>, Vec<u128slx>: Archive, Archived<Vec<u128slx>>: Deserialize<Vec<u128slx>, __D>, HashMap<u128slx, f64slx>: Archive, Archived<HashMap<u128slx, f64slx>>: Deserialize<HashMap<u128slx, f64slx>, __D>, Option<Vec<u128slx>>: Archive, Archived<Option<Vec<u128slx>>>: Deserialize<Option<Vec<u128slx>>, __D>,

fn deserialize(&self, deserializer: &mut __D) -> Result<Powerset, __D::Error>

Deserializes using the given deserializer

impl HashedTypeDef for Powerset

where (): HashedTypeDef,

const TYPE_HASH_NATIVE: u128 = 205_679_758_547_736_158_701_104_755_242_467_695_097u128

native hash computation

const TYPE_HASH_LE: u128 = _

hash encoded to little endianess

const TYPE_HASH_BE: u128 = _

hash encoded to big endianess

const UUID: Uuid = _

hash encoded to Uuid

impl IterableLattice for Powerset

type IntoIterUp = IntoIter<u128slx>

Type of iterator for iterating lattice from bottom to top

type IntoIterDown = IntoIter<u128slx>

Type of iterator for iterating lattice from top to bottom

unsafe fn unsafe_bottom_to_top(&self) -> Result<Self::IntoIterUp, String>

Unsafe iterator of the full lattice, non decreasing with inference;

unsafe fn unsafe_top_to_bottom(&self) -> Result<Self::IntoIterDown, String>

Unsafe iterator of the full lattice, non increasing with inference;

fn bottom_to_top(&self) -> Result<IntoIter<SafeElement<Self::Item>>, String>

Safe iterator of the full lattice, non decreasing with inference;

fn top_to_bottom(&self) -> Result<IntoIter<SafeElement<Self::Item>>, String>

Safe iterator of the full lattice, non increasing with inference;

impl Lattice for Powerset

type Item = u128slx

Type for encoding lattice elements:

fn rand_lattice<R: Rng>(rng: &mut R) -> Self

Random lattice generator (for tests)

fn rand_element<R: Rng>(&self, rng: &mut R) -> SafeElement<Self::Item>

Random element generator (for tests); elements are built safe

fn ref_lattice_hash(&self) -> &u128slx

Reference to lattice hash

fn contains(&self, element: &Self::Item) -> bool

Test if element is from lattice

fn ref_bottom(&self) -> &SafeElement<Self::Item>

Reference to least element of the lattice

fn ref_top(&self) -> &SafeElement<Self::Item>

Reference to greatest element of the lattice

unsafe fn unsafe_meet( &self, element_left: &Self::Item, element_right: &Self::Item, ) -> Self::Item

Unsafe greatest lower bound

unsafe fn unsafe_join( &self, element_left: &Self::Item, element_right: &Self::Item, ) -> Self::Item

Unsafe least upper bound

fn from_str(&self, s: &str) -> Result<SafeElement<Self::Item>, String>

Parse safe element from str

fn to_string(&self, element: &SafeElement<Self::Item>) -> Result<String, String>

Format safe element into String

fn lattice_hash(&self) -> u128slx

Lattice hash

fn bottom(&self) -> SafeElement<Self::Item>

Least element of the lattice

fn top(&self) -> SafeElement<Self::Item>

Greatest element of the lattice

fn is_bottom( &self, safe_element: &SafeElement<Self::Item>, ) -> Result<bool, String>

Is safe element the least element of the lattice?

fn is_top(&self, safe_element: &SafeElement<Self::Item>) -> Result<bool, String>

Is safe element the greatest element of the lattice?

unsafe fn unsafe_is_bottom(&self, element: &Self::Item) -> bool

Is unsafe element the least element of the lattice?

unsafe fn unsafe_is_top(&self, element: &Self::Item) -> bool

Is unsafe element the greatest element of the lattice?

fn meet( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<SafeElement<Self::Item>, String>

Greatest lower bound

fn meet_some<'a, I>(&self, it: I) -> Result<SafeElement<Self::Item>, String>

where I: IntoIterator<Item = &'a SafeElement<Self::Item>>, Self: 'a,

Greatest lower bound of a collection

fn join( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<SafeElement<Self::Item>, String>

Least upper bound

fn join_some<'a, I>(&self, it: I) -> Result<SafeElement<Self::Item>, String>

where I: IntoIterator<Item = &'a SafeElement<Self::Item>>, Self: 'a,

Least upper bound of a collection

fn check_safe<T>(&self, element: T) -> Result<SafeElement<Self::Item>, String>

where T: Into<Self::Item>,

Check if unsafe element is in lattice and then build safe element

fn rand_elements<R: Rng, I>( &self, len: usize, rng: &mut R, ) -> I::Type<SafeElement<Self::Item>>

where I: CollectionFamily1,

Elements collection generator (for tests); elements are built safe

fn assignment(&self) -> AssignmentBuilder<Self::Item>

where Self::Item: Eq + Ord + Hash,

Init a new assignment builder

fn assignment_with_capacity( &self, capacity: usize, ) -> AssignmentBuilder<Self::Item>

where Self::Item: Eq + Ord + Hash,

Init a new assignment builder with capacity

fn prunable( &self, length_mid: u32, length_max: u32, ) -> AssignmentBuilder<Self::Item>

where Self::Item: Eq + Ord + Hash,

Init a new prunable assignment builder

fn prunable_with_capacity( &self, length_mid: u32, length_max: u32, capacity: usize, ) -> AssignmentBuilder<Self::Item>

where Self::Item: Eq + Ord + Hash,

Init a new prunable assignment builder with capacity

unsafe fn unsafe_cover(&self, left: &Self::Item, right: &Self::Item) -> bool

Unsafe test if left and right cover top, ie. union of left and right is top

unsafe fn unsafe_disjoint(&self, left: &Self::Item, right: &Self::Item) -> bool

Unsafe test if left and right are disjoint

unsafe fn unsafe_implies_join( &self, left: &Self::Item, right: &Self::Item, ) -> bool

Unsafe test if left implies (i.e. is contained by) right

unsafe fn unsafe_implied_join( &self, left: &Self::Item, right: &Self::Item, ) -> bool

Unsafe test if left is implied by (i.e. contains) right

unsafe fn unsafe_implies_meet( &self, left: &Self::Item, right: &Self::Item, ) -> bool

Unsafe test if left implies (i.e. is contained by) right

unsafe fn unsafe_implied_meet( &self, left: &Self::Item, right: &Self::Item, ) -> bool

Unsafe test if left is implied by (i.e. contains) right

fn cover( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left and right cover top, ie. union of left and right is top

fn disjoint( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left and right are disjoint

fn implies_join( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left implies (i.e. is contained by) right

fn implied_join( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left is implied by (i.e. contains) right

fn implies_meet( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left implies (i.e. is contained by) right

fn implied_meet( &self, left: &SafeElement<Self::Item>, right: &SafeElement<Self::Item>, ) -> Result<bool, String>

Test if left is implied by (i.e. contains) right

impl LatticeWithLeaves for Powerset

type IntoIterLeaves = IntoIter<<Powerset as Lattice>::Item, f64slx>

Type of leaves iterator

unsafe fn unsafe_leaves(&self) -> Result<Self::IntoIterLeaves, String>

Unsafe iterator of the weighted leaves of the lattice

unsafe fn unsafe_leaf(&self, u: usize) -> Result<&Self::Item, String>

Get unsafe leaf at rank u

unsafe fn unsafe_weighted_leaf( &self, u: usize, ) -> Result<(&Self::Item, &f64slx), String>

Get unsafe weighted leaf at rank u

fn weighted_leaf( &self, u: usize, ) -> Result<(SafeElement<Self::Item>, f64slx), String>

Get safe weighted leaf at rank u

fn leaf(&self, u: usize) -> Result<SafeElement<Self::Item>, String>

Get safe leaf at rank u

fn leaves(&self) -> Result<IntoIter<(SafeElement<Self::Item>, f64slx)>, String>

Iterator of the safe weighted leaves of the lattice

fn mass_to_pignistic( &self, mass: &Assignment<Self::Item>, ) -> Result<Assignment<Self::Item>, String>

Transform mass to pignistic probability

impl<__S: Fallible + ?Sized> Serialize<__S> for Powerset

where u128slx: Serialize<__S>, SafeElement<u128slx>: Serialize<__S>, BTreeMap<u128slx, String>: Serialize<__S>, HashMap<String, u128slx>: Serialize<__S>, Vec<u128slx>: Serialize<__S>, HashMap<u128slx, f64slx>: Serialize<__S>, Option<Vec<u128slx>>: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for Powerset

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.