* Bug #12705 fixed - Elementary_functions & m2sci: members() function
[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 // <-- ENGLISH IMPOSED -->
10
11
12 // Vectors
13 [nb, loc] = members([], [], %t);
14 assert_checkequal(nb , []);
15 assert_checkequal(loc, []);
16 [nb, loc] = members([], [], %f);
17 assert_checkequal(nb , []);
18 assert_checkequal(loc, []);
19
20 [nb, loc] = members([1 2], [3 4], %t);
21 assert_checkequal(nb , [0 0]);
22 assert_checkequal(loc, [0 0]);
23 [nb, loc] = members([1 2], [3 4], %f);
24 assert_checkequal(nb , [0 0]);
25 assert_checkequal(loc, [0 0]);
26
27 [nb, loc] = members([1 2; 3 4], [5 6; 7 8], %t);
28 assert_checkequal(nb , [0 0; 0 0]);
29 assert_checkequal(loc, [0 0; 0 0]);
30 [nb, loc] = members([1 2; 3 4], [5 6; 7 8], %f);
31 assert_checkequal(nb , [0 0; 0 0]);
32 assert_checkequal(loc, [0 0; 0 0]);
33
34 [nb, loc] = members(string([1 2; 3 4]), string([5 6; 7 8]), %t);
35 assert_checkequal(nb , [0 0; 0 0]);
36 assert_checkequal(loc, [0 0; 0 0]);
37 [nb, loc] = members(string([1 2; 3 4]), string([5 6; 7 8]), %f);
38 assert_checkequal(nb , [0 0; 0 0]);
39 assert_checkequal(loc, [0 0; 0 0]);
40
41 A = [1 8 4 5 2 1];
42 S = [9 7 4 2 1 4];
43
44 [nb, loc] = members(A, S, %t);
45 assert_checkequal(nb , [1 0 2 0 1 1]);
46 assert_checkequal(loc, [5 0 6 0 4 5]);
47 [nb, loc] = members(A, S, %f);
48 assert_checkequal(nb , [1 0 2 0 1 1]);
49 assert_checkequal(loc, [5 0 3 0 4 5]);
50
51
52 // Strings
53 A = 'a'+string(A);
54 S = 's'+string(S);
55
56 [nb, loc] = members(A, S, %t);
57 assert_checkequal(nb , [0 0 0 0 0 0]);
58 assert_checkequal(loc, [0 0 0 0 0 0]);
59 [nb, loc] = members(A, S, %f);
60 assert_checkequal(nb , [0 0 0 0 0 0]);
61 assert_checkequal(loc, [0 0 0 0 0 0]);
62
63 A = ["elt1" "elt3" "elt4"];
64 S = ["elt5" "elt1" "elt3"];
65
66 [nb, loc] = members(A, S, %t);
67 assert_checkequal(nb , [1 1 0]);
68 assert_checkequal(loc, [2 3 0]);
69 [nb, loc] = members(A, S, %f);
70 assert_checkequal(nb , [1 1 0]);
71 assert_checkequal(loc, [2 3 0]);
72
73 A = ["elt1" "elt3" "elt4"];
74 S = ["elt5" "elt6" "elt2" "elt1" "elt3"];
75
76 [nb, loc] = members(A, S, %t);
77 assert_checkequal(nb , [1 1 0]);
78 assert_checkequal(loc, [4 5 0]);
79 [nb, loc] = members(A, S, %f);
80 assert_checkequal(nb , [1 1 0]);
81 assert_checkequal(loc, [4 5 0]);
82
83
84 // Integers
85 A = int16([1 8 4 5 2 1]);
86 S = int16([9 7 4 2 1 4]);
87
88 [nb, loc] = members(A, S, %t);
89 assert_checkequal(nb , [1 0 2 0 1 1]);
90 assert_checkequal(loc, [5 0 6 0 4 5]);
91 [nb, loc] = members(A, S, %f);
92 assert_checkequal(nb , [1 0 2 0 1 1]);
93 assert_checkequal(loc, [5 0 3 0 4 5]);
94
95 A = uint8([1 8 4 5 2 1]);
96 S = uint8([9 7 4 2 1 4]);
97
98 [nb, loc] = members(A, S, %t);
99 assert_checkequal(nb , [1 0 2 0 1 1]);
100 assert_checkequal(loc, [5 0 6 0 4 5]);
101 [nb, loc] = members(A, S, %f);
102 assert_checkequal(nb , [1 0 2 0 1 1]);
103 assert_checkequal(loc, [5 0 3 0 4 5]);
104
105
106 // Complexes
107 A = [1 8 4 5 2 1]*%i;
108 S = [9 7 4 2 1 4]*%i;
109
110 [nb, loc] = members(A, S, %t);
111 assert_checkequal(nb , [1 0 2 0 1 1]);
112 assert_checkequal(loc, [5 0 6 0 4 5]);
113 [nb, loc] = members(A, S, %f);
114 assert_checkequal(nb , [1 0 2 0 1 1]);
115 assert_checkequal(loc, [5 0 3 0 4 5]);
116
117
118 // Matrices
119 A = [ 5 0 1 4 1 ;
120       0 5 3 1 9 ;
121       2 0 1 6 1 ;
122       0 2 2 2 2 ;
123       2 0 8 1 7 ;
124       6 7 1 9 3 ];
125 S = [4 8 1 ;
126      1 0 2 ;
127      6 2 3 ;
128      2 9 4 ;
129      1 2 5 ;
130      3 0 6 ];
131 loc_ref  = [ 17 12 13 16 13 ;
132              12 17 15 13 10 ;
133              14 12 13 18 13 ;
134              12 14 14 14 14 ;
135              14 12  7 13  0 ;
136              18  0 13 10 15 ];
137 loc2_ref = [ 17  8  2  1  2 ;
138               8 17  6  2 10 ;
139               4  8  2  3  2 ;
140               8  4  4  4  4 ;
141               4  8  7  2  0 ;
142               3  0  2  10 6 ];
143 nb_ref   = [ 1 2 3 2 3 ;
144              2 1 2 3 1 ;
145              4 2 3 2 3 ;
146              2 4 4 4 4 ;
147              4 2 1 3 0 ;
148              2 0 3 1 2 ];
149
150 [nb, loc] = members(A, S, %t);
151 assert_checkequal(nb , nb_ref);
152 assert_checkequal(loc, loc_ref);
153 [nb, loc2] = members(A, S, %f);
154 assert_checkequal(nb  , nb_ref);
155 assert_checkequal(loc2, loc2_ref);
156 assert_checktrue(loc >= loc2);
157 A_for_later = A;
158 S_for_later = S;
159 loc_ref_for_later = loc_ref;
160 loc2_ref_for_later = loc2_ref;
161 nb_ref_for_later = nb_ref;
162
163 A = A';
164 S = S';
165 loc_ref  = [ 15 17 14 17 14 18 ;
166              17 15 17 14 17  0 ;
167              13 16 13 14  2 13 ;
168              12 13 18 14 13 11 ;
169              13 11 13 14  0 16 ];
170 loc2_ref = [ 15  5  6  5  6  7 ;
171               5 15  5  6  5  0 ;
172               3  9  3  6  2  3 ;
173               1  3  7  6  3 11 ;
174               3 11  3  6  0  9 ];
175 nb_ref   = [1 2 4 2 4 2 ;
176             2 1 2 4 2 0 ;
177             3 2 3 4 1 3 ;
178             2 3 2 4 3 1 ;
179             3 1 3 4 0 2 ];
180
181 [nb, loc] = members(A, S, %t);
182 assert_checkequal(nb , nb_ref);
183 assert_checkequal(loc, loc_ref);
184 [nb, loc2] = members(A, S, %f);
185 assert_checkequal(nb  , nb_ref);
186 assert_checkequal(loc2, loc2_ref);
187 assert_checktrue(loc >= loc2);
188
189
190 // Matrices of Integers
191 A = uint32(A);
192 S = uint32(S);
193
194 [nb, loc] = members(A, S, %t);
195 assert_checkequal(nb , nb_ref);
196 assert_checkequal(loc, loc_ref);
197 [nb, loc2] = members(A, S, %f);
198 assert_checkequal(nb  , nb_ref);
199 assert_checkequal(loc2, loc2_ref);
200 assert_checktrue(loc >= loc2);
201
202
203 // Matrices of Strings
204 A = string(A_for_later);
205 S = string(S_for_later);
206 loc_ref  = loc_ref_for_later;
207 loc2_ref = loc2_ref_for_later;
208 nb_ref   = nb_ref_for_later;
209
210 [nb, loc] = members(A, S, %t);
211 assert_checkequal(nb , nb_ref);
212 assert_checkequal(loc, loc_ref);
213 [nb, loc2] = members(A, S, %f);
214 assert_checkequal(nb  , nb_ref);
215 assert_checkequal(loc2, loc2_ref);
216 assert_checktrue(loc >= loc2);
217
218
219 // Matrices of Complexes
220 A = A_for_later*%i;
221 S = S_for_later*%i;
222
223 [nb, loc] = members(A, S, %t);
224 assert_checkequal(nb , nb_ref);
225 assert_checkequal(loc, loc_ref);
226 [nb, loc2] = members(A, S, %f);
227 assert_checkequal(nb  , nb_ref);
228 assert_checkequal(loc2, loc2_ref);
229 assert_checktrue(loc >= loc2);
230
231
232 // Hypermatrices
233 A = A_for_later;
234 A(:, :, 2) = A;
235 S = S_for_later;
236 loc_ref(:, :, 2)  = loc_ref;
237 loc2_ref(:, :, 2) = loc2_ref;
238 nb_ref(:, :, 2)   = nb_ref;
239
240 [nb, loc] = members(A, S, %t);
241 assert_checkequal(nb , nb_ref);
242 assert_checkequal(loc, loc_ref);
243 [nb, loc2] = members(A, S, %f);
244 assert_checkequal(nb  , nb_ref);
245 assert_checkequal(loc2, loc2_ref);
246 assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
247 assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
248
249
250 // Hypermatrices of Integers
251 A_int = uint32(A);
252 S_int = uint32(S);
253
254 [nb, loc] = members(A_int, S_int, %t);
255 assert_checkequal(nb , nb_ref);
256 assert_checkequal(loc, loc_ref);
257 [nb, loc2] = members(A_int, S_int, %f);
258 assert_checkequal(nb  , nb_ref);
259 assert_checkequal(loc2, loc2_ref);
260 assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
261 assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
262
263
264 // Hypermatrices of Strings
265 A_str = string(A);
266 S_str = string(S);
267
268 [nb, loc] = members(A_str, S_str, %t);
269 assert_checkequal(nb , nb_ref);
270 assert_checkequal(loc, loc_ref);
271 [nb, loc2] = members(A_str, S_str, %f);
272 assert_checkequal(nb  , nb_ref);
273 assert_checkequal(loc2, loc2_ref);
274 assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
275 assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
276
277
278 // Hypermatrices of Complexes
279 A_img = A.*%i;
280 S_img = S*%i;
281
282 [nb, loc] = members(A_img, S_img, %t);
283 assert_checkequal(nb , nb_ref);
284 assert_checkequal(loc, loc_ref);
285 [nb, loc2] = members(A_img, S_img, %f);
286 assert_checkequal(nb  , nb_ref);
287 assert_checkequal(loc2, loc2_ref);
288 assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
289 assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
290
291
292 // Polynomials
293 z = %z;
294 A = [z (1-z)^2 ; -4 %i*z ];
295 S = [2  %i*z -z  3-z  z  z^3 z];
296 loc_ref  = [7 0 ; 0 2];
297 loc2_ref = [5 0 ; 0 2];
298 nb_ref   = [2 0 ; 0 1];
299
300 [nb, loc] = members(A, S, %t);
301 assert_checkequal(nb, nb_ref);
302 assert_checkequal(loc, loc_ref);
303 [nb, loc2] = members(A, S, %f);
304 assert_checkequal(nb, nb_ref);
305 assert_checkequal(loc2, loc2_ref);
306 assert_checktrue(loc >= loc2);
307
308
309 // IEEE
310 A = [ 0 0 1 1 1 ;
311       0 2 2 2 %nan ;
312       2 0 1 1 1 ;
313       0 0 1 %inf -%inf];
314 S = [1 0 1 ;
315      2 0 4 ;
316      1 2 5 ;
317   %inf -%inf 6];
318 loc_ref  = [6 6 9 9 9 ;
319             6 7 7 7 0 ;
320             7 6 9 9 9 ;
321             6 6 9 4 8 ];
322 loc2_ref = [5 5 1 1 1 ;
323             5 2 2 2 0 ;
324             2 5 1 1 1 ;
325             5 5 1 4 8 ];
326 nb_ref   = [2 2 3 3 3 ;
327             2 2 2 2 0 ;
328             2 2 3 3 3 ;
329             2 2 3 1 1 ];
330
331 [nb, loc] = members(A, S, %t);
332 assert_checkequal(nb , nb_ref);
333 assert_checkequal(loc, loc_ref);
334 [nb, loc2] = members(A, S, %f);
335 assert_checkequal(nb  , nb_ref);
336 assert_checkequal(loc2, loc2_ref);
337 assert_checktrue(loc >= loc2);
338
339
340 // =============================================================================
341
342
343 // Error checks
344 A = [1 2 3; 4 5 6];
345 refMsg = msprintf(_("%s: Wrong number of input argument(s): at least %d expected.\n"), "members", 2);
346 assert_checkerror("[nb, loc] = members(A);", refMsg);
347 S = string(A);
348 refMsg = msprintf(_("%s: Wrong type for input argument #%d: expected same type as first argument.\n"), "members", 2);
349 assert_checkerror("[nb, loc] = members(A, S, %t);", refMsg);
350 S = int16(A);
351 assert_checkerror("[nb, loc] = members(A, S, %t);", refMsg);
352 S = uint8(A);
353 assert_checkerror("[nb, loc] = members(A, S, %f);", refMsg);
354 S = [7 8 9; 10 %nan 12];
355 refMsg = msprintf(_("%s: Wrong value for argument #%d: Must not contain NaN.\n"), "members", 2);
356 assert_checkerror("[nb, loc] = members(A, S);", refMsg);
357 S = [7 8 9; 10 11 12];
358 last = 1;
359 refMsg = msprintf(_("%s: Wrong type for input argument #%d: Boolean matrix expected.\n"), "members", 3);
360 assert_checkerror("[nb, loc] = members(A, S, last);", refMsg);
361 last = "yes";
362 refMsg = msprintf(_("%s: Wrong type for input argument #%d: Boolean matrix expected.\n"), "members", 3);
363 assert_checkerror("[nb, loc] = members(A, S, last);", refMsg);
364 last = [%t %f];
365 refMsg = msprintf(_("%s: Wrong size for input argument #%d: Scalar expected.\n"), "members", 3);
366 assert_checkerror("[nb, loc] = members(A, S, last);", refMsg);