fix prod : variables that are returned are binding link with outType
[scilab.git] / scilab / modules / elementary_functions / tests / unit_tests / prod.tst
1 // =============================================================================
2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 // Copyright (C) 2010 - INRIA - Serge Steer
4 // Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
5 //
6 //  This file is distributed under the same license as the Scilab package.
7 // =============================================================================
8
9 // <-- CLI SHELL MODE -->
10 // prod
11 // Check error
12 d=[1 10;254 9];
13 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
14 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
15 assert_checkerror("prod(d, ""orient"")", refMsg);
16
17 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
18 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
19 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
20
21 //==============================================================================
22 // matrices of integer
23 i = uint8(d);
24 assert_checkfalse(execstr("prod(i, ""orient"")"   ,"errcatch") == 0);
25 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
26 assert_checkerror("prod(i, ""orient"")", refMsg);
27
28 assert_checkfalse(execstr("prod(i, [""r"", ""c""])"   ,"errcatch") == 0);
29 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
30 assert_checkerror("prod(i, [""r"", ""c""])", refMsg);
31
32 assert_checkfalse(execstr("prod(i,""r"", ""nat"")"   ,"errcatch") == 0);
33 refMsg = msprintf(_("Wrong value for argument #%d.\n"), 3);
34 assert_checkerror("prod(i,""r"", ""nat"")", refMsg);
35
36 assert_checkfalse(execstr("prod(i,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
37 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 3);
38 assert_checkerror("prod(i,""r"", [""nat"" ""dble""])", refMsg);
39
40 assert_checkfalse(execstr("prod(i,""orient"", ""t"")"   ,"errcatch") == 0);
41 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
42 assert_checkerror("prod(i,""orient"", ""t"")", refMsg);
43
44 assert_checkfalse(execstr("prod(i,1,1)"   ,"errcatch") == 0);
45 refMsg = msprintf(_("Wrong type for argument #%d: String expected.\n"), 3);
46 assert_checkerror("prod(i,1,1)", refMsg);
47
48 //==============================================================================
49 // sparse matrices
50 d = sparse(d);
51 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
52 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
53 assert_checkerror("prod(d, ""orient"")", refMsg);
54
55 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
56 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
57 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
58
59 //==============================================================================
60 // boolean matrices
61 d = [%f %t;%t %f];
62 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
63 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"prod",2,"""*"",""r"",""c"",""m""");
64 assert_checkerror("prod(d, ""orient"")", refMsg);
65
66 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
67 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
68 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
69
70 assert_checkfalse(execstr("prod(d,""r"", ""nat"")"   ,"errcatch") == 0);
71 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"prod", 3, "native", "double");
72 assert_checkerror("prod(d,""r"", ""nat"")", refMsg);
73
74 assert_checkfalse(execstr("prod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
75 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",3);
76 assert_checkerror("prod(d,""r"", [""nat"" ""dble""])", refMsg);
77
78 assert_checkfalse(execstr("prod(d,""orient"", ""t"")"   ,"errcatch") == 0);
79 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
80 "prod",2,"""*"",""r"",""c"",""m""");
81 assert_checkerror("prod(d,""orient"", ""t"")", refMsg);
82
83 assert_checkfalse(execstr("prod(d,1,1)"   ,"errcatch") == 0);
84 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"),"prod",3);
85 assert_checkerror("prod(d,1,1)", refMsg);
86
87 //==============================================================================
88 // sparse boolean matrices
89 d = sparse(d);
90 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
91 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
92 "prod",2,"""*"",""r"",""c"",""m""");
93 assert_checkerror("prod(d, ""orient"")", refMsg);
94
95 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
96 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
97 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
98
99 assert_checkfalse(execstr("prod(d,""r"", ""nat"")"   ,"errcatch") == 0);
100 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"prod", 3, "native", "double");
101 assert_checkerror("prod(d,""r"", ""nat"")", refMsg);
102
103 assert_checkfalse(execstr("prod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
104 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",3);
105 assert_checkerror("prod(d,""r"", [""nat"" ""dble""])", refMsg);
106
107 assert_checkfalse(execstr("prod(d,""orient"", ""t"")"   ,"errcatch") == 0);
108 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
109 "prod",2,"""*"",""r"",""c"",""m""");
110 assert_checkerror("prod(d,""orient"", ""t"")", refMsg);
111
112 assert_checkfalse(execstr("prod(d,1,1)"   ,"errcatch") == 0);
113 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"),"prod",3);
114 assert_checkerror("prod(d,1,1)", refMsg);
115
116 //==============================================================================
117 // hypermatrices
118 d = rand(2,2,2);
119 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
120 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
121 "prod",2,"""*"",""r"",""c"",""m""");
122 assert_checkerror("prod(d, ""orient"")", refMsg);
123
124 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
125 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
126 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
127
128 //==============================================================================
129 // polynome
130 s = poly(0, "s");
131 d = [s s^2;s*%i 1];
132 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
133 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
134 "prod",2,"""*"",""r"",""c"",""m""");
135 assert_checkerror("prod(d, ""orient"")", refMsg);
136
137 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
138 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
139 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
140
141 //==============================================================================
142 // rational matrices
143 s = poly(0, "s");
144 d = [1/s 1/s^2; 1/s 1];
145 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
146 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
147 "prod",2,"""*"",""r"",""c"",""m""");
148 assert_checkerror("prod(d, ""orient"")", refMsg);
149
150 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
151 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
152 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
153
154 //empty matrices
155 T=list(list(),list("native"),list("double"));
156 for typ=T
157     assert_checkequal(prod([], typ(:)), 1);
158     assert_checkequal(prod([], "*", typ(:)), 1);
159     assert_checkequal(prod([], 1, typ(:)), []);
160     assert_checkequal(prod([], 2, typ(:)), []);
161     assert_checkequal(prod([], 3, typ(:)), []);
162 end
163
164 //=======================================================================
165 //float matrices
166 d=[1 10;254 9];
167 T=list(list(),list("native"),list("double"));
168 for typ=T
169     assert_checkequal(prod(d, typ(:)), 22860);
170     assert_checkequal(prod(d, "*", typ(:)), 22860);
171     assert_checkequal(prod(d, 1, typ(:)), [254 90]);
172     assert_checkequal(prod(d, 2, typ(:)), [10;2286]);
173     assert_checkequal(prod(d, 3, typ(:)), d);
174 end
175
176
177 //hypermatrices of floats
178 d=[1 10;254 9];d(:,:,2)=1;
179 T=list(list(),list("native"),list("double"));
180 for typ=T
181     assert_checkequal(prod(d, typ(:)), 22860);
182     assert_checkequal(prod(d, "*", typ(:)), 22860);
183     assert_checkequal(prod(d, 1, typ(:)), hypermat([1,2,2],[254;90;1;1]));
184     assert_checkequal(prod(d, 2, typ(:)), hypermat([2,1,2],[10;2286;1;1]));
185     assert_checkequal(prod(d, 3, typ(:)), [1,10;254,9]);
186     assert_checkequal(prod(d, 5, typ(:)), d);
187 end
188
189 //=======================================================================
190 //matrices of short integers
191 i=uint8([1 10;254 9]);
192 T=list(list(),list("native"));
193 for typ=T
194     assert_checkequal(prod(i, typ(:)), uint8(76));
195     assert_checkequal(prod(i, "*", typ(:)), uint8(76));
196     assert_checkequal(prod(i, 1, typ(:)), uint8([254 90]));
197     assert_checkequal(prod(i, 2, typ(:)), uint8([10;238]));
198     assert_checkequal(prod(i, 3, typ(:)), i);
199 end
200
201 assert_checkequal(prod(i, "double"), 22860);
202 assert_checkequal(prod(i, "*", "double"), 22860);
203 assert_checkequal(prod(i, 1, "double"), [254 90]);
204 assert_checkequal(prod(i, 2, "double"), [10;2286]);
205 assert_checkequal(prod(i, 3, "double"), double(i));
206
207 //with hypermatrices
208 i=uint8([1 10;254 9]);i(:,:,2)=uint8(1);
209 T = list(list(),list("native"));
210 for typ=T
211     assert_checkequal(prod(i, typ(:)), uint8(76));
212     assert_checkequal(prod(i, "*", typ(:)), uint8(76));
213     assert_checkequal(prod(i, 1, typ(:)), hypermat([1,2,2],uint8([254;90;1;1])));
214     assert_checkequal(prod(i, 2, typ(:)), hypermat([2,1,2],uint8([10;238;1;1])));
215     assert_checkequal(prod(i, 3, typ(:)), uint8([1,10;254,9]));
216     assert_checkequal(prod(i, 5, typ(:)), i);
217 end
218
219 assert_checkequal(prod(i, "double"), 22860);
220 assert_checkequal(prod(i, "*", "double"), 22860);
221 assert_checkequal(prod(i, 1, "double"), hypermat([1,2,2],[254;90;1;1]));
222 assert_checkequal(prod(i, 2, "double"), hypermat([2,1,2],[10;2286;1;1]));
223 assert_checkequal(prod(i, 3, "double"), [1,10;254,9]);
224 assert_checkequal(prod(i, 5, "double"), double(i));
225
226 //Polynomials
227 s=%s;p=[s s+1;s^2 1];
228 T=list(list(),list("native"),list("double"));
229 for typ=T
230     assert_checkequal(prod(p, typ(:)), s^3+s^4);
231     assert_checkequal(prod(p, "*", typ(:)), s^3+s^4);
232     assert_checkequal(prod(p, 1, typ(:)), [s^3,1+s]);
233     assert_checkequal(prod(p, 2, typ(:)), [s+s^2;s^2]);
234     assert_checkequal(prod(p, 3, typ(:)), p);
235 end
236 //with hypermatrices
237 s=%s;p=[s s+1;s^2 1];p(:,:,2)=[1 s;s+1 2];
238 T=list(list(),list("native"),list("double"));
239 for typ=T
240     assert_checkequal(prod(p, typ(:)), 2*s^4+4*s^5+2*s^6);
241     assert_checkequal(prod(p, "*", typ(:)), 2*s^4+4*s^5+2*s^6);
242     assert_checkequal(prod(p, 1, typ(:)), hypermat([1,2,2],[s^3;1+s;1+s;2*s]));
243     assert_checkequal(prod(p, 2, typ(:)), hypermat([2,1,2],[s+s^2;s^2;s;2+2*s]));
244     assert_checkequal(prod(p, 3, typ(:)), [s,s+s^2;s^2+s^3,2]);
245     assert_checkequal(prod(p, 5, typ(:)), p);
246 end
247
248 //=======================================================================
249 //Matrices of rationals
250 s=%s;r=1.0 ./[s s+1;s^2 1];
251 T=list(list(),list("native"),list("double"));
252 for typ=T
253     assert_checkequal(prod(r, typ(:)), 1.0/(s^3+s^4));
254     assert_checkequal(prod(r, "*", typ(:)), 1.0/(s^3+s^4));
255     assert_checkequal(prod(r, 1, typ(:)), [1,1]./[s^3,1+s]);
256     assert_checkequal(prod(r, 2, typ(:)), [1;1]./[s+s^2;s^2]);
257     assert_checkequal(prod(r, 3, typ(:)), r);
258 end
259
260 //=======================================================================
261 //Matrices of booleans
262 b=[%t %t; %f %t];
263 T = list(list(),list("double"));
264 for typ=T
265     assert_checkequal(prod(b, typ(:)), 0);
266     assert_checkequal(prod(b, "*", typ(:)), 0);
267     assert_checkequal(prod(b, 1, typ(:)), [0 1]);
268     assert_checkequal(prod(b, 2, typ(:)), [1;0]);
269     assert_checkequal(prod(b, 3, typ(:)), double(b));
270 end
271
272 assert_checkequal(prod(b, "native"), %f);
273 assert_checkequal(prod(b, "*", "native"), %f);
274 assert_checkequal(prod(b, 1, "native"), [%f %t]);
275 assert_checkequal(prod(b, 2, "native"), [%t;%f]);
276 assert_checkequal(prod(b, 3, "native"), b);
277
278 //with hypermatrices
279 b=[%t %t;%f %t];b(1,1,2)=%t;
280 T = list(list(),list("double"));
281 for typ=T
282     assert_checkequal(prod(b, typ(:)), 0);
283     assert_checkequal(prod(b, "*", typ(:)), 0);
284     assert_checkequal(prod(b, 1, typ(:)), hypermat([1,2,2],[0;1;0;0]));
285     assert_checkequal(prod(b, 2, typ(:)), hypermat([2,1,2],[1;0;0;0]));
286     assert_checkequal(prod(b, 3, typ(:)), [1,0;0,0]);
287     assert_checkequal(prod(b, 5, typ(:)), double(b));
288 end
289
290 assert_checkequal(prod(b, "native"), %f);
291 assert_checkequal(prod(b, "*", "native"), %f);
292 assert_checkequal(prod(b, 1, "native"), hypermat([1,2,2],[%f;%t;%f;%f]));
293 assert_checkequal(prod(b, 2, "native"), hypermat([2,1,2],[%t;%f;%f;%f]));
294 assert_checkequal(prod(b, 3, "native"), [%t,%f;%f,%f]);
295 assert_checkequal(prod(b, 5, "native"), b);
296
297 //=======================================================================
298 //sparse matrices of floats
299 s=sparse([1 10 2;-1 254 9]);
300 T=list(list(),list("native"),list("double"));
301 for typ=T
302     assert_checkequal(prod(s, typ(:)), -45720);
303     assert_checkequal(prod(s, "*", typ(:)), -45720);
304     assert_checkequal(prod(s, 1, typ(:)), sparse([-1 2540 18]));
305     assert_checkequal(prod(s, 2, typ(:)), sparse([20;-2286]));
306     assert_checkequal(prod(s, 3, typ(:)), s);
307 end
308
309 //=======================================================================
310 //sparse  matrices of boolean
311 bs=sparse([%t %t %f;%t %t %t]);
312 T = list(list(),list("double"));
313 for typ=T
314     assert_checkequal(prod(bs, typ(:)), 0);
315     assert_checkequal(prod(bs, "*", typ(:)), 0);
316     assert_checkequal(prod(bs, 1, typ(:)), sparse([1,1,0]));
317     assert_checkequal(prod(bs, 2, typ(:)), sparse([0;1]));
318     assert_checkequal(prod(bs, 3, typ(:)), bool2s(bs));
319 end
320
321 assert_checkequal(prod(bs, "native"), %f);
322 assert_checkequal(prod(bs, "*", "native"), %f);
323 assert_checkequal(prod(bs, 1, "native"), sparse([%t,%t,%f]));
324 assert_checkequal(prod(bs, 2, "native"), sparse([%f;%t]));
325 assert_checkequal(prod(bs, 3, "native"), bs);
326
327 // TODO : test the "m" option