scirs2-python 0.4.3

Python bindings for SciRS2 - A comprehensive scientific computing library in Rust (SciPy alternative)
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349

"""Tests for homogeneity of variance tests."""

import pytest
import numpy as np
import scirs2


class TestLeveneTest:
    """Test Levene's test for homogeneity of variance."""

    def test_levene_basic_two_groups(self):
        """Test basic Levene's test with two groups."""
        g1 = np.array([8.88, 9.12, 9.04, 8.98, 9.00])
        g2 = np.array([8.88, 8.95, 9.29, 9.44, 9.15])

        result = scirs2.levene_py(g1, g2)

        assert "statistic" in result
        assert "pvalue" in result
        assert result["statistic"] >= 0
        assert 0 <= result["pvalue"] <= 1

    def test_levene_three_groups(self):
        """Test Levene's test with three groups."""
        g1 = np.array([8.88, 9.12, 9.04, 8.98, 9.00])
        g2 = np.array([8.88, 8.95, 9.29, 9.44, 9.15])
        g3 = np.array([8.95, 9.12, 8.95, 8.85, 9.03])

        result = scirs2.levene_py(g1, g2, g3)

        assert "statistic" in result
        assert "pvalue" in result

    def test_levene_center_mean(self):
        """Test Levene's test using mean as center."""
        g1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
        g2 = np.array([2.0, 3.0, 4.0, 5.0, 6.0])

        result = scirs2.levene_py(g1, g2, center="mean")

        assert "statistic" in result
        assert "pvalue" in result

    def test_levene_center_median(self):
        """Test Levene's test using median as center (default)."""
        g1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
        g2 = np.array([2.0, 3.0, 4.0, 5.0, 6.0])

        result = scirs2.levene_py(g1, g2, center="median")

        assert "statistic" in result
        assert "pvalue" in result

    def test_levene_center_trimmed(self):
        """Test Levene's test using trimmed mean as center."""
        g1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0])
        g2 = np.array([2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0])

        result = scirs2.levene_py(g1, g2, center="trimmed", proportion_to_cut=0.1)

        assert "statistic" in result
        assert "pvalue" in result

    def test_levene_equal_variances(self):
        """Test Levene's test with groups having equal variances."""
        np.random.seed(42)
        g1 = np.random.normal(0, 1, 50)
        g2 = np.random.normal(1, 1, 50)  # Same variance, different mean

        result = scirs2.levene_py(g1, g2)

        # Should have high p-value for equal variances
        assert result["pvalue"] > 0.05

    def test_levene_different_variances(self):
        """Test Levene's test with groups having different variances."""
        np.random.seed(42)
        g1 = np.random.normal(0, 1, 50)
        g2 = np.random.normal(0, 5, 50)  # Much larger variance

        result = scirs2.levene_py(g1, g2)

        # Should have low p-value for different variances
        assert result["pvalue"] < 0.05

    def test_levene_four_groups(self):
        """Test Levene's test with four groups."""
        g1 = np.array([1.0, 2.0, 3.0, 4.0])
        g2 = np.array([2.0, 3.0, 4.0, 5.0])
        g3 = np.array([3.0, 4.0, 5.0, 6.0])
        g4 = np.array([4.0, 5.0, 6.0, 7.0])

        result = scirs2.levene_py(g1, g2, g3, g4)

        assert "statistic" in result
        assert "pvalue" in result


