ebi 0.3.14

A stochastic process mining utility and library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use ebi_objects::{
    DirectlyFollowsGraph, FiniteStochasticLanguage,
    ebi_arithmetic::{Fraction, One},
};

use crate::ebi_traits::{
    ebi_trait_event_log::EbiTraitEventLog,
    ebi_trait_finite_stochastic_language::EbiTraitFiniteStochasticLanguage,
};

pub trait DirectlyFollowsAbstractor {
    fn abstract_to_directly_follows_graph(&self) -> DirectlyFollowsGraph;
}

impl DirectlyFollowsAbstractor for dyn EbiTraitEventLog {
    fn abstract_to_directly_follows_graph(&self) -> DirectlyFollowsGraph {
        let mut result = DirectlyFollowsGraph::new(self.activity_key().clone());

        //If the language has no traces, then the directly follows graph has no start activities and no empty traces.
        for trace in self.iter_traces() {
            let mut last_activity = None;
            for activity in trace {
                match last_activity {
                    Some(previous) => {
                        //edge
                        result.add_edge(previous, *activity, &Fraction::one());
                    }
                    None => {
                        //start activity
                        result.add_start_activity(*activity, &Fraction::one());
                    }
                }
                last_activity = Some(*activity);
            }

            match last_activity {
                Some(activity) => result.add_end_activity(activity, &Fraction::one()),
                None => result.add_empty_trace(&Fraction::one()),
            };
        }
        result
    }
}

impl DirectlyFollowsAbstractor for dyn EbiTraitFiniteStochasticLanguage + '_ {
    fn abstract_to_directly_follows_graph(&self) -> DirectlyFollowsGraph {
        let mut result = DirectlyFollowsGraph::new(self.activity_key().clone());

        //If the language has no traces, then the directly follows graph has no start activities and no empty traces.

        for (trace, probability) in self.iter_traces_probabilities() {
            let mut last_activity = None;
            for activity in trace {
                match last_activity {
                    Some(previous) => {
                        //edge
                        result.add_edge(previous, *activity, probability);
                    }
                    None => {
                        //start activity
                        result.add_start_activity(*activity, probability);
                    }
                }
                last_activity = Some(*activity);
            }

            match last_activity {
                Some(activity) => result.add_end_activity(activity, probability),
                None => result.add_empty_trace(probability),
            };
        }

        result
    }
}

impl DirectlyFollowsAbstractor for FiniteStochasticLanguage {
    fn abstract_to_directly_follows_graph(&self) -> DirectlyFollowsGraph {
        <dyn EbiTraitFiniteStochasticLanguage>::abstract_to_directly_follows_graph(self)
    }
}