zoe 0.0.31

A nightly library for viral genomics
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

#[cfg(feature = "fuzzing")]
pub mod float_compare {
    use crate::{
        alignment::phmm::{
            CorePhmm, EmissionParams, GlobalPhmm, LayerParams, TransitionParams,
            indexing::{GetCore, GetLayer},
        },
        math::{NearlyEqual, NearlyEqualMethod},
    };

    impl<T: NearlyEqual<T> + Copy> NearlyEqual<T> for TransitionParams<T> {
        fn nearly_equal<M: NearlyEqualMethod<T>>(&self, b: &Self, strategy: &M) -> (bool, Option<(T, T)>) {
            self.0.nearly_equal(&b.0, strategy)
        }
    }

    impl<T: NearlyEqual<T> + Copy, const S: usize> NearlyEqual<T> for EmissionParams<T, S> {
        fn nearly_equal<M: NearlyEqualMethod<T>>(&self, b: &Self, strategy: &M) -> (bool, Option<(T, T)>) {
            self.as_array().nearly_equal(b.as_array(), strategy)
        }
    }

    impl<T: NearlyEqual<T> + Copy, const S: usize> NearlyEqual<T> for LayerParams<T, S> {
        fn nearly_equal<M: NearlyEqualMethod<T>>(&self, b: &Self, strategy: &M) -> (bool, Option<(T, T)>) {
            let (eq, vals) = self.transition.nearly_equal(&b.transition, strategy);
            if !eq {
                return (false, vals);
            }
            let (eq, vals) = self.emission_match.nearly_equal(&b.emission_match, strategy);
            if !eq {
                return (false, vals);
            }
            let (eq, vals) = self.emission_insert.nearly_equal(&b.emission_insert, strategy);
            if eq { (true, None) } else { (false, vals) }
        }
    }

    impl<T: NearlyEqual<T> + Copy, const S: usize> NearlyEqual<T> for CorePhmm<T, S> {
        fn nearly_equal<M: NearlyEqualMethod<T>>(&self, b: &Self, strategy: &M) -> (bool, Option<(T, T)>) {
            self.layers().nearly_equal(&b.layers(), strategy)
        }
    }

    impl<T: NearlyEqual<T> + Copy, const S: usize> NearlyEqual<T> for GlobalPhmm<T, S> {
        fn nearly_equal<M: NearlyEqualMethod<T>>(&self, b: &Self, strategy: &M) -> (bool, Option<(T, T)>) {
            if self.mapping() == b.mapping() {
                self.core().nearly_equal(b.core(), strategy)
            } else {
                (false, None)
            }
        }
    }
}