fd97aea9a2c03b64fe43186d5ae0fb478d40f435
[scilab.git] / scilab / modules / elementary_functions / tests / unit_tests / gsort.tst
1 // =============================================================================
2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 // Copyright (C) ????-2008 - INRIA
4 // Copyright (C) ????-2008 - ENPC
5 // Copyright (C) 2008 - DIGITEO - Allan CORNET
6 // Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
7 // Copyright (C) 2018 - Samuel GOUGEON
8 //
9 //  This file is distributed under the same license as the Scilab package.
10 // =============================================================================
11
12 // <-- CLI SHELL MODE -->
13 // <-- NO CHECK REF -->
14
15 //================================ complex arrays ==============================
16
17 // Tests in gsort_complex.tst
18
19 //================================ sparse vectors ==============================
20
21 // Tests in gsort_sparse.tst
22
23 //================================ Matrix of string case =======================
24 N = 4;
25 P = 20;
26 a = int(10*rand(N,P,"u"));
27
28 //-----Global sort
29
30 [a1,ind] = gsort(string(a),"g");
31 [a2,ind2] = gsort(a,"g");
32 assert_checkalmostequal(norm(evstr(a1)- matrix(a(ind),N,P)), %eps, [], %eps);
33
34 // a or string(a) are in the same order in the previous example
35 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
36
37 //-- rows
38 [a1,ind1]=gsort(string(a),"r");
39 [a2,ind2]=gsort(a,"r");
40 assert_checkalmostequal(norm(ind1-ind2), %eps, [], %eps);
41
42 // a or string(a) are in the same order in the previous example
43 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
44
45
46 //--columns
47 [a1,ind1] = gsort(string(a),"c");
48 [a2,ind2] = gsort(a,"c");
49 assert_checkalmostequal(norm(ind1-ind2), %eps, [], %eps);
50
51 // a or string(a) are in the same order in the previous example
52 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
53
54 //----sort the rows of a in lexicographic order
55
56 N1 = 4;P1 = 3;
57 alr = [1,2,2;
58 1,2,1;
59 1,1,2;
60 1,1,1];
61 // a random permutation
62 [ax,perm] = gsort(rand(1,N1,"u"));
63 a = alr(perm,:);
64 [a1,ind] = gsort(string(a),"lr");
65 [a2,ind] = gsort(a,"lr") ;
66
67 assert_checkalmostequal(norm(evstr(a1)- matrix(a(ind,:),N1,P1)), %eps, [], %eps);
68
69 // a or string(a) are in the same order in the previous example
70 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
71
72
73 //----sort the columns of a in lexicographic order
74 N1 = 3;P1 = 4;
75 alr = alr';
76 // a random permutation
77 [ax,perm] = gsort(rand(1,P1,"u"));
78 a = alr(:,perm);
79
80 [a1,ind] = gsort(string(a),"lc");
81 [a2,ind] = gsort(a,"lc") ;
82
83 assert_checkalmostequal(norm(evstr(a1)- matrix(a(:,ind),N1,P1)), %eps, [], %eps);
84
85 // a or string(a) are in the same order in the previous example
86 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
87
88 //================================ Matrix of double case =======================
89 N = 4;P = 20;Nrand = 100;
90
91 a = matrix(grand(1,"prm",(1:N*P)'),N,P);
92
93 //-----Global sort --------------------------------
94
95 [a1,ind]=gsort(a,"g");
96 assert_checkalmostequal(norm(a1- matrix(N*P:-1:1,N,P)), %eps, [], %eps);
97 assert_checkalmostequal(norm(a1- matrix(a(ind),N,P)), %eps, [], %eps);
98
99 for i=1:Nrand
100     b = int(10*rand(N,P,"u"));
101     [b1,ind] = gsort(b,"g");
102     assert_checkalmostequal(norm(b1- matrix(b(ind),N,P)), %eps, [], %eps);
103     assert_checktrue(or(b1(1:$-1)-b1(2:$) >= 0));
104 end
105
106 //increasing values
107
108 [a1,ind] = gsort(a,"g","i");
109 assert_checkalmostequal(norm(a1- matrix(1:N*P,N,P)), %eps, [], %eps);
110 assert_checkalmostequal(norm(a1- matrix(a(ind),N,P)), %eps, [], %eps);
111
112 for i=1:100
113     b = int(10*rand(N,P,"u"));
114     [b1,ind] = gsort(b,"g","i");
115     assert_checkalmostequal(norm(b1- matrix(b(ind),N,P)), %eps, [], %eps);
116     assert_checktrue(or(b1(1:$-1)-b1(2:$) <= 0));
117 end
118
119 //----sort each column of a ('r' means that the row indice is used for sorting)
120
121 [a1,ind] = gsort(a,"r");
122 nc = size(a,"c");
123 test = [];
124 for i = 1:nc;
125     test = [test, matrix(a(ind(:,i),i),N,1)];
126 end
127 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
128
129 test = [];
130 for i = 1:nc;
131     test = [test, gsort(a(:,i),"g")];
132 end
133 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
134
135 for i = 1:Nrand
136     b = int(10*rand(N,P,"u"));
137     [b1,ind] = gsort(b,"r");
138     assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
139     test = [];
140     for j = 1:nc
141         test = [test, matrix(b(ind(:,j),j),N,1)];
142     end
143     assert_checkalmostequal(norm(b1- test), %eps, [], %eps);
144 end
145
146 //increasing values
147
148 [a1,ind] = gsort(a,"r","i");
149 nc = size(a,"c");
150 test = [];
151 for i = 1:nc
152     test = [test, matrix(a(ind(:,i),i),N,1)];
153 end
154 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
155
156 test = [];
157 for i = 1:nc
158     test = [test, gsort(a(:,i),"g","i")];
159 end
160 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
161
162 //----sort each row of a ('c' means that the column indice is used for sorting)
163 [a1,ind] = gsort(a,"c");
164 nr = size(a,"r");
165 test = [];
166 for i = 1:nr
167     test = [test; matrix(a(i,ind(i,:)),1,P)];
168 end
169 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
170
171 test = [];
172 for i = 1:nr
173     test = [test; gsort(a(i,:),"g")];
174 end
175 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
176
177 for i = 1:Nrand
178     b = int(10*rand(N,P,"u"));
179     [b1,ind] = gsort(b,"c");
180     assert_checkequal(or(b1(:,2:$) - b1(:,1:$-1) > 0), %f);
181     test = [];
182     for j = 1:nr
183         test = [test; b(j,ind(j,:))];
184     end
185     assert_checkalmostequal(norm(b1- test), %eps, [], %eps);
186 end
187
188 //increasing
189 [a1,ind] = gsort(a,"c","i");
190 nr = size(a,"r");
191 test = [];
192 for i = 1:nr
193     test = [test; matrix(a(i,ind(i,:)),1,P)];
194 end
195 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
196
197 test = [];
198 for i = 1:nr
199     test = [test; gsort(a(i,:),"g","i")];
200 end
201 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
202
203
204 //----sort the rows of a in lexicographic order
205 //    i.e a(k,:) < a(l,:) if there's a number j
206 //    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
207 //
208 vmax = 4;
209 N1 = 4;P1 = 3;
210 alr = [1,2,2;
211 1,2,1;
212 1,1,2;
213 1,1,1];
214 // a random permutation
215 [ax,perm] = gsort(rand(1, N1, "u"));
216 a = alr(perm,:);
217
218 [a1,ind] = gsort(a,"lr");
219 assert_checkalmostequal(norm(a1 - alr), %eps, [], %eps);
220 assert_checkalmostequal(norm(a1 - matrix(a(ind,:),N1,P1)), %eps, [], %eps);
221
222 [a2,ind2] = gsort(a*[100;10;1],"g");
223 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
224
225 for i = 1:Nrand
226     b = int(vmax * rand(N,P,"u"));
227     [b1,ind] = gsort(b,"lr");
228     assert_checkalmostequal(norm(b1 - b(ind,:)), %eps, [], %eps);
229     v = b1 * ((vmax + 1) ^ [P - 1 : -1 : 0])';
230
231     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
232 end
233
234 // increasing
235 [a1,ind] = gsort(a,"lr","i");
236 assert_checkalmostequal(norm(a1 - alr(N1:-1:1,:)), %eps, [], %eps);
237 assert_checkalmostequal(norm(a1 - matrix(a(ind,:),N1,P1)), %eps, [], %eps);
238
239 [a2,ind2] = gsort(a * [100;10;1],"g","i");
240 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
241
242 for i = 1:Nrand
243     b = int(vmax * rand(N,P,"u"));
244     [b1,ind] = gsort(b,"lr","i");
245     assert_checkalmostequal(norm(b1 - b(ind,:)), %eps, [], %eps);
246     v= b1*((vmax+1)^[P-1:-1:0])';
247     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
248 end
249
250 //----sort the columns of a in lexicographic order
251 N1 = 3;P1 = 4;
252 alr = alr';
253 // a random permutation
254 [ax,perm] = gsort(rand(1,P1,"u"));
255 a = alr(:,perm);
256
257 [a1,ind] = gsort(a,"lc");
258 assert_checkalmostequal(norm(a1 - alr), %eps, [], %eps);
259 assert_checkalmostequal(norm(a1- matrix(a(:,ind),N1,P1)), %eps, [], %eps);
260
261 [a2,ind2] = gsort([100,10,1]*a,"g");
262 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
263
264 for i = 1:Nrand
265     b = int(vmax * rand(N1,P1,"u"));
266     [b1,ind] = gsort(b,"lc");
267     assert_checkalmostequal(norm(b1 - b(:,ind)), %eps, [], %eps);
268     v = ((vmax+1)^[N1-1:-1:0])*b1;
269     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
270 end
271
272 //increasing
273 [a1,ind] = gsort(a,"lc","i");
274
275 assert_checkalmostequal(norm(a1 - alr(:,P1:-1:1)), %eps, [], %eps);
276 assert_checkalmostequal(norm(a1 - matrix(a(:,ind),N1,P1)), %eps, [], %eps);
277
278 [a2,ind2] = gsort([100,10,1]*a,"g","i");
279 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
280
281 for i = 1:Nrand
282     b = int(vmax * rand(N,P,"u"));
283     [b1,ind] = gsort(b,"lc","i");
284     assert_checkalmostequal(norm(b1 - b(:,ind)), %eps, [], %eps);
285     v = ((vmax+1)^[N-1:-1:0])*b1;
286     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
287 end
288
289 a = [1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
290 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
291 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
292 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
293 16,19,19,19,18,19]';
294 [b,ind] = gsort(a,"lr","i");
295 t = b(2:$,:) - b(1:$-1,:);
296 assert_checktrue(or(t(:,1) >= 0));
297 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
298 assert_checkequal(a(ind,:), b);
299
300 for k = 1:30
301     p = grand(1,"prm",(1:size(a,1))');
302     [b,ind] = gsort(a(p,:),"lr","i");
303     t = b(2:$,:) - b(1:$-1,:);
304     assert_checktrue(or(t(:,1) >= 0));
305     assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
306     assert_checkequal(a(p(ind),:), b);
307 end
308
309 [b,ind] = gsort(a,"lr","d");
310 t = b(1:$-1,:) - b(2:$,:);
311 assert_checktrue(or(t(:,1) >= 0));
312 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
313 assert_checkequal(a(ind,:), b);
314
315 for k = 1:30
316     p = grand(1,"prm",(1:size(a,1))');
317     [b,ind] = gsort(a(p,:),"lr","d");
318     t = b(1:$-1,:) - b(2:$,:);
319     assert_checktrue(or(t(:,1) >= 0));
320     assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
321     assert_checkequal(a(p(ind),:), b);
322 end
323
324 a = b;
325 a([10 60],:) = a([60 10],:);
326 [b,ind] = gsort(a,"lr","i");
327 t = b(2:$,:) - b(1:$-1,:);
328 assert_checktrue(or(t(:,1) >= 0));
329 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
330 assert_checkequal(a(ind,:), b);
331
332 [b,ind] = gsort(a,"lr","d");
333 t = b(1:$-1,:) - b(2:$,:);
334 assert_checktrue(or(t(:,1) >= 0));
335 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
336 assert_checkequal(a(ind,:), b);
337
338 //======================== Matrix of encoded integers ==========================
339 N = 4;
340 P = 20;
341 Nrand = 100;
342 vmax = 4;
343 for itype = [1 2 4 8 11 12 14 18]
344     a = iconvert(matrix(grand(1,"prm",(1:N*P)'),N,P), itype);
345
346     //-----Global sort --------------------------------
347     [a1,ind] = gsort(a,"g");
348     assert_checkequal(a1, iconvert(matrix(N * P:-1:1,N,P), itype));
349     assert_checkequal(a1, matrix(a(ind),N,P));
350
351     for i = 1:Nrand
352         b = iconvert(10 * rand(N,P,"u"), itype);
353         [b1,ind] = gsort(b,"g");
354         assert_checkequal(b1, matrix(b(ind),N,P));
355         assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
356     end
357
358     //increasing values
359     [a1,ind] = gsort(a,"g","i");
360     assert_checkequal(a1, iconvert(matrix(1:N*P,N,P), itype));
361     assert_checkequal(a1, matrix(a(ind),N,P));
362
363     for i = 1:100
364         b = iconvert(10*rand(N,P,"u"), itype);
365         [b1,ind]=gsort(b,"g","i");
366         assert_checkequal(b1, matrix(b(ind),N,P));
367         assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
368     end
369
370     //----sort each column of a ('r' means that the row indice is used for sorting)
371     [a1,ind] = gsort(a,"r");
372     nc = size(a,"c");
373     test = [];
374     for i = 1:nc
375         test = [test, matrix(a(ind(:,i),i),N,1)];
376     end
377     assert_checkequal(a1, test);
378
379     test = [];
380     for i =1:nc
381         test = [test, gsort(a(:,i),"g")];
382     end
383     assert_checkequal(a1, test);
384
385     if itype < 10
386         for i = 1:Nrand
387             b = iconvert(10*rand(N,P,"u"), itype);
388             [b1,ind] = gsort(b,"r");
389             assert_checkfalse(or(b1(2:$,:) - b1(1:$-1,:) > 0));
390             test = [];
391             for j = 1:nc
392                 test = [test, matrix(b(ind(:,j),j),N,1)];
393             end
394             assert_checkequal(b1, test);
395         end
396     end
397
398     //increasing values
399     [a1,ind] = gsort(a,"r","i");
400     nc = size(a,"c");
401     test = [];
402     for i = 1:nc
403         test = [test, matrix(a(ind(:,i),i),N,1)];
404     end
405     assert_checkequal(a1, test);
406
407     test = [];
408     for i = 1:nc
409         test = [test, gsort(a(:,i),"g","i")];
410     end
411     assert_checkequal(a1, test);
412
413     //----sort each row of a ('c' means that the column indice is used for sorting)
414     [a1,ind] = gsort(a,"c");
415     nr = size(a,"r");
416     test = [];
417     for i = 1:nr
418         test = [test; matrix(a(i,ind(i,:)),1,P)];
419     end
420     assert_checkequal(a1, test);
421
422     test = [];
423     for i = 1:nr ;
424         test = [test; gsort(a(i,:),"g")];
425     end
426     assert_checkequal(a1, test);
427
428     if itype < 10
429         for i = 1:Nrand
430             b = iconvert(10 * rand(N,P,"u"), itype);
431             [b1,ind] = gsort(b,"c");
432             assert_checkequal(or(b1(:,2:$) - b1(:,1:$-1) > 0), %f);
433             test = [];
434             for j = 1:nr
435                 test = [test; b(j,ind(j,:))];
436             end
437             assert_checkequal(b1, test);
438         end
439     end
440
441     //increasing
442     [a1,ind] = gsort(a,"c","i");
443     nr = size(a,"r");
444     test = [];
445     for i = 1:nr
446         test = [test; matrix(a(i,ind(i,:)),1,P)];
447     end
448     assert_checkequal(a1, test);
449     test = [];
450     for i = 1:nr
451         test = [test; gsort(a(i,:),"g","i")];
452     end
453     assert_checkequal(a1, test);
454
455     //----sort the rows of a in lexicographic order
456     //    i.e a(k,:) < a(l,:) if there's a number j
457     //    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
458     //
459     N1=4;P1=3;
460     alr=[1,2,2;
461     1,2,1;
462     1,1,2;
463     1,1,1];
464     // a random permutation
465     [ax,perm] = gsort(rand(1,N1,"u"));
466     a = iconvert(alr(perm,:), itype);
467
468     [a1,ind] = gsort(a,"lr");
469
470     assert_checkequal(a1, iconvert(alr, itype));
471     assert_checkequal(a1, matrix(a(ind,:),N1,P1));
472
473     [a2,ind2] = gsort(a*[100;10;1],"g");
474     assert_checkequal(ind2, ind);
475     ///////////////////////
476     for i = 1:Nrand
477         b = iconvert(vmax*rand(N,P,"u"), itype);
478         [b1,ind] = gsort(b,"lr");
479         assert_checkequal(b1, b(ind,:));
480         v = double(b1)*((vmax+1)^[P-1:-1:0])';
481         assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
482     end
483
484     // increasing
485     [a1,ind] = gsort(a,"lr","i");
486     assert_checkequal(a1, iconvert(alr(N1:-1:1,:), itype));
487     assert_checkequal(a1, matrix(a(ind,:),N1,P1));
488
489     [a2,ind2] = gsort(a*[100;10;1],"g","i");
490     assert_checkequal(ind2, ind);
491
492     for i = 1:Nrand
493         b = int(vmax * rand(N,P,"u"));
494         [b1,ind] = gsort(b,"lr","i");
495         assert_checkequal(b1, b(ind,:));
496         v = double(b1)*((vmax+1)^[P-1:-1:0])';
497         assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
498     end
499
500     //----sort the columns of a in lexicographic order
501     N1 = 3; P1 = 4;
502     alr = alr';
503     // a random permutation
504     [ax,perm] = gsort(rand(1,P1,"u"));
505     a = iconvert(alr(:,perm), itype);
506
507     [a1,ind] = gsort(a,"lc");
508     assert_checkequal(a1, iconvert(alr, itype));
509     assert_checkequal(a1, matrix(a(:,ind),N1,P1));
510
511     [a2,ind2] = gsort([100,10,1]*a,"g");
512     assert_checkequal(ind2, ind);
513
514     for i = 1:Nrand
515         b = int(vmax*rand(N1,P1,"u"));
516         [b1,ind] = gsort(b,"lc");
517         assert_checkequal(b1, b(:,ind));
518         v= ((vmax+1)^[N1-1:-1:0])*double(b1);
519         assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
520     end
521
522     //increasing
523     [a1,ind] = gsort(a,"lc","i");
524     assert_checkequal(a1, iconvert(alr(:,P1:-1:1), itype));
525     assert_checkequal(a1, matrix(a(:,ind),N1,P1));
526
527     [a2,ind2] = gsort([100,10,1] * a,"g","i");
528     assert_checkequal(ind2, ind);
529
530     for i = 1:Nrand
531         b = int(vmax*rand(N,P,"u"));
532         [b1,ind] = gsort(b,"lc","i");
533         assert_checkequal(b1, b(:,ind));
534         v = ((vmax+1)^[N-1:-1:0])*b1;
535         assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
536     end
537
538     a = iconvert([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,..
539     8,8,8,8,9,9,9,9,9,9,9,7,9,10,10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,..
540     14,14,14,14,14,14,15,15,15,15,16,17,18;
541     3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,..
542     13,13,10,10,13,13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,..
543     13,13,17,17,18,18,19,19,16,16,19,19,19,18,19], itype)';
544     if or(itype==[11 12 14])
545         a = a - 5
546     end
547     [b,ind] = gsort(a,"lr","i");
548     t = b(2:$,:) - b(1:$-1,:);
549     assert_checktrue(or(t(:,1) >= 0));      // int8: <= 0
550     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
551     assert_checkequal(a(ind,:), b);
552
553     for k = 1:30
554         p = grand(1,"prm",(1:size(a,1))');
555         [b,ind] = gsort(a(p,:),"lr","i");
556         t = b(2:$,:) - b(1:$-1,:);
557         assert_checktrue(or(t(:,1) >= 0));      // int8: <= 0
558         assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
559         assert_checkequal(a(p(ind),:), b);
560     end
561
562     [b,ind] = gsort(a,"lr","d");
563     t = b(1:$-1,:) - b(2:$,:);
564     assert_checktrue(or(t(:,1) >= 0));      // int8: <= 0
565     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
566     assert_checkequal(a(ind,:), b);
567
568     for k = 1:30
569         p = grand(1,"prm",(1:size(a,1))');
570         [b,ind] = gsort(a(p,:),"lr","d");
571         t = b(1:$-1,:) - b(2:$,:);
572         assert_checktrue(or(t(:,1) >= 0));      // int8: <= 0
573         assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
574         assert_checkequal(a(p(ind),:), b);
575     end
576
577     a = b;
578     a([10 60],:) = a([60 10],:);
579     [b,ind] = gsort(a,"lr","i");
580     t = b(2:$,:) - b(1:$-1,:);
581     assert_checktrue(or(t(:,1) >= 0));      // int8: <= 0
582     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
583     assert_checkequal(a(ind,:), b);
584
585     [b,ind] = gsort(a,"lr","d");
586     t = b(1:$-1,:) - b(2:$,:);
587     assert_checktrue(or(t(:,1) >= 0));      // int8: <= 0
588     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
589     assert_checkequal(a(ind,:), b);
590 end
591
592 //========================== testing gsort with Nan's =========================
593
594 b = gsort([1 2 %nan 3 4],"g","i");
595 assert_checkequal(b(1:4), (1:4));
596 assert_checkequal(find(isnan(b)), 5);
597
598 b = gsort([1 2 %nan 1 3 ],"g","i");
599 assert_checkequal(b(1:4), [1 1 2 3]);
600 assert_checkequal(find(isnan(b)), 5);
601
602 b = gsort([1 2 %nan 1 3 ],"g","d");
603 assert_checkequal(b(2:$), [3 2 1 1]);
604 assert_checkequal(find(isnan(b)), 1);
605
606 b = gsort([1 2 %nan 1 3 %nan 2 3],"g","d");
607 assert_checkequal(b(3:$), [3,3,2,2,1,1]);
608 assert_checkequal(find(isnan(b)), [1 2]);
609
610 b = gsort([1 2 %nan 1 3 %nan 2 3],"g","i");
611 assert_checkequal(b(1:$-2), [1,1,2,2,3,3]);
612 assert_checkequal(find(isnan(b)), [7 8]);
613
614 m = [1 2 %nan;1 3 %nan;1 2 3];
615 b = gsort(m,"lr","i");
616 assert_checkequal(sci2exp(b,0), "[1,2,3;1,2,%nan;1,3,%nan]");
617
618 b = gsort(m,"lr","d");
619 assert_checkequal(sci2exp(b,0), "[1,3,%nan;1,2,%nan;1,2,3]");
620
621 m = m(:,[3 1 2]);
622 b = gsort(m,"lc","i");
623 assert_checkequal(sci2exp(b,0), "[1,2,%nan;1,3,%nan;1,2,3]");
624
625 b = gsort(m,"lc","d");
626 assert_checkequal(sci2exp(b,0), "[%nan,2,1;%nan,3,1;3,2,1]");
627
628 //testing gsort with Inf's
629 b = gsort([1 2 %inf 3 4],"g","i");
630 assert_checkequal(b(1:4), (1:4));
631 assert_checkequal(find(isinf(b)), 5);
632
633 b=gsort([1 2 %inf 1 3 ],"g","i");
634 assert_checkequal(b(1:4), [1 1 2 3]);
635 assert_checkequal(find(isinf(b)), 5);
636
637 b=gsort([1 2 %inf 1 3 ],"g","d");
638 assert_checkequal(b(2:$), [3 2 1 1]);
639 assert_checkequal(find(isinf(b)), 1);
640
641 b=gsort([1 2 %inf 1 3 %inf 2 3],"g","d");
642 assert_checkequal(b(3:$), [3,3,2,2,1,1]);
643 assert_checkequal(find(isinf(b)), [1 2]);
644
645 b=gsort([1 2 %inf 1 3 %inf 2 3],"g","i");
646 assert_checkequal(b(1:$-2), [1,1,2,2,3,3]);
647 assert_checkequal(find(isinf(b)), [7 8]);
648
649 m = [1 2 %inf;1 3 %inf;1 2 3];
650 b = gsort(m,"lr","i");
651 assert_checkequal(sci2exp(b,0), "[1,2,3;1,2,%inf;1,3,%inf]");
652
653 b = gsort(m,"lr","d");
654 assert_checkequal(sci2exp(b,0), "[1,3,%inf;1,2,%inf;1,2,3]");
655
656 m = m(:,[3 1 2]);
657 b = gsort(m,"lc","i");
658 assert_checkequal(sci2exp(b,0), "[1,2,%inf;1,3,%inf;1,2,3]");
659
660 b = gsort(m,"lc","d");
661 assert_checkequal(sci2exp(b,0), "[%inf,2,1;%inf,3,1;3,2,1]");
662
663 //gsort
664 a = [5 1 3 2 4];
665 assert_checkequal(gsort(a), [5 4 3 2 1]);
666 assert_checkequal(gsort(a + 0), [5 4 3 2 1]);
667
668 [s,k] = gsort(a);
669 assert_checkequal(k, [1 5 3 4 2]);
670 assert_checkequal(s, [5 4 3 2 1]);
671
672 [s,k]=gsort(a+0);
673 assert_checkequal(k, [1 5 3 4 2]);
674 assert_checkequal(s, [5 4 3 2 1]);
675
676 a = string([5 1 3 2 4]);
677 assert_checkequal(gsort(a,"g","i"), string(1:5));
678
679 [s,k]=gsort(a,"g","i");
680 assert_checkequal(k, [2 4 3 5 1]);
681 assert_checkequal(s, string(1:5));
682
683 a = [];
684 assert_checkequal(gsort(a), []);
685 [s,k]=gsort(a);
686 assert_checkequal(s, []);
687 assert_checkequal(k, []);
688
689 //================================ hypermatrix ================================
690
691 A = rand(6, 4, 2, 8);
692 for o = ["d" "i"]
693     // 'g'
694     [hs hind]   = gsort(A, 'g', o);
695     [s ind]     = gsort(A(:), 'g', o);
696
697     assert_checkequal(hs(:), s);
698     assert_checkequal(hind(:), ind);
699
700     hs = gsort(A, 'g', o);
701     assert_checkequal(hs(:), s);
702
703     // 'c' 'r' 'lc' 'lr'
704     [hsc hindc]   = gsort(A, "c", o);
705     [hsr hindr]   = gsort(A, "r", o);
706     [hslc hindlc] = gsort(A, "lc", o);
707     [hslr hindlr] = gsort(A, "lr", o);
708
709     a       = matrix(A, 6, 4, 16); // 2 * 8 = 16
710     z = zeros(a);
711     [sc, indc, sr, indr, slc, slr] = (z, z, z, z, z, z);
712     indlc   = zeros(1, 4, 16);
713     indlr   = zeros(6, 1, 16);
714
715     for i = 1:16
716         [sc(:,:,i) indc(:,:,i)]   = gsort(a(:,:,i),"c", o);
717         [sr(:,:,i) indr(:,:,i)]   = gsort(a(:,:,i),"r", o);
718         [slc(:,:,i) indlc(:,:,i)] = gsort(a(:,:,i),"lc", o);
719         [slr(:,:,i) indlr(:,:,i)] = gsort(a(:,:,i),"lr", o);
720     end
721
722     sc      = matrix(sc, 6, 4, 2, 8);
723     indc    = matrix(indc, 6, 4, 2, 8);
724     sr      = matrix(sr, 6, 4, 2, 8);
725     indr    = matrix(indr, 6, 4, 2, 8);
726     slc     = matrix(slc, 6, 4, 2, 8);
727     indlc   = matrix(indlc, 1, 4, 2, 8);
728     slr     = matrix(slr, 6, 4, 2, 8);
729     indlr   = matrix(indlr, 6, 1, 2, 8);
730
731     assert_checkequal(hsc, sc);
732     assert_checkequal(hindc, indc);
733     assert_checkequal(hsr, sr);
734     assert_checkequal(hindr, indr);
735     assert_checkequal(hslc, slc);
736     assert_checkequal(hindlc, indlc);
737     assert_checkequal(hslr, slr);
738     assert_checkequal(hindlr, indlr);
739
740     // whitout indices
741     hsc  = gsort(A, "c", o);
742     hsr  = gsort(A, "r", o);
743     hslc = gsort(A, "lc", o);
744     hslr = gsort(A, "lr", o);
745
746     assert_checkequal(hsc, sc);
747     assert_checkequal(hsr, sr);
748     assert_checkequal(hslc, slc);
749     assert_checkequal(hslr, slr);
750 end