fix integer tests
[scilab.git] / scilab / modules / integer / tests / nonreg_tests / bug_3842.dia.ref
1 //<-- CLI SHELL MODE -->
2 // =============================================================================
3 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
4 // Copyright (C) 2010 - INRIA - Serge Steer
5 //
6 //  This file is distributed under the same license as the Scilab package.
7 // =============================================================================
8 //
9 // <-- Non-regression test for bug 3842 -->
10 //
11 // <-- Bugzilla URL -->
12 // http://bugzilla.scilab.org/show_bug.cgi?id=3842
13 //
14 // <-- Short Description -->
15 // sum applyed to integer arrys can only procuce results computed using native operations.
16 exec SCI/modules/elementary_functions/tests/unit_tests/prod.tst
17 // =============================================================================
18 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
19 // Copyright (C) 2010 - INRIA - Serge Steer
20 // Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
21 //
22 //  This file is distributed under the same license as the Scilab package.
23 // =============================================================================
24 // <-- CLI SHELL MODE -->
25 // prod
26 // Check error
27 d=[1 10;254 9];
28 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
29 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
30 assert_checkerror("prod(d, ""orient"")", refMsg);
31 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
32 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "prod", 2);
33 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
34 //==============================================================================
35 // matrices of integer
36 i = uint8(d);
37 assert_checkfalse(execstr("prod(i, ""orient"")"   ,"errcatch") == 0);
38 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
39 assert_checkerror("prod(i, ""orient"")", refMsg);
40 assert_checkfalse(execstr("prod(i, [""r"", ""c""])"   ,"errcatch") == 0);
41 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "prod", 2);
42 assert_checkerror("prod(i, [""r"", ""c""])", refMsg);
43 assert_checkfalse(execstr("prod(i,""r"", ""nat"")"   ,"errcatch") == 0);
44 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s or %s expected.\n"),"prod", 3, """native""", """double""");
45 assert_checkerror("prod(i,""r"", ""nat"")", refMsg);
46 assert_checkfalse(execstr("prod(i,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
47 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "prod", 3);
48 assert_checkerror("prod(i,""r"", [""nat"" ""dble""])", refMsg);
49 assert_checkfalse(execstr("prod(i,""orient"", ""t"")"   ,"errcatch") == 0);
50 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod",2,"""*"",""r"",""c"",""m""");
51 assert_checkerror("prod(i,""orient"", ""t"")", refMsg);
52 assert_checkfalse(execstr("prod(i,1,1)"   ,"errcatch") == 0);
53 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"), "prod", 3);
54 assert_checkerror("prod(i,1,1)", refMsg);
55 //==============================================================================
56 // sparse matrices
57 d = sparse(d);
58 assert_checkfalse(execstr("prod(d, ""orient"")","errcatch") == 0);
59 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod",2,"""*"",""r"",""c"",""m""");
60 assert_checkerror("prod(d, ""orient"")", refMsg);
61 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
62 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"prod",2);
63 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
64 //==============================================================================
65 // boolean matrices
66 d = [%f %t;%t %f];
67 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
68 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"prod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
69 assert_checkerror("prod(d, ""orient"")", refMsg);
70 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
71 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"prod",2);
72 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
73 assert_checkfalse(execstr("prod(d,""r"", ""nat"")"   ,"errcatch") == 0);
74 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s or %s expected.\n"),"prod", 3, """native""", """double""");
75 assert_checkerror("prod(d,""r"", ""nat"")", refMsg);
76 assert_checkfalse(execstr("prod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
77 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"prod",3);
78 assert_checkerror("prod(d,""r"", [""nat"" ""dble""])", refMsg);
79 assert_checkfalse(execstr("prod(d,""orient"", ""t"")"   ,"errcatch") == 0);
80 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
81 "prod",2,"""*"",""r"",""c"",""m""");
82 assert_checkerror("prod(d,""orient"", ""t"")", refMsg);
83 assert_checkfalse(execstr("prod(d,1,1)"   ,"errcatch") == 0);
84 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"),"prod",3);
85 assert_checkerror("prod(d,1,1)", refMsg);
86 //==============================================================================
87 // sparse boolean matrices
88 d = sparse(d);
89 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
90 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
91 "prod",2,"""*"",""r"",""c"",""m""");
92 assert_checkerror("prod(d, ""orient"")", refMsg);
93 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
94 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"prod",2);
95 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
96 assert_checkfalse(execstr("prod(d,""r"", ""nat"")"   ,"errcatch") == 0);
97 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"prod", 3, "native", "double");
98 assert_checkerror("prod(d,""r"", ""nat"")", refMsg);
99 assert_checkfalse(execstr("prod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
100 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"prod",3);
101 assert_checkerror("prod(d,""r"", [""nat"" ""dble""])", refMsg);
102 assert_checkfalse(execstr("prod(d,""orient"", ""t"")"   ,"errcatch") == 0);
103 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
104 "prod",2,"""*"",""r"",""c"",""m""");
105 assert_checkerror("prod(d,""orient"", ""t"")", refMsg);
106 assert_checkfalse(execstr("prod(d,1,1)"   ,"errcatch") == 0);
107 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"),"prod",3);
108 assert_checkerror("prod(d,1,1)", refMsg);
109 //==============================================================================
110 // hypermatrices
111 d = rand(2,2,2);
112 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
113 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
114 assert_checkerror("prod(d, ""orient"")", refMsg);
115 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
116 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"prod",2);
117 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
118 //==============================================================================
119 // polynome
120 s = poly(0, "s");
121 d = [s s^2;s*%i 1];
122 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
123 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"prod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
124 assert_checkerror("prod(d, ""orient"")", refMsg);
125 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
126 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"prod",2);
127 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
128 //==============================================================================
129 // rational matrices
130 s = poly(0, "s");
131 d = [1/s 1/s^2; 1/s 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"),"prod",2,"""*"",""r"",""c"",""m""");
134 assert_checkerror("prod(d, ""orient"")", refMsg);
135 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
136 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"prod",2);
137 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
138 //empty matrices
139 T=list(list(),list("native"),list("double"));
140 for typ=T
141     assert_checkequal(prod([], typ(:)), 1);
142     assert_checkequal(prod([], "*", typ(:)), 1);
143     assert_checkequal(prod([], 1, typ(:)), []);
144     assert_checkequal(prod([], 2, typ(:)), []);
145     assert_checkequal(prod([], 3, typ(:)), []);
146 end
147 //=======================================================================
148 //float matrices
149 d=[1 10;254 9];
150 T=list(list(),list("native"),list("double"));
151 for typ=T
152     assert_checkequal(prod(d, typ(:)), 22860);
153     assert_checkequal(prod(d, "*", typ(:)), 22860);
154     assert_checkequal(prod(d, 1, typ(:)), [254 90]);
155     assert_checkequal(prod(d, 2, typ(:)), [10;2286]);
156     assert_checkequal(prod(d, 3, typ(:)), d);
157 end
158 //hypermatrices of floats
159 d=[1 10;254 9];d(:,:,2)=1;
160 T=list(list(),list("native"),list("double"));
161 for typ=T
162     assert_checkequal(prod(d, typ(:)), 22860);
163     assert_checkequal(prod(d, "*", typ(:)), 22860);
164     assert_checkequal(prod(d, 1, typ(:)), matrix([254;90;1;1], [1,2,2]));
165     assert_checkequal(prod(d, 2, typ(:)), matrix([10;2286;1;1], [2,1,2]));
166     assert_checkequal(prod(d, 3, typ(:)), [1,10;254,9]);
167     assert_checkequal(prod(d, 5, typ(:)), d);
168 end
169 //=======================================================================
170 //matrices of short integers
171 i=uint8([1 10;254 9]);
172 T=list(list(),list("native"));
173 for typ=T
174     assert_checkequal(prod(i, typ(:)), uint8(76));
175     assert_checkequal(prod(i, "*", typ(:)), uint8(76));
176     assert_checkequal(prod(i, 1, typ(:)), uint8([254 90]));
177     assert_checkequal(prod(i, 2, typ(:)), uint8([10;238]));
178     assert_checkequal(prod(i, 3, typ(:)), i);
179 end
180 assert_checkequal(prod(i, "double"), 22860);
181 assert_checkequal(prod(i, "*", "double"), 22860);
182 assert_checkequal(prod(i, 1, "double"), [254 90]);
183 assert_checkequal(prod(i, 2, "double"), [10;2286]);
184 assert_checkequal(prod(i, 3, "double"), double(i));
185 //with hypermatrices
186 i=uint8([1 10;254 9]);i(:,:,2)=uint8(1);
187 T = list(list(),list("native"));
188 for typ=T
189     assert_checkequal(prod(i, typ(:)), uint8(76));
190     assert_checkequal(prod(i, "*", typ(:)), uint8(76));
191     assert_checkequal(prod(i, 1, typ(:)), matrix(uint8([254;90;1;1]), [1,2,2]));
192     assert_checkequal(prod(i, 2, typ(:)), matrix(uint8([10;238;1;1]), [2,1,2]));
193     assert_checkequal(prod(i, 3, typ(:)), uint8([1,10;254,9]));
194     assert_checkequal(prod(i, 5, typ(:)), i);
195 end
196 assert_checkequal(prod(i, "double"), 22860);
197 assert_checkequal(prod(i, "*", "double"), 22860);
198 assert_checkequal(prod(i, 1, "double"), matrix([254;90;1;1], [1,2,2]));
199 assert_checkequal(prod(i, 2, "double"), matrix([10;2286;1;1], [2,1,2]));
200 assert_checkequal(prod(i, 3, "double"), [1,10;254,9]);
201 assert_checkequal(prod(i, 5, "double"), double(i));
202 //Polynomials
203 s=%s;p=[s s+1;s^2 1];
204 T=list(list(),list("native"),list("double"));
205 for typ=T
206     assert_checkequal(prod(p, typ(:)), s^3+s^4);
207     assert_checkequal(prod(p, "*", typ(:)), s^3+s^4);
208     assert_checkequal(prod(p, 1, typ(:)), [s^3,1+s]);
209     assert_checkequal(prod(p, 2, typ(:)), [s+s^2;s^2]);
210     assert_checkequal(prod(p, 3, typ(:)), p);
211 end
212 //with hypermatrices
213 s=%s;p=[s s+1;s^2 1];p(:,:,2)=[1 s;s+1 2];
214 T=list(list(),list("native"),list("double"));
215 for typ=T
216     assert_checkequal(prod(p, typ(:)), 2*s^4+4*s^5+2*s^6);
217     assert_checkequal(prod(p, "*", typ(:)), 2*s^4+4*s^5+2*s^6);
218     assert_checkequal(prod(p, 1, typ(:)), matrix([s^3;1+s;1+s;2*s], [1,2,2]));
219     assert_checkequal(prod(p, 2, typ(:)), matrix([s+s^2;s^2;s;2+2*s], [2,1,2]));
220     assert_checkequal(prod(p, 3, typ(:)), [s,s+s^2;s^2+s^3,2]);
221     assert_checkequal(prod(p, 5, typ(:)), p);
222 end
223 //=======================================================================
224 //Matrices of rationals
225 s=%s;r=1.0 ./[s s+1;s^2 1];
226 T=list(list(),list("native"),list("double"));
227 for typ=T
228     assert_checkequal(prod(r, typ(:)), 1.0/(s^3+s^4));
229     assert_checkequal(prod(r, "*", typ(:)), 1.0/(s^3+s^4));
230     assert_checkequal(prod(r, 1, typ(:)), [1,1]./[s^3,1+s]);
231     assert_checkequal(prod(r, 2, typ(:)), [1;1]./[s+s^2;s^2]);
232     assert_checkequal(prod(r, 3, typ(:)), r);
233 end
234 //=======================================================================
235 //Matrices of booleans
236 b=[%t %t; %f %t];
237 T = list(list(),list("double"));
238 for typ=T
239     assert_checkequal(prod(b, typ(:)), 0);
240     assert_checkequal(prod(b, "*", typ(:)), 0);
241     assert_checkequal(prod(b, 1, typ(:)), [0 1]);
242     assert_checkequal(prod(b, 2, typ(:)), [1;0]);
243     assert_checkequal(prod(b, 3, typ(:)), double(b));
244 end
245 assert_checkequal(prod(b, "native"), %f);
246 assert_checkequal(prod(b, "*", "native"), %f);
247 assert_checkequal(prod(b, 1, "native"), [%f %t]);
248 assert_checkequal(prod(b, 2, "native"), [%t;%f]);
249 assert_checkequal(prod(b, 3, "native"), b);
250 //with hypermatrices
251 b=[%t %t;%f %t];b(1,1,2)=%t;
252 T = list(list(),list("double"));
253 for typ=T
254     assert_checkequal(prod(b, typ(:)), 0);
255     assert_checkequal(prod(b, "*", typ(:)), 0);
256     assert_checkequal(prod(b, 1, typ(:)), matrix([0;1;0;0], [1,2,2]));
257     assert_checkequal(prod(b, 2, typ(:)), matrix([1;0;0;0], [2,1,2]));
258     assert_checkequal(prod(b, 3, typ(:)), [1,0;0,0]);
259     assert_checkequal(prod(b, 5, typ(:)), double(b));
260 end
261 assert_checkequal(prod(b, "native"), %f);
262 assert_checkequal(prod(b, "*", "native"), %f);
263 assert_checkequal(prod(b, 1, "native"), matrix([%f;%t;%f;%f], [1,2,2]));
264 assert_checkequal(prod(b, 2, "native"), matrix([%t;%f;%f;%f], [2,1,2]));
265 assert_checkequal(prod(b, 3, "native"), [%t,%f;%f,%f]);
266 assert_checkequal(prod(b, 5, "native"), b);
267 //=======================================================================
268 //sparse matrices of floats
269 s=sparse([1 10 2;-1 254 9]);
270 T=list(list(),list("native"),list("double"));
271 for typ=T
272     assert_checkequal(prod(s, typ(:)), -45720);
273     assert_checkequal(prod(s, "*", typ(:)), -45720);
274     assert_checkequal(prod(s, 1, typ(:)), sparse([-1 2540 18]));
275     assert_checkequal(prod(s, 2, typ(:)), sparse([20;-2286]));
276     assert_checkequal(prod(s, 3, typ(:)), s);
277 end
278 //=======================================================================
279 //sparse  matrices of boolean
280 bs=sparse([%t %t %f;%t %t %t]);
281 T = list(list(),list("double"));
282 for typ=T
283     assert_checkequal(prod(bs, typ(:)), 0);
284     assert_checkequal(prod(bs, "*", typ(:)), 0);
285     assert_checkequal(prod(bs, 1, typ(:)), sparse([1,1,0]));
286     assert_checkequal(prod(bs, 2, typ(:)), sparse([0;1]));
287     assert_checkequal(prod(bs, 3, typ(:)), bool2s(bs));
288 end
289 assert_checkequal(prod(bs, "native"), %f);
290 assert_checkequal(prod(bs, "*", "native"), %f);
291 assert_checkequal(prod(bs, 1, "native"), sparse([%t,%t,%f]));
292 assert_checkequal(prod(bs, 2, "native"), sparse([%f;%t]));
293 assert_checkequal(prod(bs, 3, "native"), bs);
294 // TODO : test the "m" option
295 exec SCI/modules/elementary_functions/tests/unit_tests/cumprod.tst
296 // =============================================================================
297 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
298 // Copyright (C) 2010 - INRIA - Serge Steer
299 // Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
300 // Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
301 //
302 //  This file is distributed under the same license as the Scilab package.
303 // =============================================================================
304 // <-- CLI SHELL MODE -->
305 // Check error
306 //==============================================================================
307 //float matrices
308 d=[1 10;254 9];
309 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
310 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "cumprod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
311 assert_checkerror("cumprod(d, ""orient"")", refMsg);
312 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
313 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "cumprod", 2);
314 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
315 //==============================================================================
316 // matrices of integer
317 i = uint8(d);
318 assert_checkfalse(execstr("cumprod(i, ""orient"")"   ,"errcatch") == 0);
319 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "cumprod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
320 assert_checkerror("cumprod(i, ""orient"")", refMsg);
321 assert_checkfalse(execstr("cumprod(i, [""r"", ""c""])"   ,"errcatch") == 0);
322 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "cumprod", 2);
323 assert_checkerror("cumprod(i, [""r"", ""c""])", refMsg);
324 assert_checkfalse(execstr("cumprod(i,""r"", ""nat"")"   ,"errcatch") == 0);
325 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s or %s expected.\n"),"cumprod", 3, """native""", """double""");
326 assert_checkerror("cumprod(i,""r"", ""nat"")", refMsg);
327 assert_checkfalse(execstr("cumprod(i,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
328 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "cumprod", 3);
329 assert_checkerror("cumprod(i,""r"", [""nat"" ""dble""])", refMsg);
330 assert_checkfalse(execstr("cumprod(i,""orient"", ""t"")"   ,"errcatch") == 0);
331 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "cumprod",2,"""*"",""r"",""c"",""m""");
332 assert_checkerror("cumprod(i,""orient"", ""t"")", refMsg);
333 assert_checkfalse(execstr("cumprod(i,1,1)"   ,"errcatch") == 0);
334 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"), "cumprod", 3);
335 assert_checkerror("cumprod(i,1,1)", refMsg);
336 //==============================================================================
337 // sparse matrices
338 d = sparse(d);
339 assert_checkfalse(execstr("cumprod(d, ""orient"")","errcatch") == 0);
340 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "cumprod",2,"""*"",""r"",""c"",""m""");
341 assert_checkerror("cumprod(d, ""orient"")", refMsg);
342 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
343 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"cumprod",2);
344 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
345 //==============================================================================
346 // boolean matrices
347 d = [%f %t;%t %f];
348 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
349 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"cumprod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
350 assert_checkerror("cumprod(d, ""orient"")", refMsg);
351 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
352 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"cumprod",2);
353 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
354 assert_checkfalse(execstr("cumprod(d,""r"", ""nat"")"   ,"errcatch") == 0);
355 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s or %s expected.\n"),"cumprod", 3, """native""", """double""");
356 assert_checkerror("cumprod(d,""r"", ""nat"")", refMsg);
357 assert_checkfalse(execstr("cumprod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
358 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"cumprod",3);
359 assert_checkerror("cumprod(d,""r"", [""nat"" ""dble""])", refMsg);
360 assert_checkfalse(execstr("cumprod(d,""orient"", ""t"")"   ,"errcatch") == 0);
361 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
362 "cumprod",2,"""*"",""r"",""c"",""m""");
363 assert_checkerror("cumprod(d,""orient"", ""t"")", refMsg);
364 assert_checkfalse(execstr("cumprod(d,1,1)"   ,"errcatch") == 0);
365 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"),"cumprod",3);
366 assert_checkerror("cumprod(d,1,1)", refMsg);
367 //==============================================================================
368 // sparse boolean matrices
369 d = sparse(d);
370 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
371 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
372 "cumprod",2,"""*"",""r"",""c"",""m""");
373 assert_checkerror("cumprod(d, ""orient"")", refMsg);
374 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
375 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"cumprod",2);
376 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
377 assert_checkfalse(execstr("cumprod(d,""r"", ""nat"")"   ,"errcatch") == 0);
378 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"cumprod", 3, "native", "double");
379 assert_checkerror("cumprod(d,""r"", ""nat"")", refMsg);
380 assert_checkfalse(execstr("cumprod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
381 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"cumprod",3);
382 assert_checkerror("cumprod(d,""r"", [""nat"" ""dble""])", refMsg);
383 assert_checkfalse(execstr("cumprod(d,""orient"", ""t"")"   ,"errcatch") == 0);
384 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
385 "cumprod",2,"""*"",""r"",""c"",""m""");
386 assert_checkerror("cumprod(d,""orient"", ""t"")", refMsg);
387 assert_checkfalse(execstr("cumprod(d,1,1)"   ,"errcatch") == 0);
388 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"),"cumprod",3);
389 assert_checkerror("cumprod(d,1,1)", refMsg);
390 //==============================================================================
391 // hypermatrices
392 d = rand(2,2,2);
393 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
394 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "cumprod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
395 assert_checkerror("cumprod(d, ""orient"")", refMsg);
396 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
397 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"cumprod",2);
398 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
399 //==============================================================================
400 // polynome
401 s = poly(0, "s");
402 d = [s s^2;s*%i 1];
403 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
404 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"cumprod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
405 assert_checkerror("cumprod(d, ""orient"")", refMsg);
406 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
407 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"cumprod",2);
408 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
409 //==============================================================================
410 // rational matrices
411 s = poly(0, "s");
412 d = [1/s 1/s^2; 1/s 1];
413 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
414 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
415 "cumprod",2,"""*"",""r"",""c"",""m""");
416 assert_checkerror("cumprod(d, ""orient"")", refMsg);
417 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
418 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"cumprod",2);
419 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
420 //cumprod
421 //Empty matrices
422 T=list(list(),list("native"),list("double"));
423 for typ=T
424     assert_checkequal(cumprod([],typ(:)), []);
425     assert_checkequal(cumprod([],"*",typ(:)), []);
426     assert_checkequal(cumprod([],1,typ(:)), []);
427     assert_checkequal(cumprod([],2,typ(:)), []);
428     assert_checkequal(cumprod([],3,typ(:)), []);
429 end
430 //=======================================================================
431 //float matrices
432 d=[1 10;254 9];
433 T=list(list(),list("native"),list("double"));
434 for typ=T
435     assert_checkequal(cumprod(d,typ(:)), [1,2540;254,22860]);
436     assert_checkequal(cumprod(d,"*",typ(:)), [1,2540;254,22860]);
437     assert_checkequal(cumprod(d,1,typ(:)), [1,10;254,90]);
438     assert_checkequal(cumprod(d,2,typ(:)), [1,10;254,2286]);
439     assert_checkequal(cumprod(d,3,typ(:)), d);
440 end
441 //hypermatrices of floats
442 d=[1 10;254 9];d(1,1,2)=1;
443 T=list(list(),list("native"),list("double"));
444 for typ=T
445     assert_checkequal(cumprod(d,typ(:)), matrix([1;254;2540;22860;22860;0;0;0], [2,2,2]));
446     assert_checkequal(cumprod(d,"*",typ(:)), matrix([1;254;2540;22860;22860;0;0;0], [2,2,2]));
447     assert_checkequal(cumprod(d,1,typ(:)), matrix([1;254;10;90;1;0;0;0], [2,2,2]));
448     assert_checkequal(cumprod(d,2,typ(:)), matrix([1;254;10;2286;1;0;0;0], [2,2,2]));
449     assert_checkequal(cumprod(d,3,typ(:)), matrix([1;254;10;9;1;0;0;0], [2,2,2]));
450     assert_checkequal(cumprod(d,5,typ(:)), d);
451 end
452 //=======================================================================
453 //Integers
454 i=uint8([1 10;254 9]);
455 for typ=list(list(),list("native"));
456     assert_checkequal(cumprod(i,typ(:)), uint8([1,236;254,76]));
457     assert_checkequal(cumprod(i,"*",typ(:)), uint8([1,236;254,76]));
458     assert_checkequal(cumprod(i,1,typ(:)), uint8([1,10;254,90]));
459     assert_checkequal(cumprod(i,2,typ(:)), uint8([1,10;254,238]));
460     assert_checkequal(cumprod(i,3,typ(:)), double(i));
461 end
462 assert_checkequal(cumprod(i,"double"), [1,2540;254,22860]);
463 assert_checkequal(cumprod(i,"*","double"), [1,2540;254,22860]);
464 assert_checkequal(cumprod(i,1,"double"), [1,10;254,90]);
465 assert_checkequal(cumprod(i,2,"double"), [1,10;254,2286]);
466 assert_checkequal(cumprod(i,3,"double"), double(i));
467 //with hypermatrices
468 i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
469 for typ=list(list(),list("native"));
470     assert_checkequal(cumprod(i,typ(:)), matrix(uint8([1;254;236;76;76;0;0;0]), [2,2,2]));
471     assert_checkequal(cumprod(i,"*",typ(:)), matrix(uint8([1;254;236;76;76;0;0;0]), [2,2,2]));
472     assert_checkequal(cumprod(i,1,typ(:)), matrix(uint8([1;254;10;90;1;0;0;0]), [2,2,2]));
473     assert_checkequal(cumprod(i,2,typ(:)), matrix(uint8([1;254;10;238;1;0;0;0]), [2,2,2]));
474     assert_checkequal(cumprod(i,3,typ(:)), matrix(uint8([1;254;10;9;1;0;0;0]), [2,2,2]));
475     assert_checkequal(cumprod(i,5,typ(:)), double(i));
476 end
477 assert_checkequal(cumprod(i,"double"), matrix([1;254;2540;22860;22860;0;0;0], [2,2,2]));
478 assert_checkequal(cumprod(i,"*","double"), matrix([1;254;2540;22860;22860;0;0;0], [2,2,2]));
479 assert_checkequal(cumprod(i,1,"double"), matrix([1;254;10;90;1;0;0;0], [2,2,2]));
480 assert_checkequal(cumprod(i,2,"double"), matrix([1;254;10;2286;1;0;0;0], [2,2,2]));
481 assert_checkequal(cumprod(i,3,"double"), matrix([1;254;10;9;1;0;0;0], [2,2,2]));
482 assert_checkequal(cumprod(i,5,"double"), double(i));
483 //=======================================================================
484 //Matrices of Polynomials
485 s=%s;p=[s s+1;s^2 0];
486 T=list(list(),list("native"),list("double"));
487 for typ=T
488     assert_checkequal(cumprod(p,typ(:)), [s,s^3+s^4;s^3,0*s]);
489     assert_checkequal(cumprod(p,"*",typ(:)), [s,s^3+s^4;s^3,0*s]);
490     assert_checkequal(cumprod(p,1,typ(:)), [s,1+s;s^3,0*s]);
491     assert_checkequal(cumprod(p,2,typ(:)), [s,s+s^2;s^2,0*s]);
492     assert_checkequal(cumprod(p,3,typ(:)), p);
493 end
494 //with hypermatrices
495 s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
496 T=list(list(),list("native"),list("double"));
497 for typ=T
498     assert_checkequal(cumprod(p,typ(:)), matrix([s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s], [2,2,2]));
499     assert_checkequal(cumprod(p,"*",typ(:)), matrix([s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s], [2,2,2]));
500     assert_checkequal(cumprod(p,1,typ(:)), matrix([s;s^3;1+s;0*s;-1;0*s;0*s;0*s], [2,2,2]));
501     assert_checkequal(cumprod(p,2,typ(:)), matrix([s;s^2;s+s^2;0*s;-1;0*s;0*s;0*s], [2,2,2]));
502     assert_checkequal(cumprod(p,3,typ(:)), matrix([s;s^2;1+s;0*s;-s;0*s;0*s;0*s], [2,2,2]));
503     assert_checkequal(cumprod(p,5,typ(:)), p);
504 end
505 //=======================================================================
506 //Matrices of rationals
507 s=%s;r=1.0 ./[s s+1;s^2 1];
508 T=list(list(),list("native"),list("double"));
509 for typ=T
510     assert_checkequal(cumprod(r,typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
511     assert_checkequal(cumprod(r,"*",typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
512     assert_checkequal(cumprod(r,1,typ(:)), [1,1;1,1]./[s,1+s;s^3,1+s]);
513     assert_checkequal(cumprod(r,2,typ(:)), [1,1;1,1]./[s,s+s^2;s^2,s^2]);
514     assert_checkequal(cumprod(r,3,typ(:)), r);
515 end
516 //=======================================================================
517 ///Matrices of boolean
518 b=[%t %t;%f %t];
519 for typ=list(list(),list("double"));
520     assert_checkequal(cumprod(b,typ(:)), [1,0;0,0]);
521     assert_checkequal(cumprod(b,"*",typ(:)), [1,0;0,0]);
522     assert_checkequal(cumprod(b,1,typ(:)), [1,1;0,1]);
523     assert_checkequal(cumprod(b,2,typ(:)), [1,1;0,0]);
524     assert_checkequal(cumprod(b,3,typ(:)), double(b));
525 end
526 assert_checkequal(cumprod(b,"native"), [%t,%f;%f,%f]);
527 assert_checkequal(cumprod(b,"*","native"), [%t,%f;%f,%f]);
528 assert_checkequal(cumprod(b,1,"native"), [%t,%t;%f,%t]);
529 assert_checkequal(cumprod(b,2,"native"), [%t,%t;%f,%f]);
530 assert_checkequal(cumprod(b,3,"native"), b);
531 //with hypermatrices
532 b=[%t %t;%f %t];b(1,1,2)=%f;
533 for typ=list(list(),list("double"));
534     assert_checkequal(cumprod(b,typ(:)), matrix([1;0;0;0;0;0;0;0], [2,2,2]));
535     assert_checkequal(cumprod(b,"*",typ(:)), matrix([1;0;0;0;0;0;0;0], [2,2,2]));
536     assert_checkequal(cumprod(b,1,typ(:)), matrix([1;0;1;1;0;0;0;0], [2,2,2]));
537     assert_checkequal(cumprod(b,2,typ(:)), matrix([1;0;1;0;0;0;0;0], [2,2,2]));
538     assert_checkequal(cumprod(b,3,typ(:)), matrix([1;0;1;1;0;0;0;0], [2,2,2]));
539     assert_checkequal(cumprod(b,5,typ(:)), double(b));
540 end
541 assert_checkequal(cumprod(b,"native"), matrix([%t;%f;%f;%f;%f;%f;%f;%f], [2,2,2]));
542 assert_checkequal(cumprod(b,"*","native"), matrix([%t;%f;%f;%f;%f;%f;%f;%f], [2,2,2]));
543 assert_checkequal(cumprod(b,1,"native"), matrix([%t;%f;%t;%t;%f;%f;%f;%f], [2,2,2]));
544 assert_checkequal(cumprod(b,2,"native"), matrix([%t;%f;%t;%f;%f;%f;%f;%f], [2,2,2]));
545 assert_checkequal(cumprod(b,3,"native"), matrix([%t;%f;%t;%t;%f;%f;%f;%f], [2,2,2]));
546 assert_checkequal(cumprod(b,5,"native"), b);
547 //=======================================================================
548 //sparse matrices of floats
549 s=sparse([1 10 0;-1 0 9]);
550 T=list(list(),list("native"),list("double"));
551 for typ=T
552     assert_checkequal(cumprod(s,typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
553     assert_checkequal(cumprod(s,"*",typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
554     assert_checkequal(cumprod(s,1,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
555     assert_checkequal(cumprod(s,2,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
556     assert_checkequal(cumprod(s,3,typ(:)), s);
557 end
558 //=======================================================================
559 //sparse  matrices of boolean
560 bs=sparse([%t %t %f;%t %t %t]);
561 for typ=list(list(),list("double"));
562     assert_checkequal(cumprod(bs,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
563     assert_checkequal(cumprod(bs,"*",typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
564     assert_checkequal(cumprod(bs,1,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
565     assert_checkequal(cumprod(bs,2,typ(:)), sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3]));
566     assert_checkequal(cumprod(bs,3,typ(:)), bool2s(bs));
567 end
568 assert_checkequal(cumprod(bs,"native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
569 assert_checkequal(cumprod(bs,"*","native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
570 assert_checkequal(cumprod(bs,1,"native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
571 assert_checkequal(cumprod(bs,2,"native"), sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3]));
572 assert_checkequal(cumprod(bs,3,"native"), bs);
573 // TODO : test the "m" option
574 exec SCI/modules/elementary_functions/tests/unit_tests/prod.tst
575 // =============================================================================
576 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
577 // Copyright (C) 2010 - INRIA - Serge Steer
578 // Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
579 //
580 //  This file is distributed under the same license as the Scilab package.
581 // =============================================================================
582 // <-- CLI SHELL MODE -->
583 // prod
584 // Check error
585 d=[1 10;254 9];
586 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
587 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
588 assert_checkerror("prod(d, ""orient"")", refMsg);
589 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
590 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "prod", 2);
591 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
592 //==============================================================================
593 // matrices of integer
594 i = uint8(d);
595 assert_checkfalse(execstr("prod(i, ""orient"")"   ,"errcatch") == 0);
596 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
597 assert_checkerror("prod(i, ""orient"")", refMsg);
598 assert_checkfalse(execstr("prod(i, [""r"", ""c""])"   ,"errcatch") == 0);
599 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "prod", 2);
600 assert_checkerror("prod(i, [""r"", ""c""])", refMsg);
601 assert_checkfalse(execstr("prod(i,""r"", ""nat"")"   ,"errcatch") == 0);
602 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s or %s expected.\n"),"prod", 3, """native""", """double""");
603 assert_checkerror("prod(i,""r"", ""nat"")", refMsg);
604 assert_checkfalse(execstr("prod(i,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
605 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "prod", 3);
606 assert_checkerror("prod(i,""r"", [""nat"" ""dble""])", refMsg);
607 assert_checkfalse(execstr("prod(i,""orient"", ""t"")"   ,"errcatch") == 0);
608 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod",2,"""*"",""r"",""c"",""m""");
609 assert_checkerror("prod(i,""orient"", ""t"")", refMsg);
610 assert_checkfalse(execstr("prod(i,1,1)"   ,"errcatch") == 0);
611 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"), "prod", 3);
612 assert_checkerror("prod(i,1,1)", refMsg);
613 //==============================================================================
614 // sparse matrices
615 d = sparse(d);
616 assert_checkfalse(execstr("prod(d, ""orient"")","errcatch") == 0);
617 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod",2,"""*"",""r"",""c"",""m""");
618 assert_checkerror("prod(d, ""orient"")", refMsg);
619 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
620 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"prod",2);
621 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
622 //==============================================================================
623 // boolean matrices
624 d = [%f %t;%t %f];
625 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
626 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"prod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
627 assert_checkerror("prod(d, ""orient"")", refMsg);
628 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
629 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"prod",2);
630 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
631 assert_checkfalse(execstr("prod(d,""r"", ""nat"")"   ,"errcatch") == 0);
632 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s or %s expected.\n"),"prod", 3, """native""", """double""");
633 assert_checkerror("prod(d,""r"", ""nat"")", refMsg);
634 assert_checkfalse(execstr("prod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
635 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"prod",3);
636 assert_checkerror("prod(d,""r"", [""nat"" ""dble""])", refMsg);
637 assert_checkfalse(execstr("prod(d,""orient"", ""t"")"   ,"errcatch") == 0);
638 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
639 "prod",2,"""*"",""r"",""c"",""m""");
640 assert_checkerror("prod(d,""orient"", ""t"")", refMsg);
641 assert_checkfalse(execstr("prod(d,1,1)"   ,"errcatch") == 0);
642 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"),"prod",3);
643 assert_checkerror("prod(d,1,1)", refMsg);
644 //==============================================================================
645 // sparse boolean matrices
646 d = sparse(d);
647 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
648 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
649 "prod",2,"""*"",""r"",""c"",""m""");
650 assert_checkerror("prod(d, ""orient"")", refMsg);
651 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
652 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"prod",2);
653 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
654 assert_checkfalse(execstr("prod(d,""r"", ""nat"")"   ,"errcatch") == 0);
655 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"prod", 3, "native", "double");
656 assert_checkerror("prod(d,""r"", ""nat"")", refMsg);
657 assert_checkfalse(execstr("prod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
658 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"prod",3);
659 assert_checkerror("prod(d,""r"", [""nat"" ""dble""])", refMsg);
660 assert_checkfalse(execstr("prod(d,""orient"", ""t"")"   ,"errcatch") == 0);
661 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
662 "prod",2,"""*"",""r"",""c"",""m""");
663 assert_checkerror("prod(d,""orient"", ""t"")", refMsg);
664 assert_checkfalse(execstr("prod(d,1,1)"   ,"errcatch") == 0);
665 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"),"prod",3);
666 assert_checkerror("prod(d,1,1)", refMsg);
667 //==============================================================================
668 // hypermatrices
669 d = rand(2,2,2);
670 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
671 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
672 assert_checkerror("prod(d, ""orient"")", refMsg);
673 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
674 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"prod",2);
675 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
676 //==============================================================================
677 // polynome
678 s = poly(0, "s");
679 d = [s s^2;s*%i 1];
680 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
681 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"prod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
682 assert_checkerror("prod(d, ""orient"")", refMsg);
683 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
684 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"prod",2);
685 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
686 //==============================================================================
687 // rational matrices
688 s = poly(0, "s");
689 d = [1/s 1/s^2; 1/s 1];
690 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
691 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"prod",2,"""*"",""r"",""c"",""m""");
692 assert_checkerror("prod(d, ""orient"")", refMsg);
693 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
694 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"prod",2);
695 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
696 //empty matrices
697 T=list(list(),list("native"),list("double"));
698 for typ=T
699     assert_checkequal(prod([], typ(:)), 1);
700     assert_checkequal(prod([], "*", typ(:)), 1);
701     assert_checkequal(prod([], 1, typ(:)), []);
702     assert_checkequal(prod([], 2, typ(:)), []);
703     assert_checkequal(prod([], 3, typ(:)), []);
704 end
705 //=======================================================================
706 //float matrices
707 d=[1 10;254 9];
708 T=list(list(),list("native"),list("double"));
709 for typ=T
710     assert_checkequal(prod(d, typ(:)), 22860);
711     assert_checkequal(prod(d, "*", typ(:)), 22860);
712     assert_checkequal(prod(d, 1, typ(:)), [254 90]);
713     assert_checkequal(prod(d, 2, typ(:)), [10;2286]);
714     assert_checkequal(prod(d, 3, typ(:)), d);
715 end
716 //hypermatrices of floats
717 d=[1 10;254 9];d(:,:,2)=1;
718 T=list(list(),list("native"),list("double"));
719 for typ=T
720     assert_checkequal(prod(d, typ(:)), 22860);
721     assert_checkequal(prod(d, "*", typ(:)), 22860);
722     assert_checkequal(prod(d, 1, typ(:)), matrix([254;90;1;1], [1,2,2]));
723     assert_checkequal(prod(d, 2, typ(:)), matrix([10;2286;1;1], [2,1,2]));
724     assert_checkequal(prod(d, 3, typ(:)), [1,10;254,9]);
725     assert_checkequal(prod(d, 5, typ(:)), d);
726 end
727 //=======================================================================
728 //matrices of short integers
729 i=uint8([1 10;254 9]);
730 T=list(list(),list("native"));
731 for typ=T
732     assert_checkequal(prod(i, typ(:)), uint8(76));
733     assert_checkequal(prod(i, "*", typ(:)), uint8(76));
734     assert_checkequal(prod(i, 1, typ(:)), uint8([254 90]));
735     assert_checkequal(prod(i, 2, typ(:)), uint8([10;238]));
736     assert_checkequal(prod(i, 3, typ(:)), i);
737 end
738 assert_checkequal(prod(i, "double"), 22860);
739 assert_checkequal(prod(i, "*", "double"), 22860);
740 assert_checkequal(prod(i, 1, "double"), [254 90]);
741 assert_checkequal(prod(i, 2, "double"), [10;2286]);
742 assert_checkequal(prod(i, 3, "double"), double(i));
743 //with hypermatrices
744 i=uint8([1 10;254 9]);i(:,:,2)=uint8(1);
745 T = list(list(),list("native"));
746 for typ=T
747     assert_checkequal(prod(i, typ(:)), uint8(76));
748     assert_checkequal(prod(i, "*", typ(:)), uint8(76));
749     assert_checkequal(prod(i, 1, typ(:)), matrix(uint8([254;90;1;1]), [1,2,2]));
750     assert_checkequal(prod(i, 2, typ(:)), matrix(uint8([10;238;1;1]), [2,1,2]));
751     assert_checkequal(prod(i, 3, typ(:)), uint8([1,10;254,9]));
752     assert_checkequal(prod(i, 5, typ(:)), i);
753 end
754 assert_checkequal(prod(i, "double"), 22860);
755 assert_checkequal(prod(i, "*", "double"), 22860);
756 assert_checkequal(prod(i, 1, "double"), matrix([254;90;1;1], [1,2,2]));
757 assert_checkequal(prod(i, 2, "double"), matrix([10;2286;1;1], [2,1,2]));
758 assert_checkequal(prod(i, 3, "double"), [1,10;254,9]);
759 assert_checkequal(prod(i, 5, "double"), double(i));
760 //Polynomials
761 s=%s;p=[s s+1;s^2 1];
762 T=list(list(),list("native"),list("double"));
763 for typ=T
764     assert_checkequal(prod(p, typ(:)), s^3+s^4);
765     assert_checkequal(prod(p, "*", typ(:)), s^3+s^4);
766     assert_checkequal(prod(p, 1, typ(:)), [s^3,1+s]);
767     assert_checkequal(prod(p, 2, typ(:)), [s+s^2;s^2]);
768     assert_checkequal(prod(p, 3, typ(:)), p);
769 end
770 //with hypermatrices
771 s=%s;p=[s s+1;s^2 1];p(:,:,2)=[1 s;s+1 2];
772 T=list(list(),list("native"),list("double"));
773 for typ=T
774     assert_checkequal(prod(p, typ(:)), 2*s^4+4*s^5+2*s^6);
775     assert_checkequal(prod(p, "*", typ(:)), 2*s^4+4*s^5+2*s^6);
776     assert_checkequal(prod(p, 1, typ(:)), matrix([s^3;1+s;1+s;2*s], [1,2,2]));
777     assert_checkequal(prod(p, 2, typ(:)), matrix([s+s^2;s^2;s;2+2*s], [2,1,2]));
778     assert_checkequal(prod(p, 3, typ(:)), [s,s+s^2;s^2+s^3,2]);
779     assert_checkequal(prod(p, 5, typ(:)), p);
780 end
781 //=======================================================================
782 //Matrices of rationals
783 s=%s;r=1.0 ./[s s+1;s^2 1];
784 T=list(list(),list("native"),list("double"));
785 for typ=T
786     assert_checkequal(prod(r, typ(:)), 1.0/(s^3+s^4));
787     assert_checkequal(prod(r, "*", typ(:)), 1.0/(s^3+s^4));
788     assert_checkequal(prod(r, 1, typ(:)), [1,1]./[s^3,1+s]);
789     assert_checkequal(prod(r, 2, typ(:)), [1;1]./[s+s^2;s^2]);
790     assert_checkequal(prod(r, 3, typ(:)), r);
791 end
792 //=======================================================================
793 //Matrices of booleans
794 b=[%t %t; %f %t];
795 T = list(list(),list("double"));
796 for typ=T
797     assert_checkequal(prod(b, typ(:)), 0);
798     assert_checkequal(prod(b, "*", typ(:)), 0);
799     assert_checkequal(prod(b, 1, typ(:)), [0 1]);
800     assert_checkequal(prod(b, 2, typ(:)), [1;0]);
801     assert_checkequal(prod(b, 3, typ(:)), double(b));
802 end
803 assert_checkequal(prod(b, "native"), %f);
804 assert_checkequal(prod(b, "*", "native"), %f);
805 assert_checkequal(prod(b, 1, "native"), [%f %t]);
806 assert_checkequal(prod(b, 2, "native"), [%t;%f]);
807 assert_checkequal(prod(b, 3, "native"), b);
808 //with hypermatrices
809 b=[%t %t;%f %t];b(1,1,2)=%t;
810 T = list(list(),list("double"));
811 for typ=T
812     assert_checkequal(prod(b, typ(:)), 0);
813     assert_checkequal(prod(b, "*", typ(:)), 0);
814     assert_checkequal(prod(b, 1, typ(:)), matrix([0;1;0;0], [1,2,2]));
815     assert_checkequal(prod(b, 2, typ(:)), matrix([1;0;0;0], [2,1,2]));
816     assert_checkequal(prod(b, 3, typ(:)), [1,0;0,0]);
817     assert_checkequal(prod(b, 5, typ(:)), double(b));
818 end
819 assert_checkequal(prod(b, "native"), %f);
820 assert_checkequal(prod(b, "*", "native"), %f);
821 assert_checkequal(prod(b, 1, "native"), matrix([%f;%t;%f;%f], [1,2,2]));
822 assert_checkequal(prod(b, 2, "native"), matrix([%t;%f;%f;%f], [2,1,2]));
823 assert_checkequal(prod(b, 3, "native"), [%t,%f;%f,%f]);
824 assert_checkequal(prod(b, 5, "native"), b);
825 //=======================================================================
826 //sparse matrices of floats
827 s=sparse([1 10 2;-1 254 9]);
828 T=list(list(),list("native"),list("double"));
829 for typ=T
830     assert_checkequal(prod(s, typ(:)), -45720);
831     assert_checkequal(prod(s, "*", typ(:)), -45720);
832     assert_checkequal(prod(s, 1, typ(:)), sparse([-1 2540 18]));
833     assert_checkequal(prod(s, 2, typ(:)), sparse([20;-2286]));
834     assert_checkequal(prod(s, 3, typ(:)), s);
835 end
836 //=======================================================================
837 //sparse  matrices of boolean
838 bs=sparse([%t %t %f;%t %t %t]);
839 T = list(list(),list("double"));
840 for typ=T
841     assert_checkequal(prod(bs, typ(:)), 0);
842     assert_checkequal(prod(bs, "*", typ(:)), 0);
843     assert_checkequal(prod(bs, 1, typ(:)), sparse([1,1,0]));
844     assert_checkequal(prod(bs, 2, typ(:)), sparse([0;1]));
845     assert_checkequal(prod(bs, 3, typ(:)), bool2s(bs));
846 end
847 assert_checkequal(prod(bs, "native"), %f);
848 assert_checkequal(prod(bs, "*", "native"), %f);
849 assert_checkequal(prod(bs, 1, "native"), sparse([%t,%t,%f]));
850 assert_checkequal(prod(bs, 2, "native"), sparse([%f;%t]));
851 assert_checkequal(prod(bs, 3, "native"), bs);
852 // TODO : test the "m" option
853 exec SCI/modules/elementary_functions/tests/unit_tests/cumprod.tst
854 // =============================================================================
855 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
856 // Copyright (C) 2010 - INRIA - Serge Steer
857 // Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
858 // Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
859 //
860 //  This file is distributed under the same license as the Scilab package.
861 // =============================================================================
862 // <-- CLI SHELL MODE -->
863 // Check error
864 //==============================================================================
865 //float matrices
866 d=[1 10;254 9];
867 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
868 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "cumprod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
869 assert_checkerror("cumprod(d, ""orient"")", refMsg);
870 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
871 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "cumprod", 2);
872 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
873 //==============================================================================
874 // matrices of integer
875 i = uint8(d);
876 assert_checkfalse(execstr("cumprod(i, ""orient"")"   ,"errcatch") == 0);
877 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "cumprod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
878 assert_checkerror("cumprod(i, ""orient"")", refMsg);
879 assert_checkfalse(execstr("cumprod(i, [""r"", ""c""])"   ,"errcatch") == 0);
880 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "cumprod", 2);
881 assert_checkerror("cumprod(i, [""r"", ""c""])", refMsg);
882 assert_checkfalse(execstr("cumprod(i,""r"", ""nat"")"   ,"errcatch") == 0);
883 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s or %s expected.\n"),"cumprod", 3, """native""", """double""");
884 assert_checkerror("cumprod(i,""r"", ""nat"")", refMsg);
885 assert_checkfalse(execstr("cumprod(i,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
886 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "cumprod", 3);
887 assert_checkerror("cumprod(i,""r"", [""nat"" ""dble""])", refMsg);
888 assert_checkfalse(execstr("cumprod(i,""orient"", ""t"")"   ,"errcatch") == 0);
889 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "cumprod",2,"""*"",""r"",""c"",""m""");
890 assert_checkerror("cumprod(i,""orient"", ""t"")", refMsg);
891 assert_checkfalse(execstr("cumprod(i,1,1)"   ,"errcatch") == 0);
892 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"), "cumprod", 3);
893 assert_checkerror("cumprod(i,1,1)", refMsg);
894 //==============================================================================
895 // sparse matrices
896 d = sparse(d);
897 assert_checkfalse(execstr("cumprod(d, ""orient"")","errcatch") == 0);
898 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "cumprod",2,"""*"",""r"",""c"",""m""");
899 assert_checkerror("cumprod(d, ""orient"")", refMsg);
900 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
901 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"cumprod",2);
902 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
903 //==============================================================================
904 // boolean matrices
905 d = [%f %t;%t %f];
906 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
907 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"cumprod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
908 assert_checkerror("cumprod(d, ""orient"")", refMsg);
909 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
910 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"cumprod",2);
911 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
912 assert_checkfalse(execstr("cumprod(d,""r"", ""nat"")"   ,"errcatch") == 0);
913 refMsg = msprintf(_("%s: Wrong value for input argument #%d: %s or %s expected.\n"),"cumprod", 3, """native""", """double""");
914 assert_checkerror("cumprod(d,""r"", ""nat"")", refMsg);
915 assert_checkfalse(execstr("cumprod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
916 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"cumprod",3);
917 assert_checkerror("cumprod(d,""r"", [""nat"" ""dble""])", refMsg);
918 assert_checkfalse(execstr("cumprod(d,""orient"", ""t"")"   ,"errcatch") == 0);
919 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
920 "cumprod",2,"""*"",""r"",""c"",""m""");
921 assert_checkerror("cumprod(d,""orient"", ""t"")", refMsg);
922 assert_checkfalse(execstr("cumprod(d,1,1)"   ,"errcatch") == 0);
923 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"),"cumprod",3);
924 assert_checkerror("cumprod(d,1,1)", refMsg);
925 //==============================================================================
926 // sparse boolean matrices
927 d = sparse(d);
928 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
929 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
930 "cumprod",2,"""*"",""r"",""c"",""m""");
931 assert_checkerror("cumprod(d, ""orient"")", refMsg);
932 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
933 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"cumprod",2);
934 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
935 assert_checkfalse(execstr("cumprod(d,""r"", ""nat"")"   ,"errcatch") == 0);
936 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"cumprod", 3, "native", "double");
937 assert_checkerror("cumprod(d,""r"", ""nat"")", refMsg);
938 assert_checkfalse(execstr("cumprod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
939 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"cumprod",3);
940 assert_checkerror("cumprod(d,""r"", [""nat"" ""dble""])", refMsg);
941 assert_checkfalse(execstr("cumprod(d,""orient"", ""t"")"   ,"errcatch") == 0);
942 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
943 "cumprod",2,"""*"",""r"",""c"",""m""");
944 assert_checkerror("cumprod(d,""orient"", ""t"")", refMsg);
945 assert_checkfalse(execstr("cumprod(d,1,1)"   ,"errcatch") == 0);
946 refMsg = msprintf(_("%s: Wrong type for input argument #%d: string expected.\n"),"cumprod",3);
947 assert_checkerror("cumprod(d,1,1)", refMsg);
948 //==============================================================================
949 // hypermatrices
950 d = rand(2,2,2);
951 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
952 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "cumprod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
953 assert_checkerror("cumprod(d, ""orient"")", refMsg);
954 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
955 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"cumprod",2);
956 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
957 //==============================================================================
958 // polynome
959 s = poly(0, "s");
960 d = [s s^2;s*%i 1];
961 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
962 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"cumprod",2,"""*"",""r"",""c"",""m"",""native"",""double""");
963 assert_checkerror("cumprod(d, ""orient"")", refMsg);
964 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
965 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A scalar string expected.\n"),"cumprod",2);
966 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
967 //==============================================================================
968 // rational matrices
969 s = poly(0, "s");
970 d = [1/s 1/s^2; 1/s 1];
971 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
972 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
973 "cumprod",2,"""*"",""r"",""c"",""m""");
974 assert_checkerror("cumprod(d, ""orient"")", refMsg);
975 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
976 refMsg = msprintf(_("%s: Wrong size for input argument #%d: string expected.\n"),"cumprod",2);
977 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
978 //cumprod
979 //Empty matrices
980 T=list(list(),list("native"),list("double"));
981 for typ=T
982     assert_checkequal(cumprod([],typ(:)), []);
983     assert_checkequal(cumprod([],"*",typ(:)), []);
984     assert_checkequal(cumprod([],1,typ(:)), []);
985     assert_checkequal(cumprod([],2,typ(:)), []);
986     assert_checkequal(cumprod([],3,typ(:)), []);
987 end
988 //=======================================================================
989 //float matrices
990 d=[1 10;254 9];
991 T=list(list(),list("native"),list("double"));
992 for typ=T
993     assert_checkequal(cumprod(d,typ(:)), [1,2540;254,22860]);
994     assert_checkequal(cumprod(d,"*",typ(:)), [1,2540;254,22860]);
995     assert_checkequal(cumprod(d,1,typ(:)), [1,10;254,90]);
996     assert_checkequal(cumprod(d,2,typ(:)), [1,10;254,2286]);
997     assert_checkequal(cumprod(d,3,typ(:)), d);
998 end
999 //hypermatrices of floats
1000 d=[1 10;254 9];d(1,1,2)=1;
1001 T=list(list(),list("native"),list("double"));
1002 for typ=T
1003     assert_checkequal(cumprod(d,typ(:)), matrix([1;254;2540;22860;22860;0;0;0], [2,2,2]));
1004     assert_checkequal(cumprod(d,"*",typ(:)), matrix([1;254;2540;22860;22860;0;0;0], [2,2,2]));
1005     assert_checkequal(cumprod(d,1,typ(:)), matrix([1;254;10;90;1;0;0;0], [2,2,2]));
1006     assert_checkequal(cumprod(d,2,typ(:)), matrix([1;254;10;2286;1;0;0;0], [2,2,2]));
1007     assert_checkequal(cumprod(d,3,typ(:)), matrix([1;254;10;9;1;0;0;0], [2,2,2]));
1008     assert_checkequal(cumprod(d,5,typ(:)), d);
1009 end
1010 //=======================================================================
1011 //Integers
1012 i=uint8([1 10;254 9]);
1013 for typ=list(list(),list("native"));
1014     assert_checkequal(cumprod(i,typ(:)), uint8([1,236;254,76]));
1015     assert_checkequal(cumprod(i,"*",typ(:)), uint8([1,236;254,76]));
1016     assert_checkequal(cumprod(i,1,typ(:)), uint8([1,10;254,90]));
1017     assert_checkequal(cumprod(i,2,typ(:)), uint8([1,10;254,238]));
1018     assert_checkequal(cumprod(i,3,typ(:)), double(i));
1019 end
1020 assert_checkequal(cumprod(i,"double"), [1,2540;254,22860]);
1021 assert_checkequal(cumprod(i,"*","double"), [1,2540;254,22860]);
1022 assert_checkequal(cumprod(i,1,"double"), [1,10;254,90]);
1023 assert_checkequal(cumprod(i,2,"double"), [1,10;254,2286]);
1024 assert_checkequal(cumprod(i,3,"double"), double(i));
1025 //with hypermatrices
1026 i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
1027 for typ=list(list(),list("native"));
1028     assert_checkequal(cumprod(i,typ(:)), matrix(uint8([1;254;236;76;76;0;0;0]), [2,2,2]));
1029     assert_checkequal(cumprod(i,"*",typ(:)), matrix(uint8([1;254;236;76;76;0;0;0]), [2,2,2]));
1030     assert_checkequal(cumprod(i,1,typ(:)), matrix(uint8([1;254;10;90;1;0;0;0]), [2,2,2]));
1031     assert_checkequal(cumprod(i,2,typ(:)), matrix(uint8([1;254;10;238;1;0;0;0]), [2,2,2]));
1032     assert_checkequal(cumprod(i,3,typ(:)), matrix(uint8([1;254;10;9;1;0;0;0]), [2,2,2]));
1033     assert_checkequal(cumprod(i,5,typ(:)), double(i));
1034 end
1035 assert_checkequal(cumprod(i,"double"), matrix([1;254;2540;22860;22860;0;0;0], [2,2,2]));
1036 assert_checkequal(cumprod(i,"*","double"), matrix([1;254;2540;22860;22860;0;0;0], [2,2,2]));
1037 assert_checkequal(cumprod(i,1,"double"), matrix([1;254;10;90;1;0;0;0], [2,2,2]));
1038 assert_checkequal(cumprod(i,2,"double"), matrix([1;254;10;2286;1;0;0;0], [2,2,2]));
1039 assert_checkequal(cumprod(i,3,"double"), matrix([1;254;10;9;1;0;0;0], [2,2,2]));
1040 assert_checkequal(cumprod(i,5,"double"), double(i));
1041 //=======================================================================
1042 //Matrices of Polynomials
1043 s=%s;p=[s s+1;s^2 0];
1044 T=list(list(),list("native"),list("double"));
1045 for typ=T
1046     assert_checkequal(cumprod(p,typ(:)), [s,s^3+s^4;s^3,0*s]);
1047     assert_checkequal(cumprod(p,"*",typ(:)), [s,s^3+s^4;s^3,0*s]);
1048     assert_checkequal(cumprod(p,1,typ(:)), [s,1+s;s^3,0*s]);
1049     assert_checkequal(cumprod(p,2,typ(:)), [s,s+s^2;s^2,0*s]);
1050     assert_checkequal(cumprod(p,3,typ(:)), p);
1051 end
1052 //with hypermatrices
1053 s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
1054 T=list(list(),list("native"),list("double"));
1055 for typ=T
1056     assert_checkequal(cumprod(p,typ(:)), matrix([s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s], [2,2,2]));
1057     assert_checkequal(cumprod(p,"*",typ(:)), matrix([s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s], [2,2,2]));
1058     assert_checkequal(cumprod(p,1,typ(:)), matrix([s;s^3;1+s;0*s;-1;0*s;0*s;0*s], [2,2,2]));
1059     assert_checkequal(cumprod(p,2,typ(:)), matrix([s;s^2;s+s^2;0*s;-1;0*s;0*s;0*s], [2,2,2]));
1060     assert_checkequal(cumprod(p,3,typ(:)), matrix([s;s^2;1+s;0*s;-s;0*s;0*s;0*s], [2,2,2]));
1061     assert_checkequal(cumprod(p,5,typ(:)), p);
1062 end
1063 //=======================================================================
1064 //Matrices of rationals
1065 s=%s;r=1.0 ./[s s+1;s^2 1];
1066 T=list(list(),list("native"),list("double"));
1067 for typ=T
1068     assert_checkequal(cumprod(r,typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
1069     assert_checkequal(cumprod(r,"*",typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
1070     assert_checkequal(cumprod(r,1,typ(:)), [1,1;1,1]./[s,1+s;s^3,1+s]);
1071     assert_checkequal(cumprod(r,2,typ(:)), [1,1;1,1]./[s,s+s^2;s^2,s^2]);
1072     assert_checkequal(cumprod(r,3,typ(:)), r);
1073 end
1074 //=======================================================================
1075 ///Matrices of boolean
1076 b=[%t %t;%f %t];
1077 for typ=list(list(),list("double"));
1078     assert_checkequal(cumprod(b,typ(:)), [1,0;0,0]);
1079     assert_checkequal(cumprod(b,"*",typ(:)), [1,0;0,0]);
1080     assert_checkequal(cumprod(b,1,typ(:)), [1,1;0,1]);
1081     assert_checkequal(cumprod(b,2,typ(:)), [1,1;0,0]);
1082     assert_checkequal(cumprod(b,3,typ(:)), double(b));
1083 end
1084 assert_checkequal(cumprod(b,"native"), [%t,%f;%f,%f]);
1085 assert_checkequal(cumprod(b,"*","native"), [%t,%f;%f,%f]);
1086 assert_checkequal(cumprod(b,1,"native"), [%t,%t;%f,%t]);
1087 assert_checkequal(cumprod(b,2,"native"), [%t,%t;%f,%f]);
1088 assert_checkequal(cumprod(b,3,"native"), b);
1089 //with hypermatrices
1090 b=[%t %t;%f %t];b(1,1,2)=%f;
1091 for typ=list(list(),list("double"));
1092     assert_checkequal(cumprod(b,typ(:)), matrix([1;0;0;0;0;0;0;0], [2,2,2]));
1093     assert_checkequal(cumprod(b,"*",typ(:)), matrix([1;0;0;0;0;0;0;0], [2,2,2]));
1094     assert_checkequal(cumprod(b,1,typ(:)), matrix([1;0;1;1;0;0;0;0], [2,2,2]));
1095     assert_checkequal(cumprod(b,2,typ(:)), matrix([1;0;1;0;0;0;0;0], [2,2,2]));
1096     assert_checkequal(cumprod(b,3,typ(:)), matrix([1;0;1;1;0;0;0;0], [2,2,2]));
1097     assert_checkequal(cumprod(b,5,typ(:)), double(b));
1098 end
1099 assert_checkequal(cumprod(b,"native"), matrix([%t;%f;%f;%f;%f;%f;%f;%f], [2,2,2]));
1100 assert_checkequal(cumprod(b,"*","native"), matrix([%t;%f;%f;%f;%f;%f;%f;%f], [2,2,2]));
1101 assert_checkequal(cumprod(b,1,"native"), matrix([%t;%f;%t;%t;%f;%f;%f;%f], [2,2,2]));
1102 assert_checkequal(cumprod(b,2,"native"), matrix([%t;%f;%t;%f;%f;%f;%f;%f], [2,2,2]));
1103 assert_checkequal(cumprod(b,3,"native"), matrix([%t;%f;%t;%t;%f;%f;%f;%f], [2,2,2]));
1104 assert_checkequal(cumprod(b,5,"native"), b);
1105 //=======================================================================
1106 //sparse matrices of floats
1107 s=sparse([1 10 0;-1 0 9]);
1108 T=list(list(),list("native"),list("double"));
1109 for typ=T
1110     assert_checkequal(cumprod(s,typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
1111     assert_checkequal(cumprod(s,"*",typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
1112     assert_checkequal(cumprod(s,1,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
1113     assert_checkequal(cumprod(s,2,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
1114     assert_checkequal(cumprod(s,3,typ(:)), s);
1115 end
1116 //=======================================================================
1117 //sparse  matrices of boolean
1118 bs=sparse([%t %t %f;%t %t %t]);
1119 for typ=list(list(),list("double"));
1120     assert_checkequal(cumprod(bs,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
1121     assert_checkequal(cumprod(bs,"*",typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
1122     assert_checkequal(cumprod(bs,1,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
1123     assert_checkequal(cumprod(bs,2,typ(:)), sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3]));
1124     assert_checkequal(cumprod(bs,3,typ(:)), bool2s(bs));
1125 end
1126 assert_checkequal(cumprod(bs,"native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
1127 assert_checkequal(cumprod(bs,"*","native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
1128 assert_checkequal(cumprod(bs,1,"native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
1129 assert_checkequal(cumprod(bs,2,"native"), sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3]));
1130 assert_checkequal(cumprod(bs,3,"native"), bs);
1131 // TODO : test the "m" option