* bug #14801 fixed: [cells1 cells2] puzzled cells components
[scilab.git] / scilab / modules / ast / tests / unit_tests / concatenation.tst
1 // ============================================================================
2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 // Copyright (C) 2014 - Scilab Enterprises - Cedric Delamarre
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
11 function checkCallOverload(mat)
12     assert_checkerror(mat, [], 999);
13 endfunction
14
15 ldouble = [1 2 3];
16 lbool   = [%t %f %t];
17 lint    = [int32(1) int32(2) int32(3)];
18 lint16  = [int16(1) int16(2) int16(3)];
19 lpoly   = [%s %s^2 %s];
20 lsparse = [sparse(1) sparse(2) sparse(3)];
21 lspb    = [sparse(%t) sparse(%f) sparse(%t)];
22 lstring = ["Scilab" "Enterprises" "2014"];
23 sta.x   = 12;
24 lsta    = [sta sta sta];
25 lcell   = {ldouble, lbool, lstring};
26
27 // list, tlist, mlist
28 checkCallOverload("[list(1) list(2)]");
29
30 // Double
31 assert_checkequal([ldouble ldouble], [1 2 3 1 2 3]);
32 assert_checkequal([ldouble lbool], [ldouble double(lbool)]);
33 checkCallOverload("[ldouble lint]");
34 checkCallOverload("[ldouble lint16]");
35 assert_checkequal([ldouble lpoly], [(ldouble + 0*%s) lpoly]);
36 assert_checkequal([ldouble lsparse], [sparse(ldouble) lsparse]);
37 checkCallOverload("[ldouble lspb]");
38 checkCallOverload("[ldouble lstring]");
39 checkCallOverload("[ldouble lsta]");
40
41 assert_checkequal([ldouble ; ldouble], matrix([1 1 2 2 3 3], 2, 3));
42 assert_checkequal([ldouble ; lbool], [ldouble ; double(lbool)]);
43 checkCallOverload("[ldouble ; lint]");
44 checkCallOverload("[ldouble ; lint16]");
45 assert_checkequal([ldouble ; lpoly], [(ldouble + 0*%s) ; lpoly]);
46 assert_checkequal([ldouble ; lsparse], [sparse(ldouble) ; lsparse]);
47 checkCallOverload("[ldouble ; lspb]");
48 checkCallOverload("[ldouble ; lstring]");
49 checkCallOverload("[ldouble ; lsta]");
50
51 // Bool
52 assert_checkequal([lbool ldouble], [double(lbool) ldouble]);
53 assert_checkequal([lbool lbool], [%t %f %t %t %f %t]);
54 checkCallOverload("[lbool lint]");
55 checkCallOverload("[lbool lint16]");
56 checkCallOverload("[lbool lpoly]");
57 checkCallOverload("[lbool lsparse]");
58 assert_checkequal([lbool lspb], [sparse(lbool) lspb]);
59 checkCallOverload("[lbool lstring]");
60 checkCallOverload("[lbool lsta]");
61
62 assert_checkequal([lbool ; ldouble], [double(lbool) ; ldouble]);
63 assert_checkequal([lbool ; lbool], matrix([%t %t %f %f %t %t], 2, 3));
64 checkCallOverload("[lbool ; lint]");
65 checkCallOverload("[lbool ; lint16]");
66 checkCallOverload("[lbool ; lpoly]");
67 checkCallOverload("[lbool ; lsparse]");
68 assert_checkequal([lbool ; lspb], [sparse(lbool) ; lspb]);
69 checkCallOverload("[lbool ; lstring]");
70 checkCallOverload("[lbool ; lsta]");
71
72 // int
73 checkCallOverload("[lint ldouble]");
74 checkCallOverload("[lint lbool]");
75 assert_checkequal([lint lint], int32([1 2 3 1 2 3]));
76 checkCallOverload("[lint lint16]");
77 checkCallOverload("[lint lpoly]");
78 checkCallOverload("[lint lsparse]");
79 checkCallOverload("[lint lspb]");
80 checkCallOverload("[lint lstring]");
81 checkCallOverload("[lint lsta]");
82
83 checkCallOverload("[lint ; ldouble]");
84 checkCallOverload("[lint ; lbool]");
85 assert_checkequal([lint ; lint], int32(matrix([1 1 2 2 3 3], 2, 3)));
86 checkCallOverload("[lint ; lint16]");
87 checkCallOverload("[lint ; lpoly]");
88 checkCallOverload("[lint ; lsparse]");
89 checkCallOverload("[lint ; lspb]");
90 checkCallOverload("[lint  lstring]");
91 checkCallOverload("[lint ; lsta]");
92
93 // polynom
94 assert_checkequal([lpoly ldouble], [%s %s^2 %s 1 2 3]);
95 checkCallOverload("[lpoly lbool]");
96 checkCallOverload("[lpoly lint]");
97 checkCallOverload("[lpoly lint16]");
98 assert_checkequal([lpoly lpoly], [%s %s^2 %s %s %s^2 %s]);
99 checkCallOverload("[lpoly lsparse]");
100 checkCallOverload("[lpoly lspb]");
101 checkCallOverload("[lpoly lstring]");
102 checkCallOverload("[lpoly lsta]");
103
104 assert_checkequal([lpoly ; ldouble], matrix([%s 1 %s^2 2 %s 3], 2, 3));
105 checkCallOverload("[lpoly ; lbool]");
106 checkCallOverload("[lpoly ; lint]");
107 checkCallOverload("[lpoly ; lint16]");
108 assert_checkequal([lpoly ; lpoly], matrix([%s %s %s^2 %s^2 %s %s], 2, 3));
109 checkCallOverload("[lpoly ; lsparse]");
110 checkCallOverload("[lpoly ; lspb]");
111 checkCallOverload("[lpoly ; lstring]");
112 checkCallOverload("[lpoly ; lsta]");
113
114 // sparse
115 assert_checkequal([lsparse ldouble], sparse([1 2 3 1 2 3]));
116 checkCallOverload("[lsparse lbool]");
117 checkCallOverload("[lsparse lint]");
118 checkCallOverload("[lsparse lint16]");
119 checkCallOverload("[lsparse lpoly]");
120 assert_checkequal([lsparse lsparse], sparse([1 2 3 1 2 3]));
121 checkCallOverload("[lsparse lspb]");
122 checkCallOverload("[lsparse lstring]");
123 checkCallOverload("[lsparse lsta]");
124
125 assert_checkequal([lsparse ; ldouble], sparse(matrix([1 1 2 2 3 3], 2, 3)));
126 checkCallOverload("[lsparse  ;lbool]");
127 checkCallOverload("[lsparse ; lint]");
128 checkCallOverload("[lsparse ; lint16]");
129 checkCallOverload("[lsparse ; lpoly]");
130 assert_checkequal([lsparse ; lsparse], sparse(matrix([1 1 2 2 3 3], 2, 3)));
131 checkCallOverload("[lsparse ; lspb]");
132 checkCallOverload("[lsparse ; lstring]");
133 checkCallOverload("[lsparse ; lsta]");
134
135 // boolean sparse
136 checkCallOverload("[lspb ldouble]");
137 assert_checkequal([lspb lbool], sparse([%t %f %t %t %f %t]));
138 checkCallOverload("[lspb lint]");
139 checkCallOverload("[lspb lint16]");
140 checkCallOverload("[lspb lpoly]");
141 checkCallOverload("[lspb lsparse]");
142 assert_checkequal([lspb lspb], sparse([%t %f %t %t %f %t]));
143 checkCallOverload("[lspb lstring]");
144 checkCallOverload("[lspb lsta]");
145
146 checkCallOverload("[lspb ; ldouble]");
147 assert_checkequal([lspb ; lbool], sparse(matrix([%t %t %f %f %t %t], 2 ,3)));
148 checkCallOverload("[lspb ; lint]");
149 checkCallOverload("[lspb ; lint16]");
150 checkCallOverload("[lspb ; lpoly]");
151 checkCallOverload("[lspb ; lsparse]");
152 assert_checkequal([lspb ; lspb], sparse(matrix([%t %t %f %f %t %t], 2 ,3)));
153 checkCallOverload("[lspb ; lstring]");
154 checkCallOverload("[lspb ; lsta]");
155
156 // string
157 checkCallOverload("[lstring ldouble]");
158 checkCallOverload("[lstring lbool]");
159 checkCallOverload("[lstring lint]");
160 checkCallOverload("[lstring lint16]");
161 checkCallOverload("[lstring lpoly]");
162 checkCallOverload("[lstring lsparse]");
163 checkCallOverload("[lstring lspb]");
164 assert_checkequal([lstring lstring], ["Scilab" "Enterprises" "2014" "Scilab" "Enterprises" "2014"]);
165 checkCallOverload("[lstring lsta]");
166
167 checkCallOverload("[lstring ; ldouble]");
168 checkCallOverload("[lstring ; lbool]");
169 checkCallOverload("[lstring ; lint]");
170 checkCallOverload("[lstring ; lint16]");
171 checkCallOverload("[lstring ; lpoly]");
172 checkCallOverload("[lstring ; lsparse]");
173 checkCallOverload("[lstring ; lspb]");
174 assert_checkequal([lstring ; lstring], matrix(["Scilab" "Scilab" "Enterprises" "Enterprises" "2014" "2014"], 2, 3));
175 checkCallOverload("[lstring ; lsta]");
176
177 // struct
178 stb.y = 23;
179 stc.x = 56;
180 lstb  = [stb stb stb];
181 lstc  = [stc stc stc];
182
183 checkCallOverload("[lsta ldouble]");
184 checkCallOverload("[lsta lbool]");
185 checkCallOverload("[lsta lint]");
186 checkCallOverload("[lsta lint16]");
187 checkCallOverload("[lsta lpoly]");
188 checkCallOverload("[lsta lsparse]");
189 checkCallOverload("[lsta lspb]");
190 checkCallOverload("[lsta lstring]");
191 assert_checkequal([lsta lsta], [sta sta sta sta sta sta]);
192 assert_checkerror("[lsta ; lstb]", msprintf(_("%s: Field names mismatch.\n"),"%st_c_st"), 10000);
193
194 checkCallOverload("[lsta ; ldouble]");
195 checkCallOverload("[lsta ; lbool]");
196 checkCallOverload("[lsta ; lint]");
197 checkCallOverload("[lsta ; lint16]");
198 checkCallOverload("[lsta ; lpoly]");
199 checkCallOverload("[lsta ; lsparse]");
200 checkCallOverload("[lsta ; lspb]");
201 checkCallOverload("[lsta ; lstring]");
202 assert_checkequal([lsta ; lsta], matrix([sta sta sta sta sta sta], 2, 3));
203 assert_checkerror("[lsta ; lstb]", msprintf(_("%s: Field names mismatch.\n"),"%st_c_st"), 10000);
204
205 // ImplicitList
206 checkCallOverload("[1:$ 2]");
207 checkCallOverload("[1:$ 1:2]");
208 checkCallOverload("[1:$ int8(2)]");
209 checkCallOverload("[1:2 1:$]");
210 checkCallOverload("[1:$ 1:$]");
211 assert_checkequal([1:3 1:3], [1 2 3 1 2 3]);
212
213 checkCallOverload("[1:$ ; 2]");
214 checkCallOverload("[1:$ ; 1:2]");
215 checkCallOverload("[1:$ ; int8(2)]");
216 checkCallOverload("[1:2 ; 1:$]");
217 checkCallOverload("[1:$ ; 1:$]");
218 assert_checkequal([1:3 ; 1:3], matrix([1 1 2 2 3 3], 2, 3));
219
220 //cells
221
222 //row
223 c = [lcell,lcell];
224 assert_checkequal(c, {ldouble, lbool, lstring, ldouble, lbool, lstring});
225 assert_checkequal(c{1, 1}, ldouble);
226 assert_checkequal(c{1, 2}, lbool);
227 assert_checkequal(c{1, 3}, lstring);
228 assert_checkequal(c{1, 4}, ldouble);
229 assert_checkequal(c{1, 5}, lbool);
230 assert_checkequal(c{1, 6}, lstring);
231
232 //col
233 c = [lcell;lcell];
234 assert_checkequal(c, {ldouble, lbool, lstring;ldouble, lbool, lstring});
235 assert_checkequal(c{1, 1}, ldouble);
236 assert_checkequal(c{1, 2}, lbool);
237 assert_checkequal(c{1, 3}, lstring);
238 assert_checkequal(c{2, 1}, ldouble);
239 assert_checkequal(c{2, 2}, lbool);
240 assert_checkequal(c{2, 3}, lstring);
241
242 //2d
243 c = [lcell,lcell;lcell,lcell;lcell,lcell];
244 assert_checkequal(c(1, 1:3), lcell);
245 assert_checkequal(c(1, 4:6), lcell);
246 assert_checkequal(c(2, 1:3), lcell);
247 assert_checkequal(c(2, 4:6), lcell);
248 assert_checkequal(c(3, 1:3), lcell);
249 assert_checkequal(c(3, 4:6), lcell);
250
251 c_2_4 = {ldouble, lbool, lstring, lcell;lcell, lstring, lbool, ldouble};
252 c_2_2 = {ldouble, lbool;lstring, lcell}
253 c = [c_2_4;c_2_2,c_2_2];
254 assert_checkequal(c{1, 1}, ldouble);
255 assert_checkequal(c{1, 2}, lbool);
256 assert_checkequal(c{1, 3}, lstring);
257 assert_checkequal(c{1, 4}, lcell);
258 assert_checkequal(c{2, 1}, lcell);
259 assert_checkequal(c{2, 2}, lstring);
260 assert_checkequal(c{2, 3}, lbool);
261 assert_checkequal(c{2, 4}, ldouble);
262 assert_checkequal(c{3, 1}, ldouble);
263 assert_checkequal(c{3, 2}, lbool);
264 assert_checkequal(c{3, 3}, ldouble);
265 assert_checkequal(c{3, 4}, lbool);
266 assert_checkequal(c{4, 1}, lstring);
267 assert_checkequal(c{4, 2}, lcell);
268 assert_checkequal(c{4, 3}, lstring);
269 assert_checkequal(c{4, 4}, lcell);
270
271 //3d
272 c1 = {ldouble, lbool;lstring, lcell};
273 c2 = {lpoly;lsta};
274 C1(:,:,2) = c1;
275 C1(:,:,1) = c1;
276 C2(:,:,2) = c2;
277 C2(:,:,1) = c2;
278 R = [C1;C2 C2];
279 assert_checkequal(R{1,1,1}, C1{1,1,1});
280 assert_checkequal(R{1,1,2}, C1{1,1,2});
281 assert_checkequal(R{1,2,1}, C1{1,2,1});
282 assert_checkequal(R{1,2,2}, C1{1,2,2});
283 assert_checkequal(R{2,1,1}, C1{2,1,1});
284 assert_checkequal(R{2,1,2}, C1{2,1,2});
285 assert_checkequal(R{2,2,1}, C1{2,2,1});
286 assert_checkequal(R{2,2,2}, C1{2,2,2});
287
288 assert_checkequal(R{3,1,1}, C2{1,1,1});
289 assert_checkequal(R{3,1,2}, C2{1,1,2});
290 assert_checkequal(R{3,2,1}, C2{1,1,1});
291 assert_checkequal(R{3,2,2}, C2{1,1,2});
292
293 assert_checkequal(R{4,1,1}, C2{2,1,1});
294 assert_checkequal(R{4,1,2}, C2{2,1,2});
295 assert_checkequal(R{4,2,1}, C2{2,1,1});
296 assert_checkequal(R{4,2,2}, C2{2,1,2});