Elementary_functions: members() improved
[scilab.git] / scilab / modules / elementary_functions / tests / unit_tests / members.tst
1 // =============================================================================
2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 // Copyright (C) 2013 - Scilab Enterprises - Paul Bignier
4 //
5 //  This file is distributed under the same license as the Scilab package.
6 // =============================================================================
7 //
8 // <-- CLI SHELL MODE -->
9 //
10 // <-- ENGLISH IMPOSED -->
11 //
12
13 // Vectors
14 [nb, loc] = members([], [], "last");
15 assert_checkequal(nb , []);
16 assert_checkequal(loc, []);
17 [nb, loc] = members([], []);
18 assert_checkequal(nb , []);
19 assert_checkequal(loc, []);
20
21 [nb, loc] = members([1 2], [3 4], "last");
22 assert_checkequal(nb , [0 0]);
23 assert_checkequal(loc, [0 0]);
24 [nb, loc] = members([1 2], [3 4]);
25 assert_checkequal(nb , [0 0]);
26 assert_checkequal(loc, [0 0]);
27
28 [nb, loc] = members([1 2; 3 4], [5 6; 7 8], "last");
29 assert_checkequal(nb , [0 0; 0 0]);
30 assert_checkequal(loc, [0 0; 0 0]);
31 [nb, loc] = members([1 2; 3 4], [5 6; 7 8]);
32 assert_checkequal(nb , [0 0; 0 0]);
33 assert_checkequal(loc, [0 0; 0 0]);
34
35 [nb, loc] = members(string([1 2; 3 4]), string([5 6; 7 8]), "last");
36 assert_checkequal(nb , [0 0; 0 0]);
37 assert_checkequal(loc, [0 0; 0 0]);
38 [nb, loc] = members(string([1 2; 3 4]), string([5 6; 7 8]));
39 assert_checkequal(nb , [0 0; 0 0]);
40 assert_checkequal(loc, [0 0; 0 0]);
41
42 A = [1 8 4 5 2 1];
43 S = [9 7 4 2 1 4];
44
45 [nb, loc] = members(A, S, "last");
46 assert_checkequal(nb , [1 0 2 0 1 1]);
47 assert_checkequal(loc, [5 0 6 0 4 5]);
48 [nb, loc] = members(A, S);
49 assert_checkequal(nb , [1 0 2 0 1 1]);
50 assert_checkequal(loc, [5 0 3 0 4 5]);
51
52
53 // Strings
54 A = 'a'+string(A);
55 S = 's'+string(S);
56
57 [nb, loc] = members(A, S, "last");
58 assert_checkequal(nb , [0 0 0 0 0 0]);
59 assert_checkequal(loc, [0 0 0 0 0 0]);
60 [nb, loc] = members(A, S);
61 assert_checkequal(nb , [0 0 0 0 0 0]);
62 assert_checkequal(loc, [0 0 0 0 0 0]);
63
64 A = ["elt1" "elt3" "elt4"];
65 S = ["elt5" "elt1" "elt3"];
66
67 [nb, loc] = members(A, S, "last");
68 assert_checkequal(nb , [1 1 0]);
69 assert_checkequal(loc, [2 3 0]);
70 [nb, loc] = members(A, S);
71 assert_checkequal(nb , [1 1 0]);
72 assert_checkequal(loc, [2 3 0]);
73
74 A = ["elt1" "elt3" "elt4"];
75 S = ["elt5" "elt6" "elt2" "elt1" "elt3"];
76
77 [nb, loc] = members(A, S, "last");
78 assert_checkequal(nb , [1 1 0]);
79 assert_checkequal(loc, [4 5 0]);
80 [nb, loc] = members(A, S);
81 assert_checkequal(nb , [1 1 0]);
82 assert_checkequal(loc, [4 5 0]);
83
84
85 // Integers
86 A = int16([1 8 4 5 2 1]);
87 S = int16([9 7 4 2 1 4]);
88
89 [nb, loc] = members(A, S, "last");
90 assert_checkequal(nb , [1 0 2 0 1 1]);
91 assert_checkequal(loc, [5 0 6 0 4 5]);
92 [nb, loc] = members(A, S);
93 assert_checkequal(nb , [1 0 2 0 1 1]);
94 assert_checkequal(loc, [5 0 3 0 4 5]);
95
96 A = uint8([1 8 4 5 2 1]);
97 S = uint8([9 7 4 2 1 4]);
98
99 [nb, loc] = members(A, S, "last");
100 assert_checkequal(nb , [1 0 2 0 1 1]);
101 assert_checkequal(loc, [5 0 6 0 4 5]);
102 [nb, loc] = members(A, S);
103 assert_checkequal(nb , [1 0 2 0 1 1]);
104 assert_checkequal(loc, [5 0 3 0 4 5]);
105
106
107 // Complexes
108 A = [1 8 4 5 2 1]*%i;
109 S = [9 7 4 2 1 4]*%i;
110
111 [nb, loc] = members(A, S, "last");
112 assert_checkequal(nb , [1 0 2 0 1 1]);
113 assert_checkequal(loc, [5 0 6 0 4 5]);
114 [nb, loc] = members(A, S);
115 assert_checkequal(nb , [1 0 2 0 1 1]);
116 assert_checkequal(loc, [5 0 3 0 4 5]);
117
118
119 // Matrices
120 A = [ 5 0 1 4 1 ;
121       0 5 3 1 9 ;
122       2 0 1 6 1 ;
123       0 2 2 2 2 ;
124       2 0 8 1 7 ;
125       6 7 1 9 3 ];
126 S = [4 8 1 ;
127      1 0 2 ;
128      6 2 3 ;
129      2 9 4 ;
130      1 2 5 ;
131      3 0 6 ];
132 loc_ref  = [ 17 12 13 16 13 ;
133              12 17 15 13 10 ;
134              14 12 13 18 13 ;
135              12 14 14 14 14 ;
136              14 12  7 13  0 ;
137              18  0 13 10 15 ];
138 loc2_ref = [ 17  8  2  1  2 ;
139               8 17  6  2 10 ;
140               4  8  2  3  2 ;
141               8  4  4  4  4 ;
142               4  8  7  2  0 ;
143               3  0  2  10 6 ];
144 nb_ref   = [ 1 2 3 2 3 ;
145              2 1 2 3 1 ;
146              4 2 3 2 3 ;
147              2 4 4 4 4 ;
148              4 2 1 3 0 ;
149              2 0 3 1 2 ];
150
151 [nb, loc] = members(A, S, "last");
152 assert_checkequal(nb , nb_ref);
153 assert_checkequal(loc, loc_ref);
154 [nb, loc2] = members(A, S);
155 assert_checkequal(nb  , nb_ref);
156 assert_checkequal(loc2, loc2_ref);
157 assert_checktrue(loc >= loc2);
158 A_for_later = A;
159 S_for_later = S;
160 loc_ref_for_later = loc_ref;
161 loc2_ref_for_later = loc2_ref;
162 nb_ref_for_later = nb_ref;
163
164 A = A';
165 S = S';
166 loc_ref  = [ 15 17 14 17 14 18 ;
167              17 15 17 14 17  0 ;
168              13 16 13 14  2 13 ;
169              12 13 18 14 13 11 ;
170              13 11 13 14  0 16 ];
171 loc2_ref = [ 15  5  6  5  6  7 ;
172               5 15  5  6  5  0 ;
173               3  9  3  6  2  3 ;
174               1  3  7  6  3 11 ;
175               3 11  3  6  0  9 ];
176 nb_ref   = [1 2 4 2 4 2 ;
177             2 1 2 4 2 0 ;
178             3 2 3 4 1 3 ;
179             2 3 2 4 3 1 ;
180             3 1 3 4 0 2 ];
181
182 [nb, loc] = members(A, S, "last");
183 assert_checkequal(nb , nb_ref);
184 assert_checkequal(loc, loc_ref);
185 [nb, loc2] = members(A, S);
186 assert_checkequal(nb  , nb_ref);
187 assert_checkequal(loc2, loc2_ref);
188 assert_checktrue(loc >= loc2);
189
190
191 // Matrices of Integers
192 A = uint32(A);
193 S = uint32(S);
194
195 [nb, loc] = members(A, S, "last");
196 assert_checkequal(nb , nb_ref);
197 assert_checkequal(loc, loc_ref);
198 [nb, loc2] = members(A, S);
199 assert_checkequal(nb  , nb_ref);
200 assert_checkequal(loc2, loc2_ref);
201 assert_checktrue(loc >= loc2);
202
203
204 // Matrices of Strings
205 A = string(A_for_later);
206 S = string(S_for_later);
207 loc_ref  = loc_ref_for_later;
208 loc2_ref = loc2_ref_for_later;
209 nb_ref   = nb_ref_for_later;
210
211 [nb, loc] = members(A, S, "last");
212 assert_checkequal(nb , nb_ref);
213 assert_checkequal(loc, loc_ref);
214 [nb, loc2] = members(A, S);
215 assert_checkequal(nb  , nb_ref);
216 assert_checkequal(loc2, loc2_ref);
217 assert_checktrue(loc >= loc2);
218
219
220 // Matrices of Complexes
221 A = A_for_later*%i;
222 S = S_for_later*%i;
223
224 [nb, loc] = members(A, S, "last");
225 assert_checkequal(nb , nb_ref);
226 assert_checkequal(loc, loc_ref);
227 [nb, loc2] = members(A, S);
228 assert_checkequal(nb  , nb_ref);
229 assert_checkequal(loc2, loc2_ref);
230 assert_checktrue(loc >= loc2);
231
232
233 // Hypermatrices
234 A = A_for_later;
235 A(:, :, 2) = A;
236 S = S_for_later;
237 loc_ref(:, :, 2)  = loc_ref;
238 loc2_ref(:, :, 2) = loc2_ref;
239 nb_ref(:, :, 2)   = nb_ref;
240
241 [nb, loc] = members(A, S, "last");
242 assert_checkequal(nb , nb_ref);
243 assert_checkequal(loc, loc_ref);
244 [nb, loc2] = members(A, S);
245 assert_checkequal(nb  , nb_ref);
246 assert_checkequal(loc2, loc2_ref);
247 assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
248 assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
249
250
251 // Hypermatrices of Integers
252 A_int = uint32(A);
253 S_int = uint32(S);
254
255 [nb, loc] = members(A_int, S_int, "last");
256 assert_checkequal(nb , nb_ref);
257 assert_checkequal(loc, loc_ref);
258 [nb, loc2] = members(A_int, S_int);
259 assert_checkequal(nb  , nb_ref);
260 assert_checkequal(loc2, loc2_ref);
261 assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
262 assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
263
264
265 // Hypermatrices of Strings
266 A_str = string(A);
267 S_str = string(S);
268
269 [nb, loc] = members(A_str, S_str, "last");
270 assert_checkequal(nb , nb_ref);
271 assert_checkequal(loc, loc_ref);
272 [nb, loc2] = members(A_str, S_str);
273 assert_checkequal(nb  , nb_ref);
274 assert_checkequal(loc2, loc2_ref);
275 assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
276 assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
277
278
279 // Hypermatrices of Complexes
280 A_img = A.*%i;
281 S_img = S*%i;
282
283 [nb, loc] = members(A_img, S_img, "last");
284 assert_checkequal(nb , nb_ref);
285 assert_checkequal(loc, loc_ref);
286 [nb, loc2] = members(A_img, S_img);
287 assert_checkequal(nb  , nb_ref);
288 assert_checkequal(loc2, loc2_ref);
289 assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
290 assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
291
292
293 // Polynomials
294 z = %z;
295 A_pol = [z (1-z)^2 ; -4 %i*z ];
296 S_pol = [2  %i*z -z  3-z  z  z^3 z];
297 loc_ref  = [7 0 ; 0 2];
298 loc2_ref = [5 0 ; 0 2];
299 nb_ref   = [2 0 ; 0 1];
300
301 [nb, loc] = members(A_pol, S_pol, "last");
302 assert_checkequal(nb, nb_ref);
303 assert_checkequal(loc, loc_ref);
304 [nb, loc2] = members(A_pol, S_pol);
305 assert_checkequal(nb, nb_ref);
306 assert_checkequal(loc2, loc2_ref);
307 assert_checktrue(loc >= loc2);
308
309
310 // Row-wise and column-wise search
311 // With reals
312 A_cols = A_for_later;
313 S_cols = S_for_later;
314 S_cols(:, 2) = A_for_later(:, 2);
315 loc_ref = [0 2 0 0 0];
316 nb_ref  = [0 1 0 0 0];
317 [nb, loc] = members(A_cols, S_cols, "cols");
318 assert_checkequal(nb, nb_ref);
319 assert_checkequal(loc, loc_ref);
320 A_rows = A_cols';
321 S_rows = S_cols';
322 [nb, loc] = members(A_rows, S_rows, "rows");
323 assert_checkequal(nb, nb_ref);
324 assert_checkequal(loc, loc_ref);
325 // With integers
326 A_cols = int16(A_cols);
327 S_cols = int16(S_cols);
328 [nb, loc] = members(A_cols, S_cols, "cols");
329 assert_checkequal(nb, nb_ref);
330 assert_checkequal(loc, loc_ref);
331 A_rows = A_cols';
332 S_rows = S_cols';
333 [nb, loc] = members(A_rows, S_rows, "rows");
334 assert_checkequal(nb, nb_ref);
335 assert_checkequal(loc, loc_ref);
336 // With strings
337 A_cols = string(A_cols);
338 S_cols = string(S_cols);
339 [nb, loc] = members(A_cols, S_cols, "cols");
340 assert_checkequal(nb, nb_ref);
341 assert_checkequal(loc, loc_ref);
342 A_rows = A_cols';
343 S_rows = S_cols';
344 [nb, loc] = members(A_rows, S_rows, "rows");
345 assert_checkequal(nb, nb_ref);
346 assert_checkequal(loc, loc_ref);
347
348
349 // Shuffle option
350 // With reals
351 A_cols = A_for_later;
352 S_cols = S_for_later;
353 S_cols(:, 2) = A_for_later(:, 2);
354 temp = S_cols(1, 2); S_cols(1, 2) = S_cols(6, 2); S_cols(6, 2) = temp; // Switching two elements of S
355 S_cols = [S_cols S_cols(:, 2)]; // To get two column occurrences of A in S, for "later" to be relevant
356 loc_ref  = [0 2 0 0 0];
357 loc2_ref = [0 4 0 0 0];
358 nb_ref   = [0 2 0 0 0];
359 [nb, loc] = members(A_cols, S_cols, "cols", "shuffle");
360 assert_checkequal(nb, nb_ref);
361 assert_checkequal(loc, loc_ref);
362 [nb, loc2] = members(A_cols, S_cols, "cols", "shuffle", "last");
363 assert_checkequal(nb, nb_ref);
364 assert_checkequal(loc2, loc2_ref);
365 A_rows = A_cols';
366 S_rows = S_cols';
367 [nb, loc] = members(A_rows, S_rows, "rows", "shuffle");
368 assert_checkequal(nb, nb_ref);
369 assert_checkequal(loc, loc_ref);
370 [nb, loc2] = members(A_rows, S_rows, "rows", "shuffle", "last");
371 assert_checkequal(nb, nb_ref);
372 assert_checkequal(loc2, loc2_ref);
373 // With integers
374 A_cols = int16(A_cols);
375 S_cols = int16(S_cols);
376 [nb, loc] = members(A_cols, S_cols, "cols", "shuffle");
377 assert_checkequal(nb, nb_ref);
378 assert_checkequal(loc, loc_ref);
379 [nb, loc2] = members(A_cols, S_cols, "cols", "shuffle", "last");
380 assert_checkequal(nb, nb_ref);
381 assert_checkequal(loc2, loc2_ref);
382 A_rows = A_cols';
383 S_rows = S_cols';
384 [nb, loc] = members(A_rows, S_rows, "rows", "shuffle");
385 assert_checkequal(nb, nb_ref);
386 assert_checkequal(loc, loc_ref);
387 [nb, loc2] = members(A_rows, S_rows, "rows", "shuffle", "last");
388 assert_checkequal(nb, nb_ref);
389 assert_checkequal(loc2, loc2_ref);
390 // With strings
391 A_cols = string(A_cols);
392 S_cols = string(S_cols);
393 [nb, loc] = members(A_cols, S_cols, "cols", "shuffle");
394 assert_checkequal(nb, nb_ref);
395 assert_checkequal(loc, loc_ref);
396 [nb, loc2] = members(A_cols, S_cols, "cols", "shuffle", "last");
397 assert_checkequal(nb, nb_ref);
398 assert_checkequal(loc2, loc2_ref);
399 A_rows = A_cols';
400 S_rows = S_cols';
401 [nb, loc] = members(A_rows, S_rows, "rows", "shuffle");
402 assert_checkequal(nb, nb_ref);
403 assert_checkequal(loc, loc_ref);
404 [nb, loc2] = members(A_rows, S_rows, "rows", "shuffle", "last");
405 assert_checkequal(nb, nb_ref);
406 assert_checkequal(loc2, loc2_ref);
407
408
409
410 // IEEE
411 // Normal mode
412 A = [ 0 0 1 1 1 ;
413       0 2 2 2 %nan ;
414       2 0 1 1 1 ;
415       0 0 1 %inf -%inf];
416 S = [1 0 1 ;
417      2 0 4 ;
418      1 2 5 ;
419   %inf -%inf 6];
420 loc_ieee_ref  = [6 6 9 9 9 ;
421                  6 7 7 7 0 ;
422                  7 6 9 9 9 ;
423                  6 6 9 4 8 ];
424 loc2_ieee_ref = [5 5 1 1 1 ;
425                  5 2 2 2 0 ;
426                  2 5 1 1 1 ;
427                  5 5 1 4 8 ];
428 nb_ieee_ref   = [2 2 3 3 3 ;
429                  2 2 2 2 0 ;
430                  2 2 3 3 3 ;
431                  2 2 3 1 1 ];
432
433 [nb, loc] = members(A, S, "last");
434 assert_checkequal(nb , nb_ieee_ref);
435 assert_checkequal(loc, loc_ieee_ref);
436 [nb, loc2] = members(A, S);
437 assert_checkequal(nb  , nb_ieee_ref);
438 assert_checkequal(loc2, loc2_ieee_ref);
439 assert_checktrue(loc >= loc2);
440
441
442 // Row-wise and column-wise modes
443 A_cols(:, 1) = "%nan";      // Introducing a %nan column
444 A_cols(1, 2) = "%inf";      // Adding some %inf elements
445 A_cols(2, 2) = "-%inf";
446 S_cols(:, 1) = "%nan";      // Introducing a %nan column
447 S_cols(1, [2 4]) = "%inf";  // Adding the same %inf elements to S
448 S_cols(2, [2 4]) = "-%inf";
449 S_cols(3, [2 4]) = "7";     // Adjusting, for shuffle option
450 A_rows(1, :) = "%nan";      // Same operations, by rows
451 A_rows(2, 1) = "%inf";
452 A_rows(2, 2) = "-%inf";
453 S_rows(1, :) = "%nan";
454 S_rows([2 4], 1) = "%inf";
455 S_rows([2 4], 2) = "-%inf";
456 S_rows([2 4], 3) = "7";
457 loc_ref(1) = 1; // %nan columns are common to A and S, in first position
458 nb_ref(1)  = 1;
459
460 [nb, loc] = members(A_cols, S_cols, "cols", "shuffle");
461 assert_checkequal(nb , nb_ref);
462 assert_checkequal(loc, loc_ref);
463 [nb, loc] = members(A_rows, S_rows, "rows", "shuffle");
464 assert_checkequal(nb , nb_ref);
465 assert_checkequal(loc, loc_ref);
466
467
468
469 // =============================================================================
470
471
472
473 // Error checks
474 A = [1 2 3; 4 5 6];
475 refMsg = msprintf(_("%s: Wrong number of input argument(s): at least %d expected.\n"), "members", 2);
476 assert_checkerror("[nb, loc] = members(A);", refMsg);
477 S = string(A);
478 refMsg = msprintf(_("%s: Wrong type for input argument #%d: expected same type as first argument.\n"), "members", 2);
479 assert_checkerror("[nb, loc] = members(A, S, ""last"");", refMsg);
480 S = int16(A);
481 assert_checkerror("[nb, loc] = members(A, S, ""last"");", refMsg);
482 S = uint8(A);
483 assert_checkerror("[nb, loc] = members(A, S);", refMsg);
484 S = [7 8 9; 10 %nan 12];
485 refMsg = msprintf(_("%s: Wrong value for argument #%d: Must not contain NaN.\n"), "members", 2);
486 assert_checkerror("[nb, loc] = members(A, S);", refMsg);
487 A = rand(2, 3, 2);
488 S = [7 8; 10 11];
489 refMsg = msprintf(_("%s: Wrong type for argument #%d: Matrix expected.\n"), "members", 1);
490 assert_checkerror("[nb, loc] = members(A, S, ""rows"");", refMsg);
491 A = [1 2 3; 4 5 6; 7 8 9];
492 S = rand(2, 3, 2);
493 refMsg = msprintf(_("%s: Wrong type for argument #%d: Matrix expected.\n"), "members", 2);
494 assert_checkerror("[nb, loc] = members(A, S, ""rows"");", refMsg);
495 S = [7 8; 10 11];
496 refMsg = msprintf(_("%s: Incompatible input arguments #%d and #%d: Same number of columns expected.\n"), "members", 1, 2);
497 assert_checkerror("[nb, loc] = members(A, S, ""rows"");", refMsg);
498 refMsg = msprintf(_("%s: Incompatible input arguments #%d and #%d: Same number of rows expected.\n"), "members", 1, 2);
499 assert_checkerror("[nb, loc] = members(A, S, ""cols"");", refMsg);