v

1
import math
2
import math.stats
3

4
fn test_freq() {
5
	// Tests were also verified on Wolfram Alpha
6
	data := [f64(10.0), f64(10.0), f64(5.9), f64(2.7)]
7
	mut o := stats.freq(data, 10.0)
8
	assert o == 2
9
	o = stats.freq(data, 2.7)
10
	assert o == 1
11
	o = stats.freq(data, 15)
12
	assert o == 0
13
}
14

15
fn tst_res(str1 string, str2 string) bool {
16
	if (math.abs(str1.f64() - str2.f64())) < 1e-5 {
17
		return true
18
	}
19
	return false
20
}
21

22
fn test_mean() {
23
	// Tests were also verified on Wolfram Alpha
24
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
25
	mut o := stats.mean(data)
26
	// Some issue with precision comparison in f64 using == operator hence serializing to string
27
	assert tst_res(o.str(), '5.762500')
28
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
29
	o = stats.mean(data)
30
	// Some issue with precision comparison in f64 using == operator hence serializing to string
31
	assert tst_res(o.str(), '17.650000')
32
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
33
	o = stats.mean(data)
34
	// Some issue with precision comparison in f64 using == operator hence serializing to string
35
	assert tst_res(o.str(), '37.708000')
36
}
37

38
fn test_geometric_mean() {
39
	// Tests were also verified on Wolfram Alpha
40
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
41
	mut o := stats.geometric_mean(data)
42
	// Some issue with precision comparison in f64 using == operator hence serializing to string
43
	assert tst_res(o.str(), '5.15993')
44
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
45
	o = stats.geometric_mean(data)
46
	// Some issue with precision comparison in f64 using == operator hence serializing to string
47
	ok := o.str() == 'nan' || o.str() == '-nan' || o.str() == '-1.#IND00' || o == f64(0)
48
		|| o.str() == '-nan(ind)'
49
	assert ok // Because in math it yields a complex number
50
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
51
	o = stats.geometric_mean(data)
52
	// Some issue with precision comparison in f64 using == operator hence serializing to string
53
	assert tst_res(o.str(), '25.064496')
54
}
55

56
fn test_harmonic_mean() {
57
	// Tests were also verified on Wolfram Alpha
58
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
59
	mut o := stats.harmonic_mean(data)
60
	// Some issue with precision comparison in f64 using == operator hence serializing to string
61
	assert tst_res(o.str(), '4.626519')
62
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
63
	o = stats.harmonic_mean(data)
64
	// Some issue with precision comparison in f64 using == operator hence serializing to string
65
	assert tst_res(o.str(), '9.134577')
66
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
67
	o = stats.harmonic_mean(data)
68
	// Some issue with precision comparison in f64 using == operator hence serializing to string
69
	assert tst_res(o.str(), '16.555477')
70
}
71

72
fn test_median() {
73
	// Tests were also verified on Wolfram Alpha
74
	// Assumes sorted array
75

76
	// Even
77
	mut data := [f64(2.7), f64(4.45), f64(5.9), f64(10.0)]
78
	mut o := stats.median(data)
79
	// Some issue with precision comparison in f64 using == operator hence serializing to string
80
	assert tst_res(o.str(), '5.175000')
81
	data = [f64(-3.0), f64(1.89), f64(4.4), f64(67.31)]
82
	o = stats.median(data)
83
	// Some issue with precision comparison in f64 using == operator hence serializing to string
84
	assert tst_res(o.str(), '3.145000')
85
	data = [f64(7.88), f64(12.0), f64(54.83), f64(76.122)]
86
	o = stats.median(data)
87
	// Some issue with precision comparison in f64 using == operator hence serializing to string
88
	assert tst_res(o.str(), '33.415000')
89

90
	// Odd
91
	data = [f64(2.7), f64(4.45), f64(5.9), f64(10.0), f64(22)]
92
	o = stats.median(data)
93
	assert o == f64(5.9)
94
	data = [f64(-3.0), f64(1.89), f64(4.4), f64(9), f64(67.31)]
95
	o = stats.median(data)
96
	assert o == f64(4.4)
97
	data = [f64(7.88), f64(3.3), f64(12.0), f64(54.83), f64(76.122)]
98
	o = stats.median(data)
99
	assert o == f64(12.0)
100
}
101

102
fn test_mode() {
103
	// Tests were also verified on Wolfram Alpha
104
	mut data := [f64(2.7), f64(2.7), f64(4.45), f64(5.9), f64(10.0)]
105
	mut o := stats.mode(data)
106
	assert o == f64(2.7)
107
	data = [f64(-3.0), f64(1.89), f64(1.89), f64(1.89), f64(9), f64(4.4), f64(4.4), f64(9),
108
		f64(67.31)]
109
	o = stats.mode(data)
110
	assert o == f64(1.89)
111
	// Testing greedy nature
112
	data = [f64(2.0), f64(4.0), f64(2.0), f64(4.0)]
113
	o = stats.mode(data)
114
	assert o == f64(2.0)
115
}
116

117
fn test_rms() {
118
	// Tests were also verified on Wolfram Alpha
119
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
120
	mut o := stats.rms(data)
121
	// Some issue with precision comparison in f64 using == operator hence serializing to string
122
	assert tst_res(o.str(), '6.362046')
123
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
124
	o = stats.rms(data)
125
	// Some issue with precision comparison in f64 using == operator hence serializing to string
126
	assert tst_res(o.str(), '33.773393')
127
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
128
	o = stats.rms(data)
129
	// Some issue with precision comparison in f64 using == operator hence serializing to string
130
	assert tst_res(o.str(), '47.452561')
131
}
132

