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