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