histc() reforged
[scilab.git] / scilab / modules / statistics / tests / unit_tests / histc.tst
1 // ========================================================================
2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 // Copyright (C) 2013 - Scilab Enterprises - Paul Bignier
4 // Copyright (C) 2017 - Samuel GOUGEON
5 //
6 //  This file is distributed under the same license as the Scilab package.
7 // ========================================================================
8 //
9 //<-- CLI SHELL MODE -->
10 //<-- NO CHECK REF -->
11 //
12 // ==========================
13 // CHECKING FORMAT OF RESULTS
14 // ==========================
15 [h,j,b,i] = histc([]);
16 assert_checkequal(list(h,j,b,i), list([],[],[],[]));
17 d = rand(2,9);
18 [h,j,b,i] = histc(d, 6);
19 assert_checkequal(size(h),[1,6]);
20 assert_checkequal(size(j),[1,5]);
21 assert_checkequal(size(b),[1,7]);
22 assert_checkequal(size(i),[2,9]);
23 [h,j,b,i] = histc(d, [-%inf 0.3 0.5 0.6 %inf]);
24 assert_checkequal(size(h),[1,4]);
25 assert_checkequal(size(b),[1,5]);
26 d = grand(2,9,"uin",0,9);
27 [h,j,b,i] = histc(d, [1 3 5], "discrete");
28 assert_checkequal(size(h),[1,3]);
29 assert_checkequal(size(j),[1,5]);
30 assert_checkequal(size(b),[1,3]);
31 assert_checkequal(size(i),[2,9]);
32 c = d + %i*d;
33 [h,j,b,i] = histc(c, 4);
34 assert_checkequal(size(h),[1,4]);
35 assert_checkequal(size(j),[1,5]);
36 assert_checkequal(size(b),[1,5]);
37 assert_checkequal(size(i),[2,9]);
38 d = int8(d);
39 [h,j,b,i] = histc(d, 6);
40 assert_checkequal(size(h),[1,6]);
41 assert_checkequal(size(j),[1,2]);
42 assert_checkequal(size(b),[1,7]);
43 assert_checkequal(size(i),[2,9]);
44 [h,j,b,i] = histc(d, [0 3 5 8], "discrete");
45 assert_checkequal(size(h),[1,4]);
46 assert_checkequal(size(j),[1,1]);
47 assert_checkequal(size(b),[1,4]);
48 assert_checkequal(size(i),[2,9]);
49 d = sparse(double(d));
50 [h,j,b,i] = histc(d, 6);
51 assert_checkequal(size(h),[1,6]);
52 assert_checkequal(size(j),[1,5]);
53 assert_checkequal(size(b),[1,7]);
54 assert_checkequal(size(i),[2,9]);
55 [h,j,b,i] = histc(d, [1 3 5], "discrete");
56 assert_checkequal(size(h),[1,3]);
57 assert_checkequal(size(j),[1,5]);
58 assert_checkequal(size(b),[1,3]);
59 assert_checkequal(size(i),[2,9]);
60 d = d + %i*d;
61 [h,j,b,i] = histc(d, 4);
62 assert_checkequal(size(h),[1,4]);
63 assert_checkequal(size(j),[1,5]);
64 assert_checkequal(size(b),[1,5]);
65 assert_checkequal(size(i),[2,9]);
66 // Texts
67 t = matrix(asciimat(grand(20,1,"uin",ascii("a"), ascii("z"))), 2, 10);
68 [h,j,b,i] = histc(t, ["e" "i" "o" "u"]);
69 assert_checkequal(size(h),[1,3]);
70 assert_checkequal(size(j),[1,3]);
71 assert_checkequal(size(b),[1,4]);
72 assert_checkequal(size(i),[2,10]);
73 [h,j,b,i] = histc(t, ["e" "i" "o" "u"], "discrete");
74 assert_checkequal(size(h),[1,4]);
75 assert_checkequal(size(j),[1,3]);
76 assert_checkequal(size(b),[1,4]);
77 assert_checkequal(size(i),[2,10]);
78 // Polynomials
79 z = %z;
80 p = [-z z z z z 2*z 2*z 2*z z^2 z^2];
81 [h,j,b,i] = histc(p);
82 assert_checkequal(size(h),[1,4]);
83 assert_checkequal(size(j),[1,5]);
84 assert_checkequal(size(b),[1,4]);
85 assert_checkequal(size(i),[1,10]);
86 p = [z+%inf -z z z z z 2*z 2*z 2*z z^2 z^2];
87 [h,j,b,i] = histc(p);
88 assert_checkequal(size(h),[1,5]);
89 assert_checkequal(size(j),[1,5]);
90 assert_checkequal(size(b),[1,5]);
91
92 // =====================================================
93 // CHECKING RESULTS WITH DECIMAL REAL OR COMPLEX NUMBERS
94 // =====================================================
95 assert_checkequal(histc(37), 1);
96 d = [1 1 1 2 2 3 4 4 5 5 5 6 6 7 8 8 9 9 9];
97 N = size(d,"*");
98 // Default binning
99 [h,j,b,i] = histc(d);
100 href = [6 5 3 5];
101 assert_checkequal(h, href);
102 assert_checkequal(b, 1:2:9);
103 assert_checkequal(i, [1 1 1 1 1 1 2 2 2 2 2 3 3 3 4 4 4 4 4]);
104 assert_checkequal(histc(d,,"countsNorm"), href/N);
105 assert_checkequal(histc(d,,"density"), href/2);
106 assert_checkequal(histc(d,,"densityNorm"), href/2/N);
107 // Fixed number of bins
108 [h,j,b,i] = histc(d,3);
109 href = [6 7 6];
110 assert_checkequal(h, href);
111 assert_checkequal(b, [3 11 19 27]/3);
112 assert_checkequal(i, [1 1 1 1 1 1 2 2 2 2 2 2 2 3 3 3 3 3 3]);
113 assert_checkequal(histc(d, 3,"countsNorm"), href/N);
114 assert_checkalmostequal(histc(d, 3,"density"), href/(8/3));
115 assert_checkalmostequal(histc(d, 3,"densityNorm"), href/(8/3)/N);
116 // Fixed bins width
117 [h,j,b,i] = histc(d,-2.5);
118 href = [5 6 3 5];
119 assert_checkequal(h, href);
120 assert_checkequal(b, (0:4)*2.5);
121 assert_checkequal(i, [1 1 1 1 1 2 2 2 2 2 2 3 3 3 4 4 4 4 4]);
122 assert_checkequal(histc(d, -2.5, "countsNorm"), href/N);
123 assert_checkalmostequal(histc(d, -2.5, "density"), href/2.5);
124 // Automatic Sturges binning
125 [h,j,b,i] = histc(d,"sturges");
126 href = [5 1 5 2 1 5];
127 assert_checkequal(h, href);
128 assert_checkalmostequal(b, [3 7 11 15 19 23 27]/3);
129 assert_checkequal(i, [1 1 1 1 1 2 3 3 3 3 3 4 4 5 6 6 6 6 6]);
130 assert_checkequal(histc(d,"sturges","countsNorm"), href/N);
131 assert_checkalmostequal(histc(d,"sturges","density"), href/(4/3));
132 assert_checkalmostequal(histc(d,"sturges","densityNorm"), href/(4/3)/N);
133 // Automatic Freedman-Diaconis binning
134 [h,j,b,i] = histc(d, "freediac");
135 href = [11 8];
136 assert_checkequal(h, href);
137 assert_checkalmostequal(b, [1 5 9]);
138 assert_checkequal(i, [1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2]);
139 assert_checkequal(histc(d, "freediac", "countsNorm"), href/N);
140 assert_checkalmostequal(histc(d, "freediac", "density"), href/4);
141 assert_checkalmostequal(histc(d, "freediac", "densityNorm"), href/4/N);
142 // Explicit bins edges, without outsiders
143 sb = [1 4 6 9];
144 [h,j,b,i] = histc(d,sb);
145 href = [8 5 6];
146 assert_checkequal(h, href);
147 assert_checkalmostequal(b, sb);
148 assert_checkequal(i, [1 1 1 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 3]);
149 assert_checkequal(histc(d, sb, "countsNorm"), href/N);
150 assert_checkalmostequal(histc(d, sb, "density"), href./diff(sb));
151 assert_checkalmostequal(histc(d, sb, "densityNorm"), href/N./diff(sb));
152 // Explicit bins edges, with marginal bins
153 sb = [-%inf 3 5 7 %inf];
154 [h,j,b,i] = histc(d,sb);
155 href = [6 5 3 5];
156 assert_checkequal(h, href);
157 assert_checkalmostequal(b, [1 3 5 7 9]);
158 assert_checkequal(i, [1 1 1 1 1 1 2 2 2 2 2 3 3 3 4 4 4 4 4]);
159 assert_checkequal(histc(d, sb, "countsNorm"), href/N);
160 assert_checkalmostequal(histc(d, sb, "density"), href/2);
161 assert_checkalmostequal(histc(d, sb, "densityNorm"), href/N/2);
162 // Explicit bins edges, with useless/empty extra marginal bins
163 sb = [-%inf 1 3 5 7 10 %inf];
164 [h,j,b,i] = histc(d,sb);
165 href = [6 5 3 5];
166 assert_checkalmostequal(b, [1 3 5 7 10]);
167 assert_checkequal(i, [1 1 1 1 1 1 2 2 2 2 2 3 3 3 4 4 4 4 4]);
168 assert_checkequal(histc(d, sb, "countsNorm"), href/N);
169 assert_checkalmostequal(histc(d, sb, "density"), href./[2 2 2 3]);
170 assert_checkalmostequal(histc(d, sb, "densityNorm"), href/N./[2 2 2 3]);
171 // Explicit bins edges, with outsiders
172 // d = [1 1 1 2 2 3 4 4 5 5 5 6 6 7 8 8 9 9 9];
173 sb = [2 5.5 7];
174 [h,j,b,i] = histc(d,sb);
175 href = [8 3];
176 jref = [3 5 0 0 0];
177 assert_checkequal(h, href);
178 assert_checkequal(j, jref);
179 assert_checkalmostequal(b, sb);
180 assert_checkequal(i, [0 0 0 1 1 1 1 1 1 1 1 2 2 2 0 0 0 0 0]);
181 [h, j] = histc(d, sb, "countsNorm");
182 assert_checkequal(h, href/11);
183 assert_checkequal(j, jref/11);
184 [h, j] = histc(d, sb, "countsNorm,normWith: leftout");
185 assert_checkequal(h, href/14);
186 assert_checkequal(j, jref/14);
187 [h, j] = histc(d, sb, "countsNorm,normWith: rightout");
188 assert_checkequal(h, href/16);
189 assert_checkequal(j, jref/16);
190 [h, j] = histc(d, sb, "countsNorm,normWith: out");
191 assert_checkequal(h, href/19);
192 assert_checkequal(j, jref/19);
193 [h, j] = histc(d, sb, "countsNorm,normWith: all");
194 assert_checkequal(h, href/19);
195 assert_checkequal(j, jref/19);
196 [h, j] = histc(d, sb, "density");
197 assert_checkalmostequal(h, href./diff(sb));
198 assert_checkalmostequal(j, jref);
199 [h, j] = histc(d, sb, "densityNorm");
200 assert_checkalmostequal(h, href./diff(sb)/11);
201 assert_checkalmostequal(j, jref/11);
202 [h, j] = histc(d, sb, "densityNorm,normWith: leftout");
203 assert_checkalmostequal(h, href./diff(sb)/14);
204 assert_checkalmostequal(j, jref/14);
205 [h, j] = histc(d, sb, "densityNorm,normWith: rightout");
206 assert_checkalmostequal(h, href./diff(sb)/16);
207 assert_checkalmostequal(j, jref/16);
208 [h, j] = histc(d, sb, "densityNorm,normWith: all");
209 assert_checkalmostequal(h, href./diff(sb)/19);
210 assert_checkalmostequal(j, jref/19);
211
212 // With Nan and Inf
213 // ----------------
214 // continuous: [leftout, rightout, zeros, nan, inf]
215 //d = [1 1 1 2 2 3 4 4 5 5 5 6 6 7 8 8 9 9 9];
216 d = [%nan %inf d %nan %nan -%inf];
217 N = size(d,"*");
218 sb = [2 4.5 7];
219 [h,j,b,i] = histc(d, sb);
220 href = [5 6];
221 jref = [3 5 0 3 2];
222 assert_checkequal(h, href);
223 assert_checkequal(j, jref);
224 assert_checkequal(i, [0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 2 0 0 0 0 0 0 0 0]);
225 [h, j] = histc(d, sb,"countsNorm");
226 assert_checkequal(h, href/11);
227 assert_checkequal(j, jref/11);
228 [h, j] = histc(d, sb,"countsNorm,normWith: nan");
229 assert_checkequal(h, href/14);
230 assert_checkequal(j, jref/14);
231 [h, j] = histc(d, sb,"countsNorm,normWith: inf");
232 assert_checkequal(h, href/13);
233 assert_checkequal(j, jref/13);
234 [h, j] = histc(d, sb,"countsNorm,normWith: inf nan");
235 assert_checkequal(h, href/16);
236 assert_checkequal(j, jref/16);
237 [h, j] = histc(d, sb,"countsNorm,normWith: leftout nan");
238 assert_checkequal(h, href/17);
239 assert_checkequal(j, jref/17);
240 [h, j] = histc(d, sb,"countsNorm,normWith: rightout inf");
241 assert_checkequal(h, href/18);
242 assert_checkequal(j, jref/18);
243 [h, j] = histc(d, sb,"countsNorm,normWith: out inf");
244 assert_checkequal(h, href/21);
245 assert_checkequal(j, jref/21);
246 [h, j] = histc(d, sb,"countsNorm,normWith: all");
247 assert_checkequal(h, href/24);
248 assert_checkequal(j, jref/24);
249
250 [h, j] = histc(d, sb,"densityNorm");
251 assert_checkequal(h, href/11/2.5);
252 assert_checkequal(j, jref/11);
253 [h, j] = histc(d, sb,"densityNorm,normWith: nan");
254 assert_checkequal(h, href/14/2.5);
255 assert_checkequal(j, jref/14);
256 [h, j] = histc(d, sb,"densityNorm,normWith: inf");
257 assert_checkequal(h, href/13/2.5);
258 assert_checkequal(j, jref/13);
259 [h, j] = histc(d, sb,"densityNorm,normWith: inf nan");
260 assert_checkequal(h, href/16/2.5);
261 assert_checkequal(j, jref/16);
262 [h, j] = histc(d, sb,"densityNorm,normWith: leftout nan");
263 assert_checkequal(h, href/17/2.5);
264 assert_checkequal(j, jref/17);
265 [h, j] = histc(d, sb,"densityNorm,normWith: rightout inf");
266 assert_checkequal(h, href/18/2.5);
267 assert_checkequal(j, jref/18);
268 [h, j] = histc(d, sb,"densityNorm,normWith: all");
269 assert_checkequal(h, href/24/2.5);
270 assert_checkequal(j, jref/24);
271
272 // CATEGORIAL MODE
273 // The order of binsValues matters and is kept
274 // a) sorted, no duplicate:
275 d = [
276 1  7  4  4  1  4  3  4  8  6  8  2  3  4  6
277 1  6  2  7  7  3  8  7  4  3  4  4  1  5  7
278 ];
279 [h,j,b,i] = histc(d, [1 2 4 7] , "discrete");
280 href = [4 2 8 5];
281 assert_checkequal(h, href);
282 assert_checkequal(b, [1 2 4 7]);
283 iref = [
284 1  4  3  3  1  3  0  3  0  0  0  2  0  3  0
285 1  0  2  4  4  0  0  4  3  0  3  3  1  0  4
286 ];
287 assert_checkequal(i, iref);
288 // b) sorted main bins values, but duplicates
289 [h,j,b,i] = histc(d, [1 2 1 4 2 7 4] , "discrete");
290 assert_checkequal(h, href);
291 assert_checkequal(b, [1 2 4 7]);
292 assert_checkequal(i, iref);
293
294 // c) puzzled bins values, no duplicates:
295 [h,j,b,i] = histc(d, [2 7 1 4] , "discrete");
296 href = [2 5 4 8];
297 assert_checkequal(h, href);
298 assert_checkequal(b, [2 7 1 4]);
299 iref = [
300 3  2  4  4  3  4  0  4  0  0  0  1  0  4  0
301 3  0  1  2  2  0  0  2  4  0  4  4  3  0  2
302 ];
303 assert_checkequal(i, iref);
304 // d) puzzled and duplicates bins values:
305 [h,j,b,i] = histc(d, [2 7 2 7 1 7 2 4 1 4] , "discrete");
306 assert_checkequal(h, href);
307 assert_checkequal(b, [2 7 1 4]);
308 assert_checkequal(i, iref);
309
310 // e) bins with %inf and %nan
311 d = [
312 1 1 1 1 1 2 2 2 2 3 3 3 4 4 5
313 6 7 7 8 8 8 9 9 9 9 0 0 0 0 0
314 ];
315 uns = [1 1 1 1 1];
316 d = [d ; [-uns uns uns*0]*%inf];
317 //   1    1    1    1    1    2   2   2   2   3   3   3   4   4   5
318 //   6    7    7    8    8    8   9   9   9   9   0   0   0   0   0
319 //  -Inf -Inf -Inf -Inf -Inf Inf Inf Inf Inf Inf Nan Nan Nan Nan Nan
320 [h,j,b,i] = histc(d, [1 2 4 7 %nan -%inf] , "discrete");
321 bref = [1  2  4  7 -%inf]
322 href = [5  4  2  2  5 ];
323 jref = [17 0  5  5 10 ];
324 iref = [
325 1  1  1  1  1  2  2  2  2  0  0  0  3  3  0
326 0  4  4  0  0  0  0  0  0  0  0  0  0  0  0
327 5  5  5  5  5  0  0  0  0  0  0  0  0  0  0
328 ];
329 assert_checkequal(h, href);
330 assert_checkequal(j, jref);
331 assert_checkequal(b, bref);
332 assert_checkequal(i, iref);
333 // e.2) = normalized by counted
334 [h,j,b,i] = histc(d, [1 2 4 7 %nan -%inf] , "discrete,countsNorm");
335 assert_checkequal(h, href/sum(href));
336 assert_checkequal(j, jref/sum(href));
337 // e.3) = normalized by all
338 options = "discrete,countsNorm,normwith: all";
339 [h,j,b,i] = histc(d, [1 2 4 7 %nan -%inf], options);
340 assert_checkequal(h, href/size(d,"*"));
341 assert_checkequal(j, jref/size(d,"*"));
342 // e.3) = normalized including out
343 options = "discrete,countsNorm,normwith: out";
344 [h,j,b,i] = histc(d, [1 2 4 7 %nan -%inf], options);
345 assert_checkequal(h, href/(sum(href)+jref(1)));
346 assert_checkequal(j, jref/(sum(href)+jref(1)));
347 // e.4) normalized including Inf: should change nothing, since Inf and -Inf
348 //      are already included.
349 options = "discrete,countsNorm,normwith: inf";
350 [h,j,b,i] = histc(d, [1 2 4 7 %nan -%inf], options);
351 assert_checkequal(h, href/(sum(href)+5));
352 assert_checkequal(j, jref/(sum(href)+5));
353 // e.5) normalized including Nan
354 options = "discrete,countsNorm,normwith: nan";
355 [h,j,b,i] = histc(d, [1 2 4 7 %nan -%inf], options);
356 assert_checkequal(h, href/(sum(href)+jref(4)));
357 assert_checkequal(j, jref/(sum(href)+jref(4)));
358
359 // =============================
360 // WITH SPARSE MATRIX OF NUMBERS
361 // =============================
362
363
364 // =====================
365 // WITH ENCODED INTEGERS
366 // =====================
367 assert_checkequal(histc(int16(37)), 1);
368
369 // ==========
370 // WITH TEXTS
371 // ==========
372 // Discrete bins
373 // -------------
374 assert_checkequal(histc("abcd"), 1);
375 assert_checkequal(histc("abcd",["a" "b"]), 1);
376 assert_checkequal(histc("cbcd",["a" "b"]), 0);
377 assert_checkequal(histc(["a" "c" "a" "a" "b" "c"]), [3 1 2]);
378
379 t = [
380 "c" "n" "h" "i" "b" "i" "f" "i" "p" "l" "p" "d" "f" "i" "l"
381 "b" "m" "e" "o" "o" "f" "p" "o" "h" "f" "h" "h" "c" "k" "o"
382 "p" "f" "k" "a" "j" "o" "j" "d" "h" "h" "n" "m" "o" "l" "n"
383 "h" "b" "o" "l" "j" "n" "o" "i" "g" "i" "a" "a" "j" "d" "p"
384 ];
385 // With default discrete bins:
386 [h,j,b,i] = histc(t);
387 assert_checkequal(h, [3 3 2 3 1 5 1 7 6 4 2 4 2 4 8 5]);
388 assert_checkequal(j, [0 0 0]);
389 assert_checkequal(b, asciimat((97:112)')');
390 iref = [
391 3   14  8   9   2   9   6   9   16  12  16  4   6   9   12
392 2   13  5   15  15  6   16  15  8   6   8   8   3   11  15
393 16  6   11  1   10  15  10  4   8   8   14  13  15  12  14
394 8   2   15  12  10  14  15  9   7   9   1   1   10  4   16
395 ];
396 assert_checkequal(i, iref);
397 // With given discrete bins WITHOUT "" bins:
398 t2 = t;
399 t2([7 13 19 26 32 39 43]) = "";
400 // --> t2  =
401 // c  n  h     b  i  f  i  p  l  p  d  f  i  l
402 // b  m  e  o  o  f     o  h  f  h  h  c  k  o
403 // p     k  a     o  j  d  h        m  o  l  n
404 // h  b  o  l  j  n  o     g  i  a  a  j  d  p
405 //
406 // b =  '' a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p
407 // h =  7  3  3  2  3  1  4  1  6  4  3  2  4  2  3  8  4
408 href = [3 1 4 8];
409 N = sum(href);
410 jref = [37 0 7];
411 bref = ["a" "e" "i" "o"];
412 iref = [
413 0  0  0  0  0  3  0  3  0  0  0  0  0  3  0
414 0  0  2  4  4  0  0  4  0  0  0  0  0  0  4
415 0  0  0  1  0  4  0  0  0  0  0  0  4  0  0
416 0  0  4  0  0  0  4  0  0  3  1  1  0  0  0
417 ];
418 [h,j,b,i] = histc(t2, bref, "discrete");
419 assert_checkequal(h, href);
420 assert_checkequal(j, jref);
421 assert_checkequal(i, iref);
422 // With given discrete bins WITHOUT "" bins: Normalized
423 [h,j,b,i] = histc(t2, bref, "discrete,countsNorm");
424 assert_checkequal(h, href/16);
425 assert_checkequal(j, jref/16);
426 [h,j,b,i] = histc(t2, bref, "discrete,countsNorm,normWith: empty");
427 assert_checkequal(h, href/(16+7));
428 assert_checkequal(j, jref/(16+7));
429 [h,j,b,i] = histc(t2, bref, "discrete,countsNorm,normWith: all");
430 assert_checkequal(h, href/60);
431 assert_checkequal(j, jref/60);
432 [h,j,b,i] = histc(t2, bref, "discrete,countsNorm,normWith: out");
433 assert_checkequal(h, href/(N+jref(1)));
434 assert_checkequal(j, jref/(N+jref(1)));
435 // With given discrete bins WITH "" bins: Normalized
436 href = [3 1 4 8 7];
437 N = sum(href);
438 jref = [37 0 7];
439 [h,j,b,i] = histc(t2, [bref ""], "discrete,countsNorm");
440 assert_checkequal(h, href/N);
441 assert_checkequal(j, jref/N);
442 [h,j,b,i] = histc(t2, [bref ""], "discrete,countsNorm,normWith: empty");
443 assert_checkequal(h, href/N);
444 assert_checkequal(j, jref/N);
445 [h,j,b,i] = histc(t2, [bref ""], "discrete,countsNorm,normWith: out");
446 assert_checkequal(h, href/60);
447 assert_checkequal(j, jref/60);
448
449 // Continuous bins. Data WITHOUT ""
450 // --------------------------------
451 [h,j,b,i] = histc(t, ["a" "c" "e" "g" "i" "k" "m" "o" "q"]);
452 assert_checkequal(h, [8  4  6  13  6  6  12  5]);
453 assert_checkequal(j, [0 0 0]);
454 iref = [
455 1  7  4  4  1  4  3  4  8  6  8  2  3  4  6
456 1  6  2  7  7  3  8  7  4  3  4  4  1  5  7
457 8  3  5  1  5  7  5  2  4  4  7  6  7  6  7
458 4  1  7  6  5  7  7  4  3  4  1  1  5  2  8
459 ];
460 assert_checkequal(i, iref);
461 // With continuous bins and outsiders:
462 [h,j,b,i] = histc(t, ["c" "e" "g" "i" "k" "m"]);
463 assert_checkequal(h, [6 6 13 6 6]);
464 assert_checkequal(j, [6 17 0]);
465 iref = [
466 1  0  3  3  0  3  2  3  0  5  0  1  2  3  5
467 0  5  1  0  0  2  0  0  3  2  3  3  1  4  0
468 0  2  4  0  4  0  4  1  3  3  0  5  0  5  0
469 3  0  0  5  4  0  0  3  2  3  0  0  4  1  0
470 ];
471 assert_checkequal(i, iref);
472 // With continuous and marginal bins: "" <=> -inf , "~~" <=> Inf (regular ascii)
473 [h,j,b,i] = histc(t, ["" "c" "e" "g" "i" "k" "m" "~~"]);
474 assert_checkequal(h, [8 4 6 13 6 6 17]);
475 assert_checkequal(j, [0 0 0]);
476 iref = [
477 1  7  4  4  1  4  3  4  7  6  7  2  3  4  6
478 1  6  2  7  7  3  7  7  4  3  4  4  1  5  7
479 7  3  5  1  5  7  5  2  4  4  7  6  7  6  7
480 4  1  7  6  5  7  7  4  3  4  1  1  5  2  7
481 ];
482 assert_checkequal(i, iref);
483
484 // Continuous bins. Data WITH ""
485 // ------------------------------
486 // t2  =
487 // c  n  h     b  i  f  i  p  l  p  d  f  i  l
488 // b  m  e  o  o  f     o  h  f  h  h  c  k  o
489 // p     k  a     o  j  d  h        m  o  l  n
490 // h  b  o  l  j  n  o     g  i  a  a  j  d  p
491 //
492 // b =  '' a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p
493 // h =  7  3  3  2  3  1  4  1  6  4  3  2  4  2  3  8  4
494 [h,j,b,i] = histc(t2, ["e" "f" "g" "h" "i" "j"]);
495 href = [5 1 6 4 3]; N = sum(href);
496 jref = [11  23  7];
497 [h,j,b,i] = histc(t2, ["e" "f" "g" "h" "i" "j"],"countsNorm,normWith: leftout");
498 assert_checkequal(h, href/(N+jref(1)));
499 assert_checkequal(j, jref/(N+jref(1)));
500 [h,j,b,i] = histc(t2, ["e" "f" "g" "h" "i" "j"],"countsNorm,normWith: rightout");
501 assert_checkequal(h, href/(N+jref(2)));
502 assert_checkequal(j, jref/(N+jref(2)));
503 [h,j,b,i] = histc(t2, ["e" "f" "g" "h" "i" "j"],"countsNorm,normWith: out");
504 assert_checkequal(h, href/sum([N jref(1:2)]));
505 assert_checkequal(j, jref/sum([N jref(1:2)]));
506 [h,j,b,i] = histc(t2, ["e" "f" "g" "h" "i" "j"],"countsNorm,normWith: empty");
507 assert_checkequal(h, href/(N+jref(3)));
508 assert_checkequal(j, jref/(N+jref(3)));
509 [h,j,b,i] = histc(t2, ["e" "f" "g" "h" "i" "j"],"countsNorm,normWith: out empty");
510 assert_checkequal(h, href/sum([N jref]));
511 assert_checkequal(j, jref/sum([N jref]));
512 [h,j,b,i] = histc(t2, ["e" "f" "g" "h" "i" "j"],"countsNorm,normWith: all");
513 assert_checkequal(h, href/sum([N jref]));
514 assert_checkequal(j, jref/sum([N jref]));
515
516
517 // ================
518 // WITH POLYNOMIALS
519 // ================
520 assert_checkequal(histc(%z), 1);
521 assert_checkequal(histc([%z %z 2+%z]), [2 1]);
522 assert_checkequal(histc([%z %z 2+%z],,"countsnorm"), [2 1]/3);
523 assert_checkequal(histc([%z %z 2+%z %nan],,"countsnorm"), [2 1]/3);
524 assert_checkequal(histc([%z %z 2+%z %nan],,"countsnorm,normWith: Nan"), [2 1]/4);  // A VOIR
525 // Data order is kept
526 assert_checkequal(histc([2+%z %z %z ]), [1 2]);
527
528
529 // ==============================
530 // CHECKING ERRORS AND TOLERANCES
531 // ==============================
532 t = ["c" "n" "h" "i" "b" "i" "f" "i" "p" "l" "p" "d" "f" "i" "l"];
533 // Wrong number of arguments
534 msg = _("%s: Wrong number of input arguments: %d to %d expected.\n");
535 msg = msprintf(msg, "histc", 1, 3);
536 assert_checkerror("histc()", msg);
537 // Too many input arguments
538 assert_checkfalse(execstr("histc(1,2,3,4)", "errcatch")==0);
539 // Too many output arguments
540 assert_checkfalse(execstr("[a,b,c,d,e] = histc(rand(1,100))", "errcatch")==0);
541 // Wrong Data types
542 msg = _("%s: Argument #%d: %s\n");
543 msg = msprintf(msg, "histc", 1, "data array missing");
544 assert_checkerror("histc(,,3)", msg);
545 msg = _("histc: Data in argument #1: Numbers or polynomials or texts expected.");
546 assert_checkerror("histc(rand(1,100)<0.5)", msg);       // boolean
547 assert_checkerror("histc(sprand(1,100,0.1)>0.5)", msg); // sparse booleans
548 assert_checkerror("histc(list(%pi, 1, %e))", msg);      // list
549 assert_checkerror("histc({1, 2, 3, 4})", msg);          // cells
550 s(1:3).r = %pi;
551 assert_checkerror("histc(s)", msg);                     // structs
552 // Number of bins must be integer > 0:
553 msg = _("%s: Argument #%d: non-zero decimal integer expected.\n");
554 msg = msprintf(msg, "histc", 2);
555 assert_checkerror("histc(rand(1,100), 1.5)", msg);
556 assert_checkerror("histc(rand(1,100), 0)", msg);
557 assert_checkerror("histc(rand(1,100), %inf)", msg);
558 assert_checkerror("histc(rand(1,100), %nan)", msg);
559 // Bins width must not be %inf
560 msg = _("%s: Argument #%d: decimal number > -Inf expected.\n");
561 msg = msprintf(msg, "histc", 2);
562 assert_checkerror("histc(rand(1,100), -%inf)", msg);
563
564 // Mismatching Data and binsEdges types
565 msg = _("%s: Arguments #%d and #%d: Same types expected.\n")
566 msg = msprintf(msg, "histc", 1, 2);
567 assert_checkerror("histc(t, 1:3)", msg);
568 assert_checkerror("histc(rand(1,100), [""a"" ""b"" ""c""])", msg);
569 assert_checkerror("histc(int8(rand(1,100)*100), [""a"" ""b"" ""c""])", msg);
570 // Mismatching Data and binsValues types
571 assert_checkerror("histc(t, 1:3, ""discrete"")", msg);
572 assert_checkerror("histc(rand(1,100), [""a"" ""b""], ""discrete"")", msg);
573 assert_checkerror("histc(int8(rand(1,100)*100), [""a"" ""b""], ""discrete"")", msg);
574 // Wrong algo name
575 msg = msprintf(_("%s: Argument #%d: wrong value for binning algo"),"histc",2);
576 assert_checkerror("histc(rand(1,100), ""foo"")", msg);
577 // Unapplicable binning modes:
578 msg = msprintf( _("%s: Argument #2: Please provide bins edges or values or leave choosing default bins.\n"), "histc");
579 assert_checkerror("histc(t, ""sqrt"")", msg);
580 assert_checkerror("histc(t, 3)", msg);
581 assert_checkerror("histc(t, -3)", msg);
582 // Wrong options type
583 msg = _("%s: Argument #%d: Text expected.\n");
584 msg = msprintf(msg, "histc", 3);
585 assert_checkerror("histc(rand(1,100),,%t)", msg);
586 assert_checkerror("histc(rand(1,100),,1)", msg);
587 assert_checkerror("histc(rand(1,100),,int8(1))", msg);
588 // Unexisting options are ignored
589 assert_checkequal(execstr("histc(rand(1,1000),,""foo"")", "errcatch"), 0);
590 // Unrelevant options are ignored
591 tmp = "histc(t,,""density"")";
592 assert_checkequal(execstr(tmp, "errcatch"), 0);
593 // Duplicate options are ignored
594 tmp = "histc(grand(1,100,""uin"",0,20),,""discrete,discrete"")";
595 assert_checkequal(execstr(tmp, "errcatch"), 0);
596 // Useless option is ignored
597 tmp = "histc([%z 2*%z %z],,""discrete"")";
598 assert_checkequal(execstr(tmp, "errcatch"), 0);
599 // Useless normWith: flags are ignored
600 tmp = "histc(rand(1,100),,""counts,normWith: inf"")";
601 assert_checkequal(execstr(tmp, "errcatch"), 0);
602 // Bad normWith: flags are ignored
603 tmp = "histc(rand(1,100),,""countsNorm,normWith: foo"")";
604 assert_checkequal(execstr(tmp, "errcatch"), 0);
605
606 // ===========================================================================
607 //                                  SCILAB 5.5
608 // ===========================================================================
609 rand("seed", 0);
610 d = rand(1, 10000, "normal");
611 [cfC, indC] = histc(20, d);
612
613 refCF = [
614    0.0002572096
615    0.00102883842
616    0.00514419209
617    0.00925954575
618    0.02700700845
619    0.07356194682
620    0.12860480213
621    0.20576768341
622    0.30376454264
623    0.36472321885
624    0.39713162899
625    0.36317996123
626    0.28987522401
627    0.19033510716
628    0.11008571063
629    0.06121588582
630    0.02674979884
631    0.01028838417
632    0.00282930565
633    0.00128604802
634 ]';
635 assert_checkequal(size(indC), [1 10000]);
636 assert_checkalmostequal(cfC, refCF,1e-7);
637 [cfC, indC] = histc(int32(20), d);
638 assert_checkequal(size(indC), [1 10000]);
639 assert_checkalmostequal(cfC, refCF, 1e-7);
640
641 // Same test, without normalization
642 [cfC, indC] = histc(20, d, normalization=%f);
643
644 refCF = [
645 1
646 4
647 20
648 36
649 105
650 286
651 500
652 800
653 1181
654 1418
655 1544
656 1412
657 1127
658 740
659 428
660 238
661 104
662 40
663 11
664 5 ]';
665 assert_checkequal(size(indC), [1 10000]);
666 assert_checkequal(cfC, refCF);
667 [cfC, indC] = histc(int16(20), d, normalization=%f);
668 assert_checkequal(size(indC), [1 10000]);
669 assert_checkequal(cfC, refCF);
670
671
672 // With x instead of n as first argument
673 cfC = histc([-5 0 5], d);
674 refCF = [0.4991 0.5009]/5;
675 assert_checkequal(cfC, refCF);
676 cfC = histc(int8([-5 0 5]), d);
677 assert_checkequal(cfC, refCF);
678 cfC = histc(int16([-5 0 5]), d);
679 assert_checkequal(cfC, refCF);
680 cfC = histc(int32([-5 0 5]), d);
681 assert_checkequal(cfC, refCF);
682 assert_checkequal(sum(cfC)*5, 1);
683 cfC = histc([-5 0 5], d, %f);
684 assert_checkequal(sum(cfC), 10000); // -5 > d > 5, and d has 10000 elements.
685
686
687
688 lambda = 2;
689 grand("setsd", 0);
690 D = grand(100000, 1, "exp", 1/lambda);
691 [cfC, indC] = histc(40, D);
692
693 refCF = [
694    1.6987118D+00
695    1.2440861D+00
696    9.0843138D-01
697    6.5661150D-01
698    4.8963575D-01
699    3.5287585D-01
700    2.5718177D-01
701    1.9447913D-01
702    1.4149098D-01
703    9.7271105D-02
704    7.3615681D-02
705    5.0401824D-02
706    3.8416409D-02
707    2.8512672D-02
708    2.1447585D-02
709    1.4634823D-02
710    1.0660711D-02
711    8.2005472D-03
712    5.8665453D-03
713    4.2895170D-03
714    4.1633547D-03
715    1.3877849D-03
716    1.4508660D-03
717    9.4621698D-04
718    7.5697358D-04
719    7.5697358D-04
720    4.4156792D-04
721    3.1540566D-04
722    2.5232453D-04
723    1.8924340D-04
724    6.3081132D-05
725    1.8924340D-04
726    1.2616226D-04
727    6.3081132D-05
728    6.3081132D-05
729    0.0000000D+00
730    0.0000000D+00
731    6.3081132D-05
732    0.0000000D+00
733    6.3081132D-05
734  ]';
735 assert_checkequal(size(indC), [100000 1]);
736 assert_checkalmostequal(cfC, refCF, 1e-7);
737 [cfC, indC] = histc(int8(40), D);
738 assert_checkequal(size(indC), [100000 1]);
739 assert_checkalmostequal(cfC, refCF, 1e-7);
740
741 // Same test, without normalization
742 [cfC, indC] = histc(40, D, normalization=%f);
743 assert_checkequal(size(indC), [100000 1]);
744
745 refCF = [
746 26929
747 19722
748 14401
749 10409
750 7762
751 5594
752 4077
753 3083
754 2243
755 1542
756 1167
757 799
758 609
759 452
760 340
761 232
762 169
763 130
764 93
765 68
766 66
767 22
768 23
769 15
770 12
771 12
772 7
773 5
774 4
775 3
776 1
777 3
778 2
779 1
780 1
781 0
782 0
783 1
784 0
785 1 ]';
786 assert_checkequal(size(indC), [100000 1]);
787 assert_checkalmostequal(cfC, refCF);
788 [cfC, indC] = histc(int32(40), D, normalization=%f);
789 assert_checkequal(size(indC), [100000 1]);
790 assert_checkalmostequal(cfC, refCF);
791
792 // With x instead of n as first argument
793 cfC = histc([0 7], D);
794 refCF = 1/7;
795 assert_checkalmostequal(cfC, refCF);
796 cfC = histc(int8([0 7]), D);
797 assert_checkalmostequal(cfC, refCF);
798 cfC = histc(int16([0 7]), D);
799 assert_checkalmostequal(cfC, refCF);
800 cfC = histc(int32([0 7]), D);
801 assert_checkalmostequal(cfC, refCF);
802 cfC = histc([0 7], D, %f);
803 assert_checkequal(cfC, 100000); // 0 > D > 7, and D has 100000 elements.