realizar 0.8.4

Pure Rust ML inference engine built from scratch - model serving for GGUF and safetensors
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152


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

    // ========================================================================
    // Additional Coverage Tests - Rank Assignment
    // ========================================================================

    #[test]
    fn test_assign_ranks_no_ties() {
        let sorted = vec![(1.0, 0), (2.0, 1), (3.0, 0), (4.0, 1)];
        let ranks = assign_ranks_with_ties(&sorted);

        assert_eq!(ranks.len(), 4);
        assert!((ranks[0].0 - 1.0).abs() < 1e-10);
        assert!((ranks[1].0 - 2.0).abs() < 1e-10);
        assert!((ranks[2].0 - 3.0).abs() < 1e-10);
        assert!((ranks[3].0 - 4.0).abs() < 1e-10);
    }

    #[test]
    fn test_assign_ranks_with_multiple_tie_groups() {
        // Two tie groups: (1.0, 1.0) and (3.0, 3.0)
        let sorted = vec![(1.0, 0), (1.0, 1), (3.0, 0), (3.0, 1)];
        let ranks = assign_ranks_with_ties(&sorted);

        // First two should have average rank 1.5
        assert!((ranks[0].0 - 1.5).abs() < 1e-10);
        assert!((ranks[1].0 - 1.5).abs() < 1e-10);
        // Last two should have average rank 3.5
        assert!((ranks[2].0 - 3.5).abs() < 1e-10);
        assert!((ranks[3].0 - 3.5).abs() < 1e-10);
    }

    #[test]
    fn test_assign_ranks_preserves_groups() {
        let sorted = vec![(1.0, 0), (2.0, 1), (3.0, 0)];
        let ranks = assign_ranks_with_ties(&sorted);

        assert_eq!(ranks[0].1, 0);
        assert_eq!(ranks[1].1, 1);
        assert_eq!(ranks[2].1, 0);
    }

    // ========================================================================
    // Additional Coverage Tests - AnalysisResult Fields
    // ========================================================================

    #[test]
    fn test_analysis_result_significant_flag() {
        // Test with alpha = 0.10 (more lenient)
        let control = vec![1.0, 2.0, 3.0, 4.0, 5.0];
        let treatment = vec![3.0, 4.0, 5.0, 6.0, 7.0];
        let result = analyze_t_test(&control, &treatment, 0.10);

        // With larger alpha, more likely to be significant
        // p_value < alpha should set significant = true
        assert_eq!(result.significant, result.p_value < 0.10);
    }

    // ========================================================================
    // Additional Coverage Tests - TestMethod Enum
    // ========================================================================

    #[test]
    fn test_test_method_equality() {
        assert_eq!(TestMethod::TTest, TestMethod::TTest);
        assert_eq!(TestMethod::LogTransformTTest, TestMethod::LogTransformTTest);
        assert_eq!(TestMethod::MannWhitneyU, TestMethod::MannWhitneyU);
        assert_ne!(TestMethod::TTest, TestMethod::MannWhitneyU);
    }

    #[test]
    fn test_test_method_clone() {
        let method = TestMethod::LogTransformTTest;
        let cloned = method.clone();
        assert_eq!(method, cloned);
    }

    // ========================================================================
    // Additional Coverage Tests - EffectSizeInterpretation Enum
    // ========================================================================

    #[test]
    fn test_effect_size_interpretation_equality() {
        assert_eq!(
            EffectSizeInterpretation::Negligible,
            EffectSizeInterpretation::Negligible
        );
        assert_ne!(
            EffectSizeInterpretation::Small,
            EffectSizeInterpretation::Large
        );
    }

    #[test]
    fn test_effect_size_interpretation_clone() {
        let interp = EffectSizeInterpretation::Medium;
        let cloned = interp;
        assert_eq!(interp, cloned);
    }

    // ========================================================================
    // Additional Coverage Tests - MannWhitneyResult
    // ========================================================================

    #[test]
    fn test_mann_whitney_result_clone() {
        let control = vec![1.0, 2.0, 3.0];
        let treatment = vec![4.0, 5.0, 6.0];
        let result = mann_whitney_u(&control, &treatment);
        let cloned = result.clone();

        assert_eq!(result.u_statistic, cloned.u_statistic);
        assert_eq!(result.p_value, cloned.p_value);
        assert_eq!(result.method, cloned.method);
    }

    // ========================================================================
    // Additional Coverage Tests - AnalysisResult Clone
    // ========================================================================

    #[test]
    fn test_analysis_result_clone() {
        let control = vec![1.0, 2.0, 3.0, 4.0, 5.0];
        let treatment = vec![2.0, 3.0, 4.0, 5.0, 6.0];
        let result = analyze_t_test(&control, &treatment, 0.05);
        let cloned = result.clone();

        assert_eq!(result.control_mean, cloned.control_mean);
        assert_eq!(result.treatment_mean, cloned.treatment_mean);
        assert_eq!(result.method, cloned.method);
    }

    // ========================================================================
    // Additional Coverage Tests - AnalysisConfig Clone
    // ========================================================================

    #[test]
    fn test_analysis_config_clone() {
        let config = AnalysisConfig {
            alpha: 0.01,
            auto_detect_skew: true,
        };
        let cloned = config.clone();

        assert_eq!(config.alpha, cloned.alpha);
        assert_eq!(config.auto_detect_skew, cloned.auto_detect_skew);
    }
include!("stats_mann_whitney.rs");
}