Struct Taxonomy 

pub struct Taxonomy { /* private fields */ }

Structure of a taxonomy lattice

Implementations

impl Taxonomy

pub fn into_taxon_builder(&self) -> TaxonomyBuilder

Derive taxonomy builder from the taxonomy

• Output: taxonomy builder

pub fn new(root: &TaxonomyBuilder) -> Result<Taxonomy, String>

Build Taxonomy from taxonomy builder

• root: &TaxonomyBuilder : taxonomy builder of the root taxon
• Output: a taxonomy or an error

pub fn rand_taxonomy<R: Rng>(rng: &mut R) -> Taxonomy

Generate random taxonomy

• rng: &mut R : random nuber generator
• R: Rng : type of random number generator
• Output: a random taxonomy

Trait Implementations

impl Archive for Taxonomy

where Taxons: Archive, SafeElement<u128slx>: Archive, TaxonCoder: Archive, HashMap<u128slx, String>: Archive, HashMap<String, u128slx>: Archive, Vec<u128slx>: Archive, HashMap<u128slx, f64slx>: Archive,

type Archived = ArchivedTaxonomy

The archived representation of this type.

type Resolver = TaxonomyResolver

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 Taxonomy

fn clone(&self) -> Taxonomy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Taxonomy

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Taxonomy

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

where Taxons: Archive, Archived<Taxons>: Deserialize<Taxons, __D>, SafeElement<u128slx>: Archive, Archived<SafeElement<u128slx>>: Deserialize<SafeElement<u128slx>, __D>, TaxonCoder: Archive, Archived<TaxonCoder>: Deserialize<TaxonCoder, __D>, HashMap<u128slx, String>: Archive, Archived<HashMap<u128slx, String>>: Deserialize<HashMap<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>,

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

Deserializes using the given deserializer

impl HashedTypeDef for Taxonomy

where (): HashedTypeDef,

const TYPE_HASH_NATIVE: u128 = 47_866_476_730_242_506_567_115_895_432_046_928_412u128

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 Taxonomy

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 Taxonomy

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 Taxonomy

type IntoIterLeaves = IntoIter<<Taxonomy 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 Taxonomy

where Taxons: Serialize<__S>, SafeElement<u128slx>: Serialize<__S>, TaxonCoder: Serialize<__S>, HashMap<u128slx, String>: Serialize<__S>, HashMap<String, u128slx>: Serialize<__S>, Vec<u128slx>: Serialize<__S>, HashMap<u128slx, f64slx>: 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 Taxonomy

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

where S: Serializer,

Serialize this value into the given Serde serializer.