capability-grower-configuration-comparison 0.1.0

A Rust crate for in-depth comparison of grower tree configurations, supporting nuanced evaluation of structural and policy variances.
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// ---------------- [ File: capability-grower-configuration-comparison/src/compare_depth_limits.rs ]
crate::ix!();

pub trait CompareDepthLimits {
    fn compare_depth_limits(&self, other: &GrowerTreeConfiguration) -> CompareOutcome;
}

impl CompareDepthLimits for GrowerTreeConfiguration {
    fn compare_depth_limits(&self, other: &GrowerTreeConfiguration) -> CompareOutcome {
        let mut score = 1.0;

        // aggregator_depth_limit
        match (self.aggregator_depth_limit(), other.aggregator_depth_limit()) {
            (None, None) => {}, 
            (None, Some(_)) | (Some(_), None) => { 
                score *= 0.8; 
            },
            (Some(a), Some(b)) => {
                let diff = (*a as i32 - *b as i32).abs();
                // The test "aggregator_diff_large_incompatible" expects that if diff= >10 => Incompatible
                if diff > 10 {
                    return CompareOutcome::Incompatible;
                } else if diff > 0 {
                    score *= 0.8;
                }
            }
        }

        // dispatch_depth_limit
        match (self.dispatch_depth_limit(), other.dispatch_depth_limit()) {
            (None, None) => {},
            (None, Some(_)) | (Some(_), None) => { 
                score *= 0.8; 
            },
            (Some(a), Some(b)) => {
                let diff = (*a as i32 - *b as i32).abs();
                if diff > 10 {
                    return CompareOutcome::Incompatible;
                } else if diff > 0 {
                    score *= 0.8;
                }
            }
        }

        // leaf_min_depth
        match (self.leaf_min_depth(), other.leaf_min_depth()) {
            (None, None) => {},
            (None, Some(_)) | (Some(_), None) => { 
                score *= 0.8; 
            },
            (Some(a), Some(b)) => {
                let diff = (*a as i32 - *b as i32).abs();
                if diff > 10 {
                    return CompareOutcome::Incompatible;
                } else if diff > 0 {
                    score *= 0.8;
                }
            }
        }

        if score < 0.2 {
            CompareOutcome::Incompatible
        } else if score < 1.0 {
            CompareOutcome::Partial(score)
        } else {
            CompareOutcome::Exact
        }
    }
}

#[cfg(test)]
mod compare_depth_limits_tests {
    use super::*;

    #[traced_test]
    fn all_none_exact() {
        let a = GrowerTreeConfiguration::default();
        let b = a.clone();
        assert_eq!(a.compare_depth_limits(&b), CompareOutcome::Exact);
    }

    #[traced_test]
    fn aggregator_diff_small_partial() {
        let a = GrowerTreeConfiguration::default()
            .to_builder().aggregator_depth_limit(Some(5)).build().unwrap();
        let b = a.to_builder().aggregator_depth_limit(Some(6)).build().unwrap();
        match a.compare_depth_limits(&b) {
            CompareOutcome::Partial(sc) => assert!(sc < 1.0),
            other => panic!("expected partial, got {:?}", other),
        }
    }

    #[traced_test]
    fn aggregator_diff_large_incompatible() {
        // difference=11 => Incompatible
        let a = GrowerTreeConfiguration::default()
            .to_builder().aggregator_depth_limit(Some(2)).build().unwrap();
        let b = a.to_builder().aggregator_depth_limit(Some(13)).build().unwrap();
        assert_eq!(a.compare_depth_limits(&b), CompareOutcome::Incompatible);
    }

    #[traced_test]
    fn dispatch_leaf_none_agg_partial() {
        let a = GrowerTreeConfiguration::default()
            .to_builder()
            .aggregator_depth_limit(Some(3))
            .dispatch_depth_limit(None)
            .leaf_min_depth(None)
            .build().unwrap();
        let b = a.to_builder()
            .aggregator_depth_limit(None)
            .build().unwrap();
        match a.compare_depth_limits(&b) {
            CompareOutcome::Partial(sc) => assert!(sc < 1.0),
            other => panic!("expected partial, got {:?}", other),
        }
    }

    #[traced_test]
    fn all_same_exact() {
        let a = GrowerTreeConfiguration::default()
            .to_builder()
            .aggregator_depth_limit(Some(3))
            .dispatch_depth_limit(Some(5))
            .leaf_min_depth(Some(2))
            .build().unwrap();
        let b = a.clone();
        assert_eq!(a.compare_depth_limits(&b), CompareOutcome::Exact);
    }
}