133
fn test_population_variance() {
134
	// Tests were also verified on Wolfram Alpha
135
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
136
	mut o := stats.population_variance(data)
137
	// Some issue with precision comparison in f64 using == operator hence serializing to string
138
	assert tst_res(o.str(), '7.269219')
139
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
140
	o = stats.population_variance(data)
141
	// Some issue with precision comparison in f64 using == operator hence serializing to string
142
	assert tst_res(o.str(), '829.119550')
143
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
144
	o = stats.population_variance(data)
145
	// Some issue with precision comparison in f64 using == operator hence serializing to string
146
	assert tst_res(o.str(), '829.852282')
147
}
148

149
fn test_sample_variance() {
150
	// Tests were also verified on Wolfram Alpha
151
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
152
	mut o := stats.sample_variance(data)
153
	// Some issue with precision comparison in f64 using == operator hence serializing to string
154
	assert tst_res(o.str(), '9.692292')
155
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
156
	o = stats.sample_variance(data)
157
	// Some issue with precision comparison in f64 using == operator hence serializing to string
158
	assert tst_res(o.str(), '1105.492733')
159
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
160
	o = stats.sample_variance(data)
161
	// Some issue with precision comparison in f64 using == operator hence serializing to string
162
	assert tst_res(o.str(), '1106.469709')
163
}
164

165
fn test_population_stddev() {
166
	// Tests were also verified on Wolfram Alpha
167
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
168
	mut o := stats.population_stddev(data)
169
	// Some issue with precision comparison in f64 using == operator hence serializing to string
170
	assert tst_res(o.str(), '2.696149')
171
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
172
	o = stats.population_stddev(data)
173
	// Some issue with precision comparison in f64 using == operator hence serializing to string
174
	assert tst_res(o.str(), '28.794436')
175
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
176
	o = stats.population_stddev(data)
177
	// Some issue with precision comparison in f64 using == operator hence serializing to string
178
	assert tst_res(o.str(), '28.807157')
179
}
180

181
fn test_sample_stddev() {
182
	// Tests were also verified on Wolfram Alpha
183
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
184
	mut o := stats.sample_stddev(data)
185
	// Some issue with precision comparison in f64 using == operator hence serializing to string
186
	assert tst_res(o.str(), '3.113245')
187
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
188
	o = stats.sample_stddev(data)
189
	// Some issue with precision comparison in f64 using == operator hence serializing to string
190
	assert tst_res(o.str(), '33.248951')
191
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
192
	o = stats.sample_stddev(data)
193
	// Some issue with precision comparison in f64 using == operator hence serializing to string
194
	assert tst_res(o.str(), '33.263639')
195
}
196

197
fn test_absdev() {
198
	// Tests were also verified on Wolfram Alpha
199
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
200
	mut o := stats.absdev(data)
201
	// Some issue with precision comparison in f64 using == operator hence serializing to string
202
	assert tst_res(o.str(), '2.187500')
203
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
204
	o = stats.absdev(data)
205
	// Some issue with precision comparison in f64 using == operator hence serializing to string
206
	assert tst_res(o.str(), '24.830000')
207
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
208
	o = stats.absdev(data)
209
	// Some issue with precision comparison in f64 using == operator hence serializing to string
210
	assert tst_res(o.str(), '27.768000')
211
}
212

213
fn test_min() {
214
	// Tests were also verified on Wolfram Alpha
215
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
216
	mut o := stats.min(data)
217
	assert o == f64(2.7)
218
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
219
	o = stats.min(data)
220
	assert o == f64(-3.0)
221
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
222
	o = stats.min(data)
223
	assert o == f64(7.88)
224
}
225

226
fn test_max() {
227
	// Tests were also verified on Wolfram Alpha
228
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
229
	mut o := stats.max(data)
230
	assert o == f64(10.0)
231
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
232
	o = stats.max(data)
233
	assert o == f64(67.31)
234
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
235
	o = stats.max(data)
236
	assert o == f64(76.122)
237
}
238

239
fn test_range() {
240
	// Tests were also verified on Wolfram Alpha
241
	mut data := [f64(10.0), f64(4.45), f64(5.9), f64(2.7)]
242
	mut o := stats.range(data)
243
	assert o == f64(7.3)
244
	data = [f64(-3.0), f64(67.31), f64(4.4), f64(1.89)]
245
	o = stats.range(data)
246
	assert o == f64(70.31)
247
	data = [f64(12.0), f64(7.88), f64(76.122), f64(54.83)]
248
	o = stats.range(data)
249
	assert o == f64(68.242)
250
}
251

252
fn test_passing_empty() {
253
	data := []f64{}
254
	assert stats.freq(data, 0) == 0
255
	assert stats.mean(data) == f64(0)
256
	assert stats.geometric_mean(data) == f64(0)
257
	assert stats.harmonic_mean(data) == f64(0)
258
	assert stats.median(data) == f64(0)
259
	assert stats.mode(data) == f64(0)
260
	assert stats.rms(data) == f64(0)
261
	assert stats.population_variance(data) == f64(0)
262
	assert stats.sample_variance(data) == f64(0)
263
	assert stats.population_stddev(data) == f64(0)
264
	assert stats.sample_stddev(data) == f64(0)
265
	assert stats.absdev(data) == f64(0)
266
	assert stats.min(data) == f64(0)
267
	assert stats.max(data) == f64(0)
268
	assert stats.range(data) == f64(0)
269
}
270