-
Notifications
You must be signed in to change notification settings - Fork 24
/
Copy pathtest_calc.py
167 lines (132 loc) · 5.47 KB
/
test_calc.py
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
import unittest
import numpy
from csep.utils.calc import bin1d_vec, cleaner_range
class TestCleanerRange(unittest.TestCase):
def setUp(self):
self.start = 0.0
self.end = 0.9
self.dh = 0.1
self.truth = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
def test_discrepancy_with_arange_catch_failure(self):
ar = numpy.arange(self.start, self.end + self.dh / 2, self.dh)
cr = cleaner_range(self.start, self.end, self.dh)
self.assertRaises(AssertionError, numpy.testing.assert_array_equal, ar, cr)
self.assertRaises(AssertionError, numpy.testing.assert_array_equal, ar, self.truth)
def test_discrepancy_with_direct_input(self):
cr = cleaner_range(self.start, self.end, self.dh)
numpy.testing.assert_array_equal(self.truth, cr)
class TestBin1d(unittest.TestCase):
def test_bin1d_vec(self):
data = [0.34, 0.35]
bin_edges = [0.33, 0.34, 0.35, 0.36]
test = bin1d_vec(data, bin_edges).tolist()
expected = [1, 2]
self.assertListEqual(test, expected)
def test_bin1d_vec2(self):
data = [0.9999999]
bin_edges = [0.8, 0.9, 1.0]
test = bin1d_vec(data, bin_edges)
expected = [1]
self.assertListEqual(test.tolist(), expected)
def test_bin1d_vec3(self):
data = [-118.9999999]
bin_edges = [-119.0, -118.9, -118.8]
test = bin1d_vec(data, bin_edges)
expected = [0]
self.assertListEqual(test.tolist(), expected)
def test_bin1d_vec4(self):
data = [-118.9999999]
bin_edges = [-119.0, -118.98, -118.96]
test = bin1d_vec(data, bin_edges)
expected = [0]
self.assertListEqual(test.tolist(), expected)
def test_bin1d_vec5(self):
data = [-119.0]
bin_edges = [-119.0, -118.98, -118.96]
test = bin1d_vec(data, bin_edges)
expected = [0]
self.assertListEqual(test.tolist(), expected)
def test_bin1d_vec6(self):
data = [1189999.99999]
bin_edges = [1189999.9, 1190000.0, 1200000.0]
test = bin1d_vec(data, bin_edges)
expected = [0]
self.assertListEqual(test.tolist(), expected)
def test_bin1d_vec7(self):
data = [-118.98]
bin_edges = [-119.0, -118.98, -118.96]
test = bin1d_vec(data, bin_edges)
expected = [1]
self.assertListEqual(test.tolist(), expected)
def test_bin1d_vec8(self):
data = [-118.9600000001]
bin_edges = [-119.0, -118.98, -118.96]
test = bin1d_vec(data, bin_edges)
expected = [1]
self.assertListEqual(test.tolist(), expected)
def test_bin1d_vec9(self):
data = [-118.97999999]
bin_edges = [-119.0, -118.98, -118.96]
test = bin1d_vec(data, bin_edges)
expected = [1]
self.assertListEqual(test.tolist(), expected)
def test_bin1d_vec_int(self):
data = [1, 3, 5, 10, 20]
bin_edges = [0, 10, 20, 30]
test = bin1d_vec(data, bin_edges)
expected = [0, 0, 0, 1, 2]
self.assertListEqual(test.tolist(), expected)
def test_bin1d_single_bin1(self):
data = [-1, 0, 2, 3, 1, 1.5, 1.0, 0.999999999999999]
bin_edges = [1]
# purposely leaving right_continous flag=False bc it should be forced in the bin1d_vec function
test = bin1d_vec(data, bin_edges)
expected = [-1, -1, 0, 0, 0, 0, 0, -1]
self.assertListEqual(test.tolist(), expected)
def test_bin1d_single_bin2(self):
data = [4.0]
bin_edges = [3.0]
test = bin1d_vec(data, bin_edges)
expected = [0]
self.assertListEqual(test.tolist(), expected)
def test_upper_limit_right_continuous(self):
data = [40, 40, 40]
bin_edges = [0, 10, 20, 30]
test = bin1d_vec(data, bin_edges, right_continuous=True)
expected = [3, 3, 3]
self.assertListEqual(test.tolist(), expected)
def test_upper_limit_not_continuous(self):
data = [30, 30, 30]
bin_edges = [0, 10, 20, 30]
test = bin1d_vec(data, bin_edges)
expected = [3, 3, 3]
self.assertListEqual(test.tolist(), expected)
def test_lower_limit(self):
data = [0]
bin_edges = [0, 10, 20, 30]
test = bin1d_vec(data, bin_edges)
expected = [0]
self.assertListEqual(test.tolist(), expected)
def test_less_and_greater_than(self):
data = [-1, 35, 40]
bin_edges = [0, 10, 20, 30]
test = bin1d_vec(data, bin_edges)
expected = [-1, 3, -1]
self.assertListEqual(test.tolist(), expected)
def test_scalar_inside(self):
mbins = numpy.arange(5.95, 9, 0.1) # (magnitude) bins from 5.95 to 8.95
for i, m in enumerate(mbins):
idx = bin1d_vec(m, mbins, right_continuous=True) # corner cases
self.assertEqual(idx, i)
idx = bin1d_vec(m + 0.05, mbins, right_continuous=True) # center bins
self.assertEqual(idx, i)
idx = bin1d_vec(m + 0.099999999, mbins, right_continuous=True) # end of bins
self.assertEqual(idx, i)
idx = bin1d_vec(10, mbins, right_continuous=True) # larger than last bin edge
self.assertEqual(idx, mbins.size - 1)
def test_scalar_outside(self):
mbins = numpy.arange(5.95, 9, 0.1) # (magnitude) bins from 5.95 to 8.95
idx = bin1d_vec(5, mbins, right_continuous=True)
self.assertEqual(idx, -1)
idx = bin1d_vec(4, mbins, right_continuous=True)
self.assertEqual(idx, -1)