gsort: fix tests after decomplexification
[scilab.git] / scilab / modules / elementary_functions / tests / unit_tests / gsort_multilevel_numbers.tst
1 // ===================================================================
2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 // Copyright (C) 2020 - Samuel GOUGEON
4 //
5 //  This file is distributed under the same license as the Scilab package.
6 // ===================================================================
7 //
8 // <-- CLI SHELL MODE -->
9 // <-- NO CHECK REF -->
10 // <-- ENGLISH IMPOSED -->
11 //
12 //====================================================================
13 //         Tests of multilevel gsort() for decimal numbers
14 //====================================================================
15 /*
16 We sort numbers,
17  - first: by integer part, with int()
18  - second: by fractional part, with a custom function.
19 */
20 function r = get_frac(d)
21     r = d - int(d)
22 endfunction
23 crit = list(int, get_frac);
24
25 // Initial data
26 // ------------
27 d = [
28    2.3   1.5   1.7   2.1   2.3   2.6   1.9   2.6
29    0.    2.8   2.1   0.8   1.8   2.9   1.6   1.
30    1.9   1.5   0.3   0.4   2.3   2.7   0.    0.8
31    2.6   1.8   2.3   0.2   0.8   1.    1.6   2.9
32    2.5   1.8   2.3   0.5   1.4   1.9   2.3   1.3
33    1.5   1.5   2.1   2.9   0.4   2.7   1.    0.2
34   ];
35
36 // "g" multilevel sorting
37 // ----------------------
38 [r, k] = gsort(d, "g", ["i" "d"], crit);
39 ref = [
40    0.8   0.3   1.9   1.6   1.4   2.9   2.6   2.3
41    0.8   0.2   1.9   1.6   1.3   2.9   2.6   2.3
42    0.8   0.2   1.8   1.5   1.    2.8   2.5   2.3
43    0.5   0.    1.8   1.5   1.    2.7   2.3   2.1
44    0.4   0.    1.8   1.5   1.    2.7   2.3   2.1
45    0.4   1.9   1.7   1.5   2.9   2.6   2.3   2.1
46   ];
47 kref = [
48   20  15  35  38  29  32  31  25
49   28  22  37  40  47  46  43  27
50   45  48  10   6  34   8   5  41
51   23   2  11   7  42  33   1  14
52   21  39  26   9  44  36  16  18
53   30   3  13  12  24   4  17  19
54   ];
55 assert_checkequal(r, ref);
56 assert_checkequal(k, kref);
57
58 // "r" and "c" multilevel sorting
59 // ------------------------------
60 [r, k] = gsort(d, "c", ["i" "d"], crit);
61 ref = [
62    1.9   1.7   1.5   2.6   2.6   2.3   2.3   2.1
63    0.8   0.    1.8   1.6   1.    2.9   2.8   2.1
64    0.8   0.4   0.3   0.    1.9   1.5   2.7   2.3
65    0.8   0.2   1.8   1.6   1.    2.9   2.6   2.3
66    0.5   1.9   1.8   1.4   1.3   2.5   2.3   2.3
67    0.4   0.2   1.5   1.5   1.    2.9   2.7   2.1
68   ];
69 kref = [
70   7  3  2  6  8  1  5  4
71   4  1  5  7  8  6  2  3
72   8  4  3  7  1  2  6  5
73   5  4  2  7  6  8  1  3
74   4  6  2  5  8  1  3  7
75   5  8  1  2  7  4  6  3
76   ];
77 assert_checkequal(r, ref);
78 assert_checkequal(k, kref);
79 //
80 [r, k] = gsort(d, "r", ["d" "i"], crit);
81 ref = [
82    2.3   2.8   2.1   2.1   2.3   2.6   2.3   2.6
83    2.5   1.5   2.1   2.9   2.3   2.7   1.    2.9
84    2.6   1.5   2.3   0.2   1.4   2.7   1.6   1.
85    1.5   1.5   2.3   0.4   1.8   2.9   1.6   1.3
86    1.9   1.8   1.7   0.5   0.4   1.    1.9   0.2
87    0.    1.8   0.3   0.8   0.8   1.9   0.    0.8
88   ];
89 kref = [
90   1  2  2  1  1  1  5  1
91   5  1  6  6  3  3  6  4
92   4  3  4  4  5  6  2  2
93   6  6  5  3  2  2  4  5
94   3  4  1  5  6  4  1  6
95   2  5  3  2  4  5  3  3
96   ];
97 assert_checkequal(r, ref);
98 assert_checkequal(k, kref);
99
100 // Lexicographic multilevel sorting
101 // --------------------------------
102 d = [
103    0.1   0.1   1.1   0.1   0.1   1.    0.1   0.
104    1.    1.    1.1   0.    1.    1.1   0.    1.
105    0.1   0.1   0.1   0.    1.1   0.1   0.    0.
106    0.    0.    0.1   1.    1.    1.    1.    0.1
107    1.1   1.    1.1   0.1   1.    1.1   0.1   0.1
108    1.1   0.1   0.1   0.1   1.    0.1   0.    0.
109     ];
110 [r, k] = gsort(d, "lr", ["i" "d"], crit);
111 ref = [
112    0.1   0.1   0.1   0.    1.1   0.1   0.    0.
113    0.1   0.1   1.1   0.1   0.1   1.    0.1   0.
114    0.    0.    0.1   1.    1.    1.    1.    0.1
115    1.1   0.1   0.1   0.1   1.    0.1   0.    0.
116    1.1   1.    1.1   0.1   1.    1.1   0.1   0.1
117    1.    1.    1.1   0.    1.    1.1   0.    1.
118   ];
119 assert_checkequal(r, ref);
120 assert_checkequal(k', [3  1  4  6  5  2]);
121
122 //
123 [r, k] = gsort(d, "lc", ["d" "i"], crit);
124 ref = [
125    1.    1.1   0.    0.1   0.1   0.1   0.1   0.1
126    1.1   1.1   1.    1.    1.    1.    0.    0.
127    0.1   0.1   0.    1.1   0.1   0.1   0.    0.
128    1.    0.1   0.1   1.    0.    0.    1.    1.
129    1.1   1.1   0.1   1.    1.    1.1   0.1   0.1
130    0.1   0.1   0.    1.    0.1   1.1   0.    0.1
131   ];
132 assert_checkequal(r, ref);
133 assert_checkequal(k, [6  3  8  5  2  1  7  4]);