class TestBartlettTest:
    """Test Bartlett's test for homogeneity of variance."""

    def test_bartlett_basic_two_groups(self):
        """Test basic Bartlett's test with two groups."""
        g1 = np.array([8.88, 9.12, 9.04, 8.98, 9.00])
        g2 = np.array([8.88, 8.95, 9.29, 9.44, 9.15])

        result = scirs2.bartlett_test_py(g1, g2)

        assert "statistic" in result
        assert "pvalue" in result
        assert result["statistic"] >= 0
        assert 0 <= result["pvalue"] <= 1

    def test_bartlett_three_groups(self):
        """Test Bartlett's test with three groups."""
        g1 = np.array([8.88, 9.12, 9.04, 8.98, 9.00])
        g2 = np.array([8.88, 8.95, 9.29, 9.44, 9.15])
        g3 = np.array([8.95, 9.12, 8.95, 8.85, 9.03])

        result = scirs2.bartlett_test_py(g1, g2, g3)

        assert "statistic" in result
        assert "pvalue" in result

    def test_bartlett_equal_variances(self):
        """Test Bartlett's test with groups having equal variances."""
        np.random.seed(42)
        g1 = np.random.normal(0, 1, 50)
        g2 = np.random.normal(1, 1, 50)  # Same variance, different mean

        result = scirs2.bartlett_test_py(g1, g2)

        # Should have high p-value for equal variances
        assert result["pvalue"] > 0.05

    def test_bartlett_different_variances(self):
        """Test Bartlett's test with groups having different variances."""
        np.random.seed(42)
        g1 = np.random.normal(0, 1, 50)
        g2 = np.random.normal(0, 5, 50)  # Much larger variance

        result = scirs2.bartlett_test_py(g1, g2)

        # Should have low p-value for different variances
        assert result["pvalue"] < 0.05

    def test_bartlett_multiple_groups(self):
        """Test Bartlett's test with multiple groups."""
        np.random.seed(42)
        g1 = np.random.normal(0, 1, 30)
        g2 = np.random.normal(0, 1, 30)
        g3 = np.random.normal(0, 1, 30)
        g4 = np.random.normal(0, 1, 30)

        result = scirs2.bartlett_test_py(g1, g2, g3, g4)

        assert "statistic" in result
        assert "pvalue" in result
        # Equal variances should give high p-value
        assert result["pvalue"] > 0.05

    def test_bartlett_different_sample_sizes(self):
        """Test Bartlett's test with different sample sizes."""
        g1 = np.array([1.0, 2.0, 3.0])
        g2 = np.array([2.0, 3.0, 4.0, 5.0, 6.0])
        g3 = np.array([3.0, 4.0])

        result = scirs2.bartlett_test_py(g1, g2, g3)

        assert "statistic" in result
        assert "pvalue" in result


class TestBrownForsytheTest:
    """Test Brown-Forsythe test for homogeneity of variance."""

    def test_brown_forsythe_basic_two_groups(self):
        """Test basic Brown-Forsythe test with two groups."""
        g1 = np.array([8.88, 9.12, 9.04, 8.98, 9.00])
        g2 = np.array([8.88, 8.95, 9.29, 9.44, 9.15])

        result = scirs2.brown_forsythe_py(g1, g2)

        assert "statistic" in result
        assert "pvalue" in result
        assert result["statistic"] >= 0
        assert 0 <= result["pvalue"] <= 1

    def test_brown_forsythe_three_groups(self):
        """Test Brown-Forsythe test with three groups."""
        g1 = np.array([8.88, 9.12, 9.04, 8.98, 9.00])
        g2 = np.array([8.88, 8.95, 9.29, 9.44, 9.15])
        g3 = np.array([8.95, 9.12, 8.95, 8.85, 9.03])

        result = scirs2.brown_forsythe_py(g1, g2, g3)

        assert "statistic" in result
        assert "pvalue" in result

    def test_brown_forsythe_equal_variances(self):
        """Test Brown-Forsythe test with groups having equal variances."""
        np.random.seed(42)
        g1 = np.random.normal(0, 1, 50)
        g2 = np.random.normal(1, 1, 50)  # Same variance, different mean

        result = scirs2.brown_forsythe_py(g1, g2)

        # Should have high p-value for equal variances
        assert result["pvalue"] > 0.05

    def test_brown_forsythe_different_variances(self):
        """Test Brown-Forsythe test with groups having different variances."""
        np.random.seed(42)
        g1 = np.random.normal(0, 1, 50)
        g2 = np.random.normal(0, 5, 50)  # Much larger variance

        result = scirs2.brown_forsythe_py(g1, g2)

        # Should have low p-value for different variances
        assert result["pvalue"] < 0.05

    def test_brown_forsythe_robust_to_outliers(self):
        """Test that Brown-Forsythe is robust to outliers (uses median)."""
        g1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
        g2 = np.array([1.0, 2.0, 3.0, 4.0, 100.0])  # Outlier

        result = scirs2.brown_forsythe_py(g1, g2)

        assert "statistic" in result
        assert "pvalue" in result


