Enum EnumLattice 

pub enum EnumLattice {
    Powerset {
        powerset: Powerset,
    },
    Taxonomy {
        taxonomy: Taxonomy,
    },
}

Enumeration of lattices implemented by default

Variants

Powerset

Powerset

Fields

powerset: Powerset

Taxonomy

Taxonomy

Fields

taxonomy: Taxonomy

Trait Implementations

impl Archive for EnumLattice

where Powerset: Archive, Taxonomy: Archive,

type Archived = ArchivedEnumLattice

The archived representation of this type.

type Resolver = EnumLatticeResolver

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 as Archive>::Resolver, out: *mut <Self as Archive>::Archived, )

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

impl Clone for EnumLattice

fn clone(&self) -> EnumLattice

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EnumLattice

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EnumLattice

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<EnumLattice, __D> for Archived<EnumLattice>

where Powerset: Archive, Archived<Powerset>: Deserialize<Powerset, __D>, Taxonomy: Archive, Archived<Taxonomy>: Deserialize<Taxonomy, __D>,

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

Deserializes using the given deserializer

impl HashedTypeDef for EnumLattice

where (): HashedTypeDef,

const TYPE_HASH_NATIVE: u128 = 75_064_138_449_171_645_831_146_742_147_588_372_271u128

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 EnumLattice

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 EnumLattice

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 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 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 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 EnumLattice

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

Type of leaves iterator

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

Get unsafe weighted leaf at rank u

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

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 EnumLattice

where Powerset: Serialize<__S>, Taxonomy: Serialize<__S>,

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

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

impl Serialize for EnumLattice

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.