Mercurial > repos > yufei-luo > s_mart
comparison smart_toolShed/commons/core/stat/test/Test_Stat.py @ 0:e0f8dcca02ed
Uploaded S-MART tool. A toolbox manages RNA-Seq and ChIP-Seq data.
author | yufei-luo |
---|---|
date | Thu, 17 Jan 2013 10:52:14 -0500 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:e0f8dcca02ed |
---|---|
1 from commons.core.stat.Stat import Stat | |
2 import unittest | |
3 | |
4 class Test_Stat(unittest.TestCase): | |
5 | |
6 def test__eq__true(self): | |
7 iStat1 = Stat([1, 2, 3, 46]) | |
8 iStat2 = Stat([1, 2, 3, 46]) | |
9 self.assertTrue(iStat1 == iStat2) | |
10 | |
11 def test__eq__false(self): | |
12 iStat1 = Stat([1, 2, 3, 4]) | |
13 iStat2 = Stat([1, 2, 3, 46]) | |
14 self.assertFalse(iStat1 == iStat2) | |
15 | |
16 def test__eq__disordered_list(self): | |
17 iStat1 = Stat([3, 2, 1, 46]) | |
18 iStat2 = Stat([1, 2, 3, 46]) | |
19 self.assertTrue(iStat1 == iStat2) | |
20 | |
21 def test_reset(self): | |
22 lValues = [1, 2, 5, 9, 12, 46] | |
23 iStat = Stat(lValues) | |
24 iStat.reset() | |
25 expValuesList = [] | |
26 expSum = 0 | |
27 expSum2 = 0 | |
28 expN = 0 | |
29 expMin = 0 | |
30 expMax = 0 | |
31 obsValuesList = iStat.getValuesList() | |
32 obsSum = iStat.getSum() | |
33 obsSum2 = iStat.getSumOfSquares() | |
34 obsN = iStat.getValuesNumber() | |
35 obsMin = iStat.getMin() | |
36 obsMax = iStat.getMax() | |
37 self.assertEquals(expValuesList, obsValuesList) | |
38 self.assertEquals(expSum, obsSum) | |
39 self.assertEquals(expSum2, obsSum2) | |
40 self.assertEquals(expN, obsN) | |
41 self.assertEquals(expMin, obsMin) | |
42 self.assertEquals(expMax, obsMax) | |
43 | |
44 def test_add_EmptyList(self): | |
45 lValues = [] | |
46 iStat = Stat(lValues) | |
47 iStat.add(5) | |
48 expValuesList = [5] | |
49 expSum = 5 | |
50 expSum2 = 25 | |
51 expN = 1 | |
52 expMin = 5 | |
53 expMax = 5 | |
54 obsValuesList = iStat.getValuesList() | |
55 obsSum = iStat.getSum() | |
56 obsSum2 = iStat.getSumOfSquares() | |
57 obsN = iStat.getValuesNumber() | |
58 obsMin = iStat.getMin() | |
59 obsMax = iStat.getMax() | |
60 self.assertEquals(expValuesList, obsValuesList) | |
61 self.assertEquals(expSum, obsSum) | |
62 self.assertEquals(expSum2, obsSum2) | |
63 self.assertEquals(expN, obsN) | |
64 self.assertEquals(expMin, obsMin) | |
65 self.assertEquals(expMax, obsMax) | |
66 | |
67 def test_add_Max(self): | |
68 lValues = [0,1,1] | |
69 iStat = Stat(lValues) | |
70 iStat.add(2) | |
71 expValuesList = [0,1,1,2] | |
72 expSum = 4 | |
73 expSum2 = 6 | |
74 expN = 4 | |
75 expMin = 0 | |
76 expMax = 2 | |
77 obsValuesList = iStat.getValuesList() | |
78 obsSum = iStat.getSum() | |
79 obsSum2 = iStat.getSumOfSquares() | |
80 obsN = iStat.getValuesNumber() | |
81 obsMin = iStat.getMin() | |
82 obsMax = iStat.getMax() | |
83 self.assertEquals(expValuesList, obsValuesList) | |
84 self.assertEquals(expSum, obsSum) | |
85 self.assertEquals(expSum2, obsSum2) | |
86 self.assertEquals(expN, obsN) | |
87 self.assertEquals(expMin, obsMin) | |
88 self.assertEquals(expMax, obsMax) | |
89 | |
90 def test_add_Min(self): | |
91 lValues = [2,1,1] | |
92 iStat = Stat(lValues) | |
93 iStat.add(0) | |
94 expValuesList = [2,1,1,0] | |
95 expSum = 4 | |
96 expSum2 = 6 | |
97 expN = 4 | |
98 expMin = 0 | |
99 expMax = 2 | |
100 obsValuesList = iStat.getValuesList() | |
101 obsSum = iStat.getSum() | |
102 obsSum2 = iStat.getSumOfSquares() | |
103 obsN = iStat.getValuesNumber() | |
104 obsMin = iStat.getMin() | |
105 obsMax = iStat.getMax() | |
106 self.assertEquals(expValuesList, obsValuesList) | |
107 self.assertEquals(expSum, obsSum) | |
108 self.assertEquals(expSum2, obsSum2) | |
109 self.assertEquals(expN, obsN) | |
110 self.assertEquals(expMin, obsMin) | |
111 self.assertEquals(expMax, obsMax) | |
112 | |
113 def test_fill_emptyList(self): | |
114 lValues = [2,1,1] | |
115 iStat = Stat(lValues) | |
116 iStat.fill([]) | |
117 expValuesList = [2,1,1] | |
118 expSum = 4 | |
119 expSum2 = 6 | |
120 expN = 3 | |
121 expMin = 1 | |
122 expMax = 2 | |
123 obsValuesList = iStat.getValuesList() | |
124 obsSum = iStat.getSum() | |
125 obsSum2 = iStat.getSumOfSquares() | |
126 obsN = iStat.getValuesNumber() | |
127 obsMin = iStat.getMin() | |
128 obsMax = iStat.getMax() | |
129 self.assertEquals(expValuesList, obsValuesList) | |
130 self.assertEquals(expSum, obsSum) | |
131 self.assertEquals(expSum2, obsSum2) | |
132 self.assertEquals(expN, obsN) | |
133 self.assertEquals(expMin, obsMin) | |
134 self.assertEquals(expMax, obsMax) | |
135 | |
136 def test_fill(self): | |
137 lValues = [2, 1, 1] | |
138 iStat = Stat(lValues) | |
139 iStat.fill([4, 0]) | |
140 expValuesList = [2, 1, 1, 4, 0] | |
141 expSum = 8 | |
142 expSum2 = 22 | |
143 expN = 5 | |
144 expMin = 0 | |
145 expMax = 4 | |
146 obsValuesList = iStat.getValuesList() | |
147 obsSum = iStat.getSum() | |
148 obsSum2 = iStat.getSumOfSquares() | |
149 obsN = iStat.getValuesNumber() | |
150 obsMin = iStat.getMin() | |
151 obsMax = iStat.getMax() | |
152 self.assertEquals(expValuesList, obsValuesList) | |
153 self.assertEquals(expSum, obsSum) | |
154 self.assertEquals(expSum2, obsSum2) | |
155 self.assertEquals(expN, obsN) | |
156 self.assertEquals(expMin, obsMin) | |
157 self.assertEquals(expMax, obsMax) | |
158 | |
159 def test_mean_emptyList(self): | |
160 lValues = [] | |
161 iStat = Stat(lValues) | |
162 expMean = 0 | |
163 obsMean = iStat.mean() | |
164 self.assertEquals(expMean, obsMean) | |
165 | |
166 def test_mean(self): | |
167 lValues = [0, 1] | |
168 iStat = Stat(lValues) | |
169 expMean = 0.5 | |
170 obsMean = iStat.mean() | |
171 self.assertEquals(expMean, obsMean) | |
172 | |
173 def test_var_emptyList(self): | |
174 lValues = [] | |
175 iStat = Stat(lValues) | |
176 expVar = 0 | |
177 obsVar = iStat.var() | |
178 self.assertEquals(expVar, obsVar) | |
179 | |
180 def test_var(self): | |
181 lValues = [1, 1, 2] | |
182 iStat = Stat(lValues) | |
183 expVar = round(1/float(3), 5) | |
184 obsVar = round(iStat.var(), 5) | |
185 self.assertEquals(expVar, obsVar) | |
186 | |
187 def test_var2(self): | |
188 lValues = [1,6,3,4,9,6] | |
189 iStat = Stat(lValues) | |
190 expVar = 7.76667 | |
191 obsVar = round(iStat.var(), 5) | |
192 self.assertEquals(expVar, obsVar) | |
193 | |
194 def test_var_null(self): | |
195 lValues = [87.340000000000003, 87.340000000000003, 87.340000000000003, 87.340000000000003, 87.340000000000003, 87.340000000000003, 87.340000000000003] | |
196 iStat = Stat(lValues) | |
197 expVar = 0 | |
198 obsVar = round(iStat.var(),5) | |
199 self.assertEquals(expVar, obsVar) | |
200 | |
201 def test_sd(self): | |
202 lValues = [1, 1, 2] | |
203 iStat = Stat(lValues) | |
204 expSd = round(0.577350269, 5) | |
205 obsSd = round(iStat.sd(), 5) | |
206 self.assertEquals(expSd, obsSd) | |
207 | |
208 def test_sd_null(self): | |
209 lValues = [87.340000000000003, 87.340000000000003, 87.340000000000003, 87.340000000000003, 87.340000000000003, 87.340000000000003, 87.340000000000003] | |
210 iStat = Stat(lValues) | |
211 expSd = 0 | |
212 obsSd = round(iStat.sd(), 5) | |
213 self.assertEquals(expSd, obsSd) | |
214 | |
215 def test_cv(self): | |
216 lValues = [1, 1, 2] | |
217 iStat = Stat(lValues) | |
218 expSd = round(0.433012702, 5) | |
219 obsSd = round(iStat.cv(), 5) | |
220 self.assertEquals(expSd, obsSd) | |
221 | |
222 def test_cv_mean_is_nul(self): | |
223 lValues = [1, -1] | |
224 iStat = Stat(lValues) | |
225 expSd = 0 | |
226 obsSd = iStat.cv() | |
227 self.assertEquals(expSd, obsSd) | |
228 | |
229 def test_median_emptyList(self): | |
230 lValues = [] | |
231 iStat = Stat(lValues) | |
232 expMedian = "NA" | |
233 obsMedian = iStat.median() | |
234 self.assertEquals(expMedian, obsMedian) | |
235 | |
236 def test_median_even(self): | |
237 lValues = [1, 2, 3, 4, 1, 2, 54, 6, 7] | |
238 iStat = Stat(lValues) | |
239 expMedian = 3 | |
240 obsMedian = iStat.median() | |
241 self.assertEquals(expMedian, obsMedian) | |
242 | |
243 def test_median_odd(self): | |
244 lValues = [1, 2, 3, 4, 2, 54, 6, 7] | |
245 iStat = Stat(lValues) | |
246 expMedian = 3.5 | |
247 obsMedian = iStat.median() | |
248 self.assertEquals(expMedian, obsMedian) | |
249 | |
250 def test_kurtosis_flat(self): | |
251 lValues = [1, 1, 1] | |
252 iStat = Stat(lValues) | |
253 expKurtosis = 0 | |
254 obsKurtosis = iStat.kurtosis() | |
255 self.assertEquals(expKurtosis, obsKurtosis) | |
256 | |
257 def test_kurtosis_peak(self): | |
258 lValues = [1, 100, -5] | |
259 iStat = Stat(lValues) | |
260 expKurtosis = round(712872278.6609683, 2) | |
261 obsKurtosis = round(iStat.kurtosis(), 2) | |
262 self.assertEquals(expKurtosis, obsKurtosis) | |
263 | |
264 def test_kurtosis_normal(self): | |
265 lValues = [-1, 0, 1.64, 1.64, 0, -1] | |
266 iStat = Stat(lValues) | |
267 expKurtosis = 3.0 | |
268 obsKurtosis = round(iStat.kurtosis(), 1) | |
269 self.assertEquals(expKurtosis, obsKurtosis) | |
270 | |
271 def test_sort(self): | |
272 lValues = [-1, 0, 1.64, 1.64, 0, -1] | |
273 iStat = Stat(lValues) | |
274 expSort = [-1, -1, 0, 0, 1.64, 1.64] | |
275 obsSort = iStat.sort() | |
276 self.assertEquals(expSort, obsSort) | |
277 | |
278 def test_sort_reverse(self): | |
279 lValues = [-1, 0, 1.64, 1.64, 0, -1] | |
280 iStat = Stat(lValues) | |
281 expSort = [1.64, 1.64, 0, 0, -1, -1] | |
282 obsSort = iStat.sort(True) | |
283 self.assertEquals(expSort, obsSort) | |
284 | |
285 def test_sort_emptyList(self): | |
286 lValues = [] | |
287 iStat = Stat(lValues) | |
288 expSort = [] | |
289 obsSort = iStat.sort() | |
290 self.assertEquals(expSort, obsSort) | |
291 | |
292 def test_quantile_emptyList(self): | |
293 lValues = [] | |
294 iStat = Stat(lValues) | |
295 expQuantile = 0 | |
296 obsQuantile = iStat.quantile(0.25) | |
297 self.assertEquals(expQuantile, obsQuantile) | |
298 | |
299 def test_quantile_0perc(self): | |
300 lValues = [0, 2.64, 1.64, -1, 5] | |
301 iStat = Stat(lValues) | |
302 expQuantile = -1 | |
303 obsQuantile = iStat.quantile(0) | |
304 self.assertEquals(expQuantile, obsQuantile) | |
305 | |
306 def test_quantile_25perc(self): | |
307 lValues = [0, 2.64, 1.64, -1, 5] | |
308 iStat = Stat(lValues) | |
309 expQuantile = 0 | |
310 obsQuantile = iStat.quantile(0.25) | |
311 self.assertEquals(expQuantile, obsQuantile) | |
312 | |
313 def test_quantile_41perc(self): | |
314 lValues = [0, 2.64, 1.64, -1, 5] | |
315 iStat = Stat(lValues) | |
316 expQuantile = 1.64 | |
317 obsQuantile = iStat.quantile(0.41) | |
318 self.assertEquals(expQuantile, obsQuantile) | |
319 | |
320 def test_quantile_75perc(self): | |
321 lValues = [0, 2.64, 1.64, -1, 5] | |
322 iStat = Stat(lValues) | |
323 expQuantile = 2.64 | |
324 obsQuantile = iStat.quantile(0.75) | |
325 self.assertEquals(expQuantile, obsQuantile) | |
326 | |
327 def test_quantile_81perc(self): | |
328 lValues = [0, 2.64, 1.64, -1, 5] | |
329 iStat = Stat(lValues) | |
330 expQuantile = 5 | |
331 obsQuantile = iStat.quantile(0.81) | |
332 self.assertEquals(expQuantile, obsQuantile) | |
333 | |
334 def test_quantile_100perc(self): | |
335 lValues = [0, 2.64, 1.64, -1, 5] | |
336 iStat = Stat(lValues) | |
337 expQuantile = 5 | |
338 obsQuantile = iStat.quantile(1) | |
339 self.assertEquals(expQuantile, obsQuantile) | |
340 | |
341 def test_N50(self): | |
342 lValues = [10, 10, 2, 16, 3, 4, 5] | |
343 iStat = Stat(lValues) | |
344 expN50 = 10 | |
345 obsN50 = iStat.N50() | |
346 self.assertEquals(expN50, obsN50) | |
347 | |
348 def test_N50SpecialValues(self): | |
349 lValues = [1, 100, 2, 3] | |
350 iStat = Stat(lValues) | |
351 expN50 = 100 | |
352 obsN50 = iStat.N50() | |
353 self.assertEquals(expN50, obsN50) | |
354 | |
355 if __name__ == "__main__": | |
356 unittest.main() |