class TestHomogeneityEdgeCases:
    """Test edge cases and error conditions."""

    def test_levene_insufficient_groups(self):
        """Test that Levene's test requires at least 2 groups."""
        g1 = np.array([1.0, 2.0, 3.0])

        with pytest.raises(RuntimeError, match="Need at least 2 groups"):
            scirs2.levene_py(g1)

    def test_bartlett_insufficient_groups(self):
        """Test that Bartlett's test requires at least 2 groups."""
        g1 = np.array([1.0, 2.0, 3.0])

        with pytest.raises(RuntimeError, match="Need at least 2 groups"):
            scirs2.bartlett_test_py(g1)

    def test_brown_forsythe_insufficient_groups(self):
        """Test that Brown-Forsythe test requires at least 2 groups."""
        g1 = np.array([1.0, 2.0, 3.0])

        with pytest.raises(RuntimeError, match="Need at least 2 groups"):
            scirs2.brown_forsythe_py(g1)

    def test_levene_with_small_samples(self):
        """Test Levene's test with small sample sizes."""
        g1 = np.array([1.0, 2.0])
        g2 = np.array([3.0, 4.0])

        result = scirs2.levene_py(g1, g2)

        assert "statistic" in result
        assert "pvalue" in result

    def test_bartlett_with_small_samples(self):
        """Test Bartlett's test with small sample sizes."""
        g1 = np.array([1.0, 2.0])
        g2 = np.array([3.0, 4.0])

        result = scirs2.bartlett_test_py(g1, g2)

        assert "statistic" in result
        assert "pvalue" in result


class TestHomogeneityConsistency:
    """Test consistency across homogeneity tests."""

    def test_brown_forsythe_equals_levene_median(self):
        """Test that Brown-Forsythe equals Levene with median center."""
        g1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
        g2 = np.array([2.0, 3.0, 4.0, 5.0, 6.0])
        g3 = np.array([3.0, 4.0, 5.0, 6.0, 7.0])

        bf_result = scirs2.brown_forsythe_py(g1, g2, g3)
        lev_result = scirs2.levene_py(g1, g2, g3, center="median")

        # Brown-Forsythe should be equivalent to Levene with median
        assert abs(bf_result["statistic"] - lev_result["statistic"]) < 1e-6
        assert abs(bf_result["pvalue"] - lev_result["pvalue"]) < 1e-6

    def test_homogeneity_order_invariance(self):
        """Test that homogeneity tests are invariant to group order."""
        g1 = np.array([1.0, 2.0, 3.0])
        g2 = np.array([4.0, 5.0, 6.0])
        g3 = np.array([7.0, 8.0, 9.0])

        # Levene test
        lev1 = scirs2.levene_py(g1, g2, g3)
        lev2 = scirs2.levene_py(g3, g1, g2)
        lev3 = scirs2.levene_py(g2, g3, g1)

        assert abs(lev1["statistic"] - lev2["statistic"]) < 1e-6
        assert abs(lev1["statistic"] - lev3["statistic"]) < 1e-6
        assert abs(lev1["pvalue"] - lev2["pvalue"]) < 1e-6
        assert abs(lev1["pvalue"] - lev3["pvalue"]) < 1e-6

        # Bartlett test
        bar1 = scirs2.bartlett_test_py(g1, g2, g3)
        bar2 = scirs2.bartlett_test_py(g3, g1, g2)
        bar3 = scirs2.bartlett_test_py(g2, g3, g1)

        assert abs(bar1["statistic"] - bar2["statistic"]) < 1e-6
        assert abs(bar1["statistic"] - bar3["statistic"]) < 1e-6
        assert abs(bar1["pvalue"] - bar2["pvalue"]) < 1e-6
        assert abs(bar1["pvalue"] - bar3["pvalue"]) < 1e-6


class TestHomogeneityComparison:
    """Test comparisons between different homogeneity tests."""

    def test_bartlett_vs_levene_normal_data(self):
        """Test Bartlett vs Levene with normal data."""
        np.random.seed(42)
        g1 = np.random.normal(0, 1, 100)
        g2 = np.random.normal(0, 1.5, 100)

        bartlett_result = scirs2.bartlett_test_py(g1, g2)
        levene_result = scirs2.levene_py(g1, g2)

        # Both should detect the difference in variances
        assert bartlett_result["pvalue"] < 0.05
        assert levene_result["pvalue"] < 0.05

    def test_levene_centers_comparison(self):
        """Test different center methods in Levene's test."""
        g1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
        g2 = np.array([2.0, 3.0, 4.0, 5.0, 6.0])

        mean_result = scirs2.levene_py(g1, g2, center="mean")
        median_result = scirs2.levene_py(g1, g2, center="median")

        # Results should be similar but not necessarily identical
        assert "statistic" in mean_result
        assert "statistic" in median_result
        assert "pvalue" in mean_result
        assert "pvalue" in median_result