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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use super::fixed_denominator_fraction::FixedDenominatorFraction;
use crate::math::distances::TriangularDistanceMatrix;
use ebi_objects::{
    anyhow::{Result, anyhow},
    ebi_arithmetic::{Fraction, Zero},
};
use std::{fmt::Debug, sync::Arc};

/**
 * Class to compute the weighted average distance over distances, where these weights are integers and all distances are not negative.
 *
 * Internally, makes all the denominators equal, such that addition can be done without gcd computations.
 */
#[derive(Clone)]
pub struct Average {
    distances: Arc<MatchedDistances>,
    cardinality: Vec<Vec<u64>>,
}

impl Average {
    pub fn new(matrix: TriangularDistanceMatrix) -> Result<Self> {
        let len = matrix.len();
        Ok(Self {
            distances: Arc::new(MatchedDistances::new(matrix)?),
            cardinality: vec![vec![0; len]; len],
        })
    }

    pub fn from_matched_distances(distances: &Arc<MatchedDistances>) -> Self {
        Self {
            distances: Arc::clone(distances),
            cardinality: vec![vec![0; distances.len()]; distances.len()],
        }
    }

    pub fn add(&mut self, index_i: usize, index_j: usize) {
        self.cardinality[index_i][index_j] += 1;
    }

    pub fn average(self) -> Result<Fraction> {
        let mut count = 0;
        let mut sum = FixedDenominatorFraction::zero();

        for i in 0..self.distances.len() {
            for j in 0..self.distances.len() {
                if self.cardinality[i][j] > 0 {
                    count += self.cardinality[i][j];
                    sum += self.distances.get(i, j).as_ref().clone() * self.cardinality[i][j];
                }
            }
        }

        if count == 0 {
            Err(anyhow!("Cannot take the average over no values."))
        } else {
            let result = &sum.to_fraction() / count;
            // log::debug!("average {}", result);
            Ok(result)
        }
    }
}

impl Debug for Average {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Average")
            .field("cardinality", &self.cardinality)
            .finish()
    }
}

pub struct MatchedDistances {
    distances: Vec<Arc<FixedDenominatorFraction>>,
    zero: Arc<FixedDenominatorFraction>,
    len: usize,
}

impl MatchedDistances {
    pub fn new(matrix: TriangularDistanceMatrix) -> Result<Self> {
        Ok(Self {
            distances: FixedDenominatorFraction::create(&matrix.distances)?,
            zero: Arc::new(FixedDenominatorFraction::zero()),
            len: matrix.len(),
        })
    }

    /**
     * Return the lenghth of one side of the matrix
     */
    pub fn len(&self) -> usize {
        self.len
    }

    fn get_index(i: usize, j: usize) -> usize {
        (i * (i - 1)) / 2 + j
    }

    pub fn get(&self, i: usize, j: usize) -> &Arc<FixedDenominatorFraction> {
        if i == j {
            &self.zero
        } else {
            let index = if i > j {
                Self::get_index(i, j)
            } else {
                Self::get_index(j, i)
            };
            &self.distances[index]
        }
    }
}