f1e8cb62e3036b5882e9176516e00492d7830292
[scilab.git] / scilab / modules / integer / tests / nonreg_tests / bug_3842.dia.ref
1 // =============================================================================
2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 // Copyright (C) 2010 - INRIA - Serge Steer
4 //
5 //  This file is distributed under the same license as the Scilab package.
6 // =============================================================================
7 //
8 // <-- Non-regression test for bug 3842 -->
9 //
10 // <-- Bugzilla URL -->
11 // http://bugzilla.scilab.org/show_bug.cgi?id=3842
12 //
13 // <-- Short Description -->
14 // sum applyed to integer arrys can only procuce results computed using native operations.
15 exec SCI/modules/elementary_functions/tests/unit_tests/prod.tst
16  
17 // =============================================================================
18  
19 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
20  
21 // Copyright (C) 2010 - INRIA - Serge Steer
22  
23 // Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
24  
25 //
26  
27 //  This file is distributed under the same license as the Scilab package.
28  
29 // =============================================================================
30  
31  
32 // <-- CLI SHELL MODE 
33  
34 // prod
35  
36 // Check error
37  
38 d=[1 10;254 9];
39  
40 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
41  
42 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
43  
44 assert_checkerror("prod(d, ""orient"")", refMsg);
45  
46  
47 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
48  
49 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
50  
51 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
52  
53  
54 //==============================================================================
55  
56 // matrices of integer
57  
58 i = uint8(d);
59  
60 assert_checkfalse(execstr("prod(i, ""orient"")"   ,"errcatch") == 0);
61  
62 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
63  
64 assert_checkerror("prod(i, ""orient"")", refMsg);
65  
66  
67 assert_checkfalse(execstr("prod(i, [""r"", ""c""])"   ,"errcatch") == 0);
68  
69 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
70  
71 assert_checkerror("prod(i, [""r"", ""c""])", refMsg);
72  
73  
74 assert_checkfalse(execstr("prod(i,""r"", ""nat"")"   ,"errcatch") == 0);
75  
76 refMsg = msprintf(_("Wrong value for argument #%d.\n"), 3);
77  
78 assert_checkerror("prod(i,""r"", ""nat"")", refMsg);
79  
80  
81 assert_checkfalse(execstr("prod(i,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
82  
83 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 3);
84  
85 assert_checkerror("prod(i,""r"", [""nat"" ""dble""])", refMsg);
86  
87  
88 assert_checkfalse(execstr("prod(i,""orient"", ""t"")"   ,"errcatch") == 0);
89  
90 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
91  
92 assert_checkerror("prod(i,""orient"", ""t"")", refMsg);
93  
94  
95 assert_checkfalse(execstr("prod(i,1,1)"   ,"errcatch") == 0);
96  
97 refMsg = msprintf(_("Wrong type for argument #%d: String expected.\n"), 3);
98  
99 assert_checkerror("prod(i,1,1)", refMsg);
100  
101  
102 //==============================================================================
103  
104 // sparse matrices
105  
106 d = sparse(d);
107  
108 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
109  
110 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
111  
112 assert_checkerror("prod(d, ""orient"")", refMsg);
113  
114  
115 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
116  
117 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
118  
119 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
120  
121  
122 //==============================================================================
123  
124 // boolean matrices
125  
126 d = [%f %t;%t %f];
127  
128 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
129  
130 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"prod",2,"""*"",""r"",""c"",""m""");
131  
132 assert_checkerror("prod(d, ""orient"")", refMsg);
133  
134  
135 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
136  
137 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
138  
139 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
140  
141  
142 assert_checkfalse(execstr("prod(d,""r"", ""nat"")"   ,"errcatch") == 0);
143  
144 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"prod", 3, "native", "double");
145  
146 assert_checkerror("prod(d,""r"", ""nat"")", refMsg);
147  
148  
149 assert_checkfalse(execstr("prod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
150  
151 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",3);
152  
153 assert_checkerror("prod(d,""r"", [""nat"" ""dble""])", refMsg);
154  
155  
156 assert_checkfalse(execstr("prod(d,""orient"", ""t"")"   ,"errcatch") == 0);
157  
158 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
159 "prod",2,"""*"",""r"",""c"",""m""");
160  
161 assert_checkerror("prod(d,""orient"", ""t"")", refMsg);
162  
163  
164 assert_checkfalse(execstr("prod(d,1,1)"   ,"errcatch") == 0);
165  
166 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"),"prod",3);
167  
168 assert_checkerror("prod(d,1,1)", refMsg);
169  
170  
171 //==============================================================================
172  
173 // sparse boolean matrices
174  
175 d = sparse(d);
176  
177 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
178  
179 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
180 "prod",2,"""*"",""r"",""c"",""m""");
181  
182 assert_checkerror("prod(d, ""orient"")", refMsg);
183  
184  
185 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
186  
187 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
188  
189 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
190  
191  
192 assert_checkfalse(execstr("prod(d,""r"", ""nat"")"   ,"errcatch") == 0);
193  
194 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"prod", 3, "native", "double");
195  
196 assert_checkerror("prod(d,""r"", ""nat"")", refMsg);
197  
198  
199 assert_checkfalse(execstr("prod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
200  
201 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",3);
202  
203 assert_checkerror("prod(d,""r"", [""nat"" ""dble""])", refMsg);
204  
205  
206 assert_checkfalse(execstr("prod(d,""orient"", ""t"")"   ,"errcatch") == 0);
207  
208 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
209 "prod",2,"""*"",""r"",""c"",""m""");
210  
211 assert_checkerror("prod(d,""orient"", ""t"")", refMsg);
212  
213  
214 assert_checkfalse(execstr("prod(d,1,1)"   ,"errcatch") == 0);
215  
216 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"),"prod",3);
217  
218 assert_checkerror("prod(d,1,1)", refMsg);
219  
220  
221 //==============================================================================
222  
223 // hypermatrices
224  
225 d = rand(2,2,2);
226  
227 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
228  
229 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
230 "prod",2,"""*"",""r"",""c"",""m""");
231  
232 assert_checkerror("prod(d, ""orient"")", refMsg);
233  
234  
235 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
236  
237 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
238  
239 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
240  
241  
242 //==============================================================================
243  
244 // polynome
245  
246 s = poly(0, "s");
247  
248 d = [s s^2;s*%i 1];
249  
250 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
251  
252 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
253 "prod",2,"""*"",""r"",""c"",""m""");
254  
255 assert_checkerror("prod(d, ""orient"")", refMsg);
256  
257  
258 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
259  
260 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
261  
262 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
263  
264  
265 //==============================================================================
266  
267 // rational matrices
268  
269 s = poly(0, "s");
270  
271 d = [1/s 1/s^2; 1/s 1];
272  
273 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
274  
275 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
276 "prod",2,"""*"",""r"",""c"",""m""");
277  
278 assert_checkerror("prod(d, ""orient"")", refMsg);
279  
280  
281 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
282  
283 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
284  
285 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
286  
287  
288 //empty matrices
289  
290 T=list(list(),list("native"),list("double"));
291  
292 for typ=T
293     assert_checkequal(prod([], typ(:)), 1);
294     assert_checkequal(prod([], "*", typ(:)), 1);
295     assert_checkequal(prod([], 1, typ(:)), []);
296     assert_checkequal(prod([], 2, typ(:)), []);
297     assert_checkequal(prod([], 3, typ(:)), []);
298 end
299  
300  
301 //=======================================================================
302  
303 //float matrices
304  
305 d=[1 10;254 9];
306  
307 T=list(list(),list("native"),list("double"));
308  
309 for typ=T
310     assert_checkequal(prod(d, typ(:)), 22860);
311     assert_checkequal(prod(d, "*", typ(:)), 22860);
312     assert_checkequal(prod(d, 1, typ(:)), [254 90]);
313     assert_checkequal(prod(d, 2, typ(:)), [10;2286]);
314     assert_checkequal(prod(d, 3, typ(:)), d);
315 end
316  
317  
318  
319 //hypermatrices of floats
320  
321 d=[1 10;254 9];d(:,:,2)=1;
322  
323 T=list(list(),list("native"),list("double"));
324  
325 for typ=T
326     assert_checkequal(prod(d, typ(:)), 22860);
327     assert_checkequal(prod(d, "*", typ(:)), 22860);
328     assert_checkequal(prod(d, 1, typ(:)), hypermat([1,2,2],[254;90;1;1]));
329     assert_checkequal(prod(d, 2, typ(:)), hypermat([2,1,2],[10;2286;1;1]));
330     assert_checkequal(prod(d, 3, typ(:)), [1,10;254,9]);
331     assert_checkequal(prod(d, 5, typ(:)), d);
332 end
333  
334  
335 //=======================================================================
336  
337 //matrices of short integers
338  
339 i=uint8([1 10;254 9]);
340  
341 T=list(list(),list("native"));
342  
343 for typ=T
344     assert_checkequal(prod(i, typ(:)), uint8(76));
345     assert_checkequal(prod(i, "*", typ(:)), uint8(76));
346     assert_checkequal(prod(i, 1, typ(:)), uint8([254 90]));
347     assert_checkequal(prod(i, 2, typ(:)), uint8([10;238]));
348     assert_checkequal(prod(i, 3, typ(:)), double(i));
349 end
350  
351  
352 assert_checkequal(prod(i, "double"), 22860);
353  
354 assert_checkequal(prod(i, "*", "double"), 22860);
355  
356 assert_checkequal(prod(i, 1, "double"), [254 90]);
357  
358 assert_checkequal(prod(i, 2, "double"), [10;2286]);
359  
360 assert_checkequal(prod(i, 3, "double"), double(i));
361  
362  
363 //with hypermatrices
364  
365 i=uint8([1 10;254 9]);i(:,:,2)=uint8(1);
366  
367 T = list(list(),list("native"));
368  
369 for typ=T
370     assert_checkequal(prod(i, typ(:)), uint8(76));
371     assert_checkequal(prod(i, "*", typ(:)), uint8(76));
372     assert_checkequal(prod(i, 1, typ(:)), hypermat([1,2,2],uint8([254;90;1;1])));
373     assert_checkequal(prod(i, 2, typ(:)), hypermat([2,1,2],uint8([10;238;1;1])));
374     assert_checkequal(prod(i, 3, typ(:)), uint8([1,10;254,9]));
375     assert_checkequal(prod(i, 5, typ(:)), i);
376 end
377  
378  
379 assert_checkequal(prod(i, "double"), 22860);
380  
381 assert_checkequal(prod(i, "*", "double"), 22860);
382  
383 assert_checkequal(prod(i, 1, "double"), hypermat([1,2,2],[254;90;1;1]));
384  
385 assert_checkequal(prod(i, 2, "double"), hypermat([2,1,2],[10;2286;1;1]));
386  
387 assert_checkequal(prod(i, 3, "double"), [1,10;254,9]);
388  
389 assert_checkequal(prod(i, 5, "double"), double(i));
390  
391  
392 //Polynomials
393  
394 s=%s;p=[s s+1;s^2 1];
395  
396 T=list(list(),list("native"),list("double"));
397  
398 for typ=T
399     assert_checkequal(prod(p, typ(:)), s^3+s^4);
400     assert_checkequal(prod(p, "*", typ(:)), s^3+s^4);
401     assert_checkequal(prod(p, 1, typ(:)), [s^3,1+s]);
402     assert_checkequal(prod(p, 2, typ(:)), [s+s^2;s^2]);
403     assert_checkequal(prod(p, 3, typ(:)), p);
404 end
405  
406 //with hypermatrices
407  
408 s=%s;p=[s s+1;s^2 1];p(:,:,2)=[1 s;s+1 2];
409  
410 T=list(list(),list("native"),list("double"));
411  
412 for typ=T
413     assert_checkequal(prod(p, typ(:)), 2*s^4+4*s^5+2*s^6);
414     assert_checkequal(prod(p, "*", typ(:)), 2*s^4+4*s^5+2*s^6);
415     assert_checkequal(prod(p, 1, typ(:)), hypermat([1,2,2],[s^3;1+s;1+s;2*s]));
416     assert_checkequal(prod(p, 2, typ(:)), hypermat([2,1,2],[s+s^2;s^2;s;2+2*s]));
417     assert_checkequal(prod(p, 3, typ(:)), [s,s+s^2;s^2+s^3,2]);
418     assert_checkequal(prod(p, 5, typ(:)), p);
419 end
420  
421  
422 //=======================================================================
423  
424 //Matrices of rationals
425  
426 s=%s;r=1.0 ./[s s+1;s^2 1];
427  
428 T=list(list(),list("native"),list("double"));
429  
430 for typ=T
431     assert_checkequal(prod(r, typ(:)), 1.0/(s^3+s^4));
432     assert_checkequal(prod(r, "*", typ(:)), 1.0/(s^3+s^4));
433     assert_checkequal(prod(r, 1, typ(:)), [1,1]./[s^3,1+s]);
434     assert_checkequal(prod(r, 2, typ(:)), [1;1]./[s+s^2;s^2]);
435     assert_checkequal(prod(r, 3, typ(:)), r);
436 end
437  
438  
439 //=======================================================================
440  
441 //Matrices of booleans
442  
443 b=[%t %t; %f %t];
444  
445 T = list(list(),list("double"));
446  
447 for typ=T
448     assert_checkequal(prod(b, typ(:)), 0);
449     assert_checkequal(prod(b, "*", typ(:)), 0);
450     assert_checkequal(prod(b, 1, typ(:)), [0 1]);
451     assert_checkequal(prod(b, 2, typ(:)), [1;0]);
452     assert_checkequal(prod(b, 3, typ(:)), double(b));
453 end
454  
455  
456 assert_checkequal(prod(b, "native"), %f);
457  
458 assert_checkequal(prod(b, "*", "native"), %f);
459  
460 assert_checkequal(prod(b, 1, "native"), [%f %t]);
461  
462 assert_checkequal(prod(b, 2, "native"), [%t;%f]);
463  
464 assert_checkequal(prod(b, 3, "native"), b);
465  
466  
467 //with hypermatrices
468  
469 b=[%t %t;%f %t];b(1,1,2)=%t;
470  
471 T = list(list(),list("double"));
472  
473 for typ=T
474     assert_checkequal(prod(b, typ(:)), 0);
475     assert_checkequal(prod(b, "*", typ(:)), 0);
476     assert_checkequal(prod(b, 1, typ(:)), hypermat([1,2,2],[0;1;0;0]));
477     assert_checkequal(prod(b, 2, typ(:)), hypermat([2,1,2],[1;0;0;0]));
478     assert_checkequal(prod(b, 3, typ(:)), [1,0;0,0]);
479     assert_checkequal(prod(b, 5, typ(:)), double(b));
480 end
481  
482  
483 assert_checkequal(prod(b, "native"), %f);
484  
485 assert_checkequal(prod(b, "*", "native"), %f);
486  
487 assert_checkequal(prod(b, 1, "native"), hypermat([1,2,2],[%f;%t;%f;%f]));
488  
489 assert_checkequal(prod(b, 2, "native"), hypermat([2,1,2],[%t;%f;%f;%f]));
490  
491 assert_checkequal(prod(b, 3, "native"), [%t,%f;%f,%f]);
492  
493 assert_checkequal(prod(b, 5, "native"), b);
494  
495  
496 //=======================================================================
497  
498 //sparse matrices of floats
499  
500 s=sparse([1 10 2;-1 254 9]);
501  
502 T=list(list(),list("native"),list("double"));
503  
504 for typ=T
505     assert_checkequal(prod(s, typ(:)), -45720);
506     assert_checkequal(prod(s, "*", typ(:)), -45720);
507     assert_checkequal(prod(s, 1, typ(:)), sparse([-1 2540 18]));
508     assert_checkequal(prod(s, 2, typ(:)), sparse([20;-2286]));
509     assert_checkequal(prod(s, 3, typ(:)), s);
510 end
511  
512  
513 //=======================================================================
514  
515 //sparse  matrices of boolean
516  
517 bs=sparse([%t %t %f;%t %t %t]);
518  
519 T = list(list(),list("double"));
520  
521 for typ=T
522     assert_checkequal(prod(bs, typ(:)), 0);
523     assert_checkequal(prod(bs, "*", typ(:)), 0);
524     assert_checkequal(prod(bs, 1, typ(:)), sparse([1,1,0]));
525     assert_checkequal(prod(bs, 2, typ(:)), sparse([0;1]));
526     assert_checkequal(prod(bs, 3, typ(:)), bool2s(bs));
527 end
528  
529  
530 assert_checkequal(prod(bs, "native"), %f);
531  
532 assert_checkequal(prod(bs, "*", "native"), %f);
533  
534 assert_checkequal(prod(bs, 1, "native"), sparse([%t,%t,%f]));
535  
536 assert_checkequal(prod(bs, 2, "native"), sparse([%f;%t]));
537  
538 assert_checkequal(prod(bs, 3, "native"), bs);
539  
540  
541 // TODO : test the "m" option
542  
543 exec SCI/modules/elementary_functions/tests/unit_tests/cumprod.tst
544  
545 // =============================================================================
546  
547 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
548  
549 // Copyright (C) 2010 - INRIA - Serge Steer
550  
551 // Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
552  
553 // Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
554  
555 //
556  
557 //  This file is distributed under the same license as the Scilab package.
558  
559 // =============================================================================
560  
561  
562 // <-- CLI SHELL MODE 
563  
564 // Check error
565  
566 //==============================================================================
567  
568 //float matrices
569  
570 d=[1 10;254 9];
571  
572  
573 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
574  
575 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
576  
577 assert_checkerror("cumprod(d, ""orient"")", refMsg);
578  
579  
580 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
581  
582 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
583  
584 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
585  
586  
587 //==============================================================================
588  
589 // matrices of integer
590  
591 i = uint8(d);
592  
593  
594 assert_checkfalse(execstr("cumprod(i, ""orient"")"   ,"errcatch") == 0);
595  
596 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
597  
598 assert_checkerror("cumprod(i, ""orient"")", refMsg);
599  
600  
601 assert_checkfalse(execstr("cumprod(i, [""r"", ""c""])"   ,"errcatch") == 0);
602  
603 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
604  
605 assert_checkerror("cumprod(i, [""r"", ""c""])", refMsg);
606  
607  
608 assert_checkfalse(execstr("cumprod(i,""r"", ""nat"")"   ,"errcatch") == 0);
609  
610 refMsg = msprintf(_("Wrong value for argument #%d.\n"), 3);
611  
612 assert_checkerror("cumprod(i,""r"", ""nat"")", refMsg);
613  
614  
615 assert_checkfalse(execstr("cumprod(i,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
616  
617 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 3);
618  
619 assert_checkerror("cumprod(i,""r"", [""nat"" ""dble""])", refMsg);
620  
621  
622 assert_checkfalse(execstr("cumprod(i,""orient"", ""t"")"   ,"errcatch") == 0);
623  
624 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
625  
626 assert_checkerror("cumprod(i,""orient"", ""t"")", refMsg);
627  
628  
629 assert_checkfalse(execstr("cumprod(i,1,1)"   ,"errcatch") == 0);
630  
631 refMsg = msprintf(_("Wrong type for argument #%d: String expected.\n"), 3);
632  
633 assert_checkerror("cumprod(i,1,1)", refMsg);
634  
635  
636 //==============================================================================
637  
638 // sparse matrices
639  
640 d = sparse(d);
641  
642 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
643  
644 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
645 "cumprod",2,"""*"",""r"",""c"",""m""");
646  
647 assert_checkerror("cumprod(d, ""orient"")", refMsg);
648  
649  
650 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
651  
652 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
653  
654 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
655  
656  
657 //==============================================================================
658  
659 // boolean matrices
660  
661 d = [%f %t;%t %f];
662  
663 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
664  
665 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"cumprod",2,"""*"",""r"",""c"",""m""");
666  
667 assert_checkerror("cumprod(d, ""orient"")", refMsg);
668  
669  
670 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
671  
672 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
673  
674 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
675  
676  
677 assert_checkfalse(execstr("cumprod(d,""r"", ""nat"")"   ,"errcatch") == 0);
678  
679 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"cumprod", 3, "native", "double");
680  
681 assert_checkerror("cumprod(d,""r"", ""nat"")", refMsg);
682  
683  
684 assert_checkfalse(execstr("cumprod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
685  
686 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",3);
687  
688 assert_checkerror("cumprod(d,""r"", [""nat"" ""dble""])", refMsg);
689  
690  
691 assert_checkfalse(execstr("cumprod(d,""orient"", ""t"")"   ,"errcatch") == 0);
692  
693 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
694 "cumprod",2,"""*"",""r"",""c"",""m""");
695  
696 assert_checkerror("cumprod(d,""orient"", ""t"")", refMsg);
697  
698  
699 assert_checkfalse(execstr("cumprod(d,1,1)"   ,"errcatch") == 0);
700  
701 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"),"cumprod",3);
702  
703 assert_checkerror("cumprod(d,1,1)", refMsg);
704  
705  
706 //==============================================================================
707  
708 // sparse boolean matrices
709  
710 d = sparse(d);
711  
712 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
713  
714 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
715 "cumprod",2,"""*"",""r"",""c"",""m""");
716  
717 assert_checkerror("cumprod(d, ""orient"")", refMsg);
718  
719  
720 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
721  
722 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
723  
724 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
725  
726  
727 assert_checkfalse(execstr("cumprod(d,""r"", ""nat"")"   ,"errcatch") == 0);
728  
729 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"cumprod", 3, "native", "double");
730  
731 assert_checkerror("cumprod(d,""r"", ""nat"")", refMsg);
732  
733  
734 assert_checkfalse(execstr("cumprod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
735  
736 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",3);
737  
738 assert_checkerror("cumprod(d,""r"", [""nat"" ""dble""])", refMsg);
739  
740  
741 assert_checkfalse(execstr("cumprod(d,""orient"", ""t"")"   ,"errcatch") == 0);
742  
743 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
744 "cumprod",2,"""*"",""r"",""c"",""m""");
745  
746 assert_checkerror("cumprod(d,""orient"", ""t"")", refMsg);
747  
748  
749 assert_checkfalse(execstr("cumprod(d,1,1)"   ,"errcatch") == 0);
750  
751 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"),"cumprod",3);
752  
753 assert_checkerror("cumprod(d,1,1)", refMsg);
754  
755  
756 //==============================================================================
757  
758 // hypermatrices
759  
760 d = rand(2,2,2);
761  
762 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
763  
764 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
765 "cumprod",2,"""*"",""r"",""c"",""m""");
766  
767 assert_checkerror("cumprod(d, ""orient"")", refMsg);
768  
769  
770 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
771  
772 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
773  
774 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
775  
776  
777 //==============================================================================
778  
779 // polynome
780  
781 s = poly(0, "s");
782  
783 d = [s s^2;s*%i 1];
784  
785 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
786  
787 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
788 "cumprod",2,"""*"",""r"",""c"",""m""");
789  
790 assert_checkerror("cumprod(d, ""orient"")", refMsg);
791  
792  
793 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
794  
795 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
796  
797 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
798  
799  
800 //==============================================================================
801  
802 // rational matrices
803  
804 s = poly(0, "s");
805  
806 d = [1/s 1/s^2; 1/s 1];
807  
808 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
809  
810 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
811 "cumprod",2,"""*"",""r"",""c"",""m""");
812  
813 assert_checkerror("cumprod(d, ""orient"")", refMsg);
814  
815  
816 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
817  
818 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
819  
820 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
821  
822  
823 //cumprod
824  
825 //Empty matrices
826  
827 T=list(list(),list("native"),list("double"));
828  
829 for typ=T
830     assert_checkequal(cumprod([],typ(:)), []);
831     assert_checkequal(cumprod([],"*",typ(:)), []);
832     assert_checkequal(cumprod([],1,typ(:)), []);
833     assert_checkequal(cumprod([],2,typ(:)), []);
834     assert_checkequal(cumprod([],3,typ(:)), []);
835 end
836  
837  
838 //=======================================================================
839  
840 //float matrices
841  
842 d=[1 10;254 9];
843  
844 T=list(list(),list("native"),list("double"));
845  
846 for typ=T
847     assert_checkequal(cumprod(d,typ(:)), [1,2540;254,22860]);
848     assert_checkequal(cumprod(d,"*",typ(:)), [1,2540;254,22860]);
849     assert_checkequal(cumprod(d,1,typ(:)), [1,10;254,90]);
850     assert_checkequal(cumprod(d,2,typ(:)), [1,10;254,2286]);
851     assert_checkequal(cumprod(d,3,typ(:)), d);
852 end
853  
854  
855 //hypermatrices of floats
856  
857 d=[1 10;254 9];d(1,1,2)=1;
858  
859 T=list(list(),list("native"),list("double"));
860  
861 for typ=T
862     assert_checkequal(cumprod(d,typ(:)), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
863     assert_checkequal(cumprod(d,"*",typ(:)), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
864     assert_checkequal(cumprod(d,1,typ(:)), hypermat([2,2,2],[1;254;10;90;1;0;0;0]));
865     assert_checkequal(cumprod(d,2,typ(:)), hypermat([2,2,2],[1;254;10;2286;1;0;0;0]));
866     assert_checkequal(cumprod(d,3,typ(:)), hypermat([2,2,2],[1;254;10;9;1;0;0;0]));
867     assert_checkequal(cumprod(d,5,typ(:)), d);
868 end
869  
870  
871 //=======================================================================
872  
873 //Integers
874  
875 i=uint8([1 10;254 9]);
876  
877 for typ=list(list(),list("native"));
878     assert_checkequal(cumprod(i,typ(:)), uint8([1,236;254,76]));
879     assert_checkequal(cumprod(i,"*",typ(:)), uint8([1,236;254,76]));
880     assert_checkequal(cumprod(i,1,typ(:)), uint8([1,10;254,90]));
881     assert_checkequal(cumprod(i,2,typ(:)), uint8([1,10;254,238]));
882     assert_checkequal(cumprod(i,3,typ(:)), double(i));
883 end
884  
885  
886 assert_checkequal(cumprod(i,"double"), [1,2540;254,22860]);
887  
888 assert_checkequal(cumprod(i,"*","double"), [1,2540;254,22860]);
889  
890 assert_checkequal(cumprod(i,1,"double"), [1,10;254,90]);
891  
892 assert_checkequal(cumprod(i,2,"double"), [1,10;254,2286]);
893  
894 assert_checkequal(cumprod(i,3,"double"), double(i));
895  
896  
897 //with hypermatrices
898  
899 i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
900  
901 for typ=list(list(),list("native"));
902     assert_checkequal(cumprod(i,typ(:)), hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0])));
903     assert_checkequal(cumprod(i,"*",typ(:)), hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0])));
904     assert_checkequal(cumprod(i,1,typ(:)), hypermat([2,2,2],uint8([1;254;10;90;1;0;0;0])));
905     assert_checkequal(cumprod(i,2,typ(:)), hypermat([2,2,2],uint8([1;254;10;238;1;0;0;0])));
906     assert_checkequal(cumprod(i,3,typ(:)), hypermat([2,2,2],uint8([1;254;10;9;1;0;0;0])));
907     assert_checkequal(cumprod(i,5,typ(:)), i);
908 end
909  
910  
911  
912 assert_checkequal(cumprod(i,"double"), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
913  
914 assert_checkequal(cumprod(i,"*","double"), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
915  
916 assert_checkequal(cumprod(i,1,"double"), hypermat([2,2,2],[1;254;10;90;1;0;0;0]));
917  
918 assert_checkequal(cumprod(i,2,"double"), hypermat([2,2,2],[1;254;10;2286;1;0;0;0]));
919  
920 assert_checkequal(cumprod(i,3,"double"), hypermat([2,2,2],[1;254;10;9;1;0;0;0]));
921  
922 assert_checkequal(cumprod(i,5,"double"), double(i));
923  
924  
925 //=======================================================================
926  
927 //Matrices of Polynomials
928  
929 s=%s;p=[s s+1;s^2 0];
930  
931 T=list(list(),list("native"),list("double"));
932  
933 for typ=T
934     assert_checkequal(cumprod(p,typ(:)), [s,s^3+s^4;s^3,0*s]);
935     assert_checkequal(cumprod(p,"*",typ(:)), [s,s^3+s^4;s^3,0*s]);
936     assert_checkequal(cumprod(p,1,typ(:)), [s,1+s;s^3,0*s]);
937     assert_checkequal(cumprod(p,2,typ(:)), [s,s+s^2;s^2,0*s]);
938     assert_checkequal(cumprod(p,3,typ(:)), p);
939 end
940  
941  
942 //with hypermatrices
943  
944 s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
945  
946 T=list(list(),list("native"),list("double"));
947  
948 for typ=T
949     assert_checkequal(cumprod(p,typ(:)), hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s]));
950     assert_checkequal(cumprod(p,"*",typ(:)), hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s]));
951     assert_checkequal(cumprod(p,1,typ(:)), hypermat([2,2,2],[s;s^3;1+s;0*s;-1;0*s;0*s;0*s]));
952     assert_checkequal(cumprod(p,2,typ(:)), hypermat([2,2,2],[s;s^2;s+s^2;0*s;-1;0*s;0*s;0*s]));
953     assert_checkequal(cumprod(p,3,typ(:)), hypermat([2,2,2],[s;s^2;1+s;0*s;-s;0*s;0*s;0*s]));
954     assert_checkequal(cumprod(p,5,typ(:)), p);
955 end
956  
957 //=======================================================================
958  
959 //Matrices of rationals
960  
961 s=%s;r=1.0 ./[s s+1;s^2 1];
962  
963 T=list(list(),list("native"),list("double"));
964  
965 for typ=T
966     assert_checkequal(cumprod(r,typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
967     assert_checkequal(cumprod(r,"*",typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
968     assert_checkequal(cumprod(r,1,typ(:)), [1,1;1,1]./[s,1+s;s^3,1+s]);
969     assert_checkequal(cumprod(r,2,typ(:)), [1,1;1,1]./[s,s+s^2;s^2,s^2]);
970     assert_checkequal(cumprod(r,3,typ(:)), r);
971 end
972  
973  
974 //=======================================================================
975  
976 ///Matrices of boolean
977  
978  
979 b=[%t %t;%f %t];
980  
981 for typ=list(list(),list("double"));
982     assert_checkequal(cumprod(b,typ(:)), [1,0;0,0]);
983     assert_checkequal(cumprod(b,"*",typ(:)), [1,0;0,0]);
984     assert_checkequal(cumprod(b,1,typ(:)), [1,1;0,1]);
985     assert_checkequal(cumprod(b,2,typ(:)), [1,1;0,0]);
986     assert_checkequal(cumprod(b,3,typ(:)), double(b));
987 end
988  
989 assert_checkequal(cumprod(b,"native"), [%t,%f;%f,%f]);
990  
991 assert_checkequal(cumprod(b,"*","native"), [%t,%f;%f,%f]);
992  
993 assert_checkequal(cumprod(b,1,"native"), [%t,%t;%f,%t]);
994  
995 assert_checkequal(cumprod(b,2,"native"), [%t,%t;%f,%f]);
996  
997 assert_checkequal(cumprod(b,3,"native"), b);
998  
999  
1000 //with hypermatrices
1001  
1002 b=[%t %t;%f %t];b(1,1,2)=%f;
1003  
1004 for typ=list(list(),list("double"));
1005     assert_checkequal(cumprod(b,typ(:)), hypermat([2,2,2],[1;0;0;0;0;0;0;0]));
1006     assert_checkequal(cumprod(b,"*",typ(:)), hypermat([2,2,2],[1;0;0;0;0;0;0;0]));
1007     assert_checkequal(cumprod(b,1,typ(:)), hypermat([2,2,2],[1;0;1;1;0;0;0;0]));
1008     assert_checkequal(cumprod(b,2,typ(:)), hypermat([2,2,2],[1;0;1;0;0;0;0;0]));
1009     assert_checkequal(cumprod(b,3,typ(:)), hypermat([2,2,2],[1;0;1;1;0;0;0;0]));
1010     assert_checkequal(cumprod(b,5,typ(:)), double(b));
1011 end
1012  
1013  
1014 assert_checkequal(cumprod(b,"native"), hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f]));
1015  
1016 assert_checkequal(cumprod(b,"*","native"), hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f]));
1017  
1018 assert_checkequal(cumprod(b,1,"native"), hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f]));
1019  
1020 assert_checkequal(cumprod(b,2,"native"), hypermat([2,2,2],[%t;%f;%t;%f;%f;%f;%f;%f]));
1021  
1022 assert_checkequal(cumprod(b,3,"native"), hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f]));
1023  
1024 assert_checkequal(cumprod(b,5,"native"), b);
1025  
1026  
1027 //=======================================================================
1028  
1029 //sparse matrices of floats
1030  
1031 s=sparse([1 10 0;-1 0 9]);
1032  
1033 T=list(list(),list("native"),list("double"));
1034  
1035 for typ=T
1036     assert_checkequal(cumprod(s,typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
1037     assert_checkequal(cumprod(s,"*",typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
1038     assert_checkequal(cumprod(s,1,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
1039     assert_checkequal(cumprod(s,2,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
1040     assert_checkequal(cumprod(s,3,typ(:)), s);
1041 end
1042  
1043  
1044 //=======================================================================
1045  
1046 //sparse  matrices of boolean
1047  
1048 bs=sparse([%t %t %f;%t %t %t]);
1049  
1050 for typ=list(list(),list("double"));
1051     assert_checkequal(cumprod(bs,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
1052     assert_checkequal(cumprod(bs,"*",typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
1053     assert_checkequal(cumprod(bs,1,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
1054     assert_checkequal(cumprod(bs,2,typ(:)), sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3]));
1055     assert_checkequal(cumprod(bs,3,typ(:)), bool2s(bs));
1056 end
1057  
1058  
1059 assert_checkequal(cumprod(bs,"native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
1060  
1061 assert_checkequal(cumprod(bs,"*","native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
1062  
1063  
1064 assert_checkequal(cumprod(bs,1,"native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
1065  
1066  
1067 assert_checkequal(cumprod(bs,2,"native"), sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3]));
1068  
1069 assert_checkequal(cumprod(bs,3,"native"), bs);
1070  
1071  
1072 // TODO : test the "m" option
1073  
1074 exec SCI/modules/elementary_functions/tests/unit_tests/prod.tst
1075  
1076 // =============================================================================
1077  
1078 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
1079  
1080 // Copyright (C) 2010 - INRIA - Serge Steer
1081  
1082 // Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
1083  
1084 //
1085  
1086 //  This file is distributed under the same license as the Scilab package.
1087  
1088 // =============================================================================
1089  
1090  
1091 // <-- CLI SHELL MODE 
1092  
1093 // prod
1094  
1095 // Check error
1096  
1097 d=[1 10;254 9];
1098  
1099 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
1100  
1101 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
1102  
1103 assert_checkerror("prod(d, ""orient"")", refMsg);
1104  
1105  
1106 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1107  
1108 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
1109  
1110 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
1111  
1112  
1113 //==============================================================================
1114  
1115 // matrices of integer
1116  
1117 i = uint8(d);
1118  
1119 assert_checkfalse(execstr("prod(i, ""orient"")"   ,"errcatch") == 0);
1120  
1121 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
1122  
1123 assert_checkerror("prod(i, ""orient"")", refMsg);
1124  
1125  
1126 assert_checkfalse(execstr("prod(i, [""r"", ""c""])"   ,"errcatch") == 0);
1127  
1128 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
1129  
1130 assert_checkerror("prod(i, [""r"", ""c""])", refMsg);
1131  
1132  
1133 assert_checkfalse(execstr("prod(i,""r"", ""nat"")"   ,"errcatch") == 0);
1134  
1135 refMsg = msprintf(_("Wrong value for argument #%d.\n"), 3);
1136  
1137 assert_checkerror("prod(i,""r"", ""nat"")", refMsg);
1138  
1139  
1140 assert_checkfalse(execstr("prod(i,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
1141  
1142 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 3);
1143  
1144 assert_checkerror("prod(i,""r"", [""nat"" ""dble""])", refMsg);
1145  
1146  
1147 assert_checkfalse(execstr("prod(i,""orient"", ""t"")"   ,"errcatch") == 0);
1148  
1149 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
1150  
1151 assert_checkerror("prod(i,""orient"", ""t"")", refMsg);
1152  
1153  
1154 assert_checkfalse(execstr("prod(i,1,1)"   ,"errcatch") == 0);
1155  
1156 refMsg = msprintf(_("Wrong type for argument #%d: String expected.\n"), 3);
1157  
1158 assert_checkerror("prod(i,1,1)", refMsg);
1159  
1160  
1161 //==============================================================================
1162  
1163 // sparse matrices
1164  
1165 d = sparse(d);
1166  
1167 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
1168  
1169 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
1170  
1171 assert_checkerror("prod(d, ""orient"")", refMsg);
1172  
1173  
1174 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1175  
1176 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
1177  
1178 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
1179  
1180  
1181 //==============================================================================
1182  
1183 // boolean matrices
1184  
1185 d = [%f %t;%t %f];
1186  
1187 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
1188  
1189 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"prod",2,"""*"",""r"",""c"",""m""");
1190  
1191 assert_checkerror("prod(d, ""orient"")", refMsg);
1192  
1193  
1194 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1195  
1196 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
1197  
1198 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
1199  
1200  
1201 assert_checkfalse(execstr("prod(d,""r"", ""nat"")"   ,"errcatch") == 0);
1202  
1203 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"prod", 3, "native", "double");
1204  
1205 assert_checkerror("prod(d,""r"", ""nat"")", refMsg);
1206  
1207  
1208 assert_checkfalse(execstr("prod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
1209  
1210 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",3);
1211  
1212 assert_checkerror("prod(d,""r"", [""nat"" ""dble""])", refMsg);
1213  
1214  
1215 assert_checkfalse(execstr("prod(d,""orient"", ""t"")"   ,"errcatch") == 0);
1216  
1217 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1218 "prod",2,"""*"",""r"",""c"",""m""");
1219  
1220 assert_checkerror("prod(d,""orient"", ""t"")", refMsg);
1221  
1222  
1223 assert_checkfalse(execstr("prod(d,1,1)"   ,"errcatch") == 0);
1224  
1225 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"),"prod",3);
1226  
1227 assert_checkerror("prod(d,1,1)", refMsg);
1228  
1229  
1230 //==============================================================================
1231  
1232 // sparse boolean matrices
1233  
1234 d = sparse(d);
1235  
1236 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
1237  
1238 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1239 "prod",2,"""*"",""r"",""c"",""m""");
1240  
1241 assert_checkerror("prod(d, ""orient"")", refMsg);
1242  
1243  
1244 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1245  
1246 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
1247  
1248 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
1249  
1250  
1251 assert_checkfalse(execstr("prod(d,""r"", ""nat"")"   ,"errcatch") == 0);
1252  
1253 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"prod", 3, "native", "double");
1254  
1255 assert_checkerror("prod(d,""r"", ""nat"")", refMsg);
1256  
1257  
1258 assert_checkfalse(execstr("prod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
1259  
1260 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",3);
1261  
1262 assert_checkerror("prod(d,""r"", [""nat"" ""dble""])", refMsg);
1263  
1264  
1265 assert_checkfalse(execstr("prod(d,""orient"", ""t"")"   ,"errcatch") == 0);
1266  
1267 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1268 "prod",2,"""*"",""r"",""c"",""m""");
1269  
1270 assert_checkerror("prod(d,""orient"", ""t"")", refMsg);
1271  
1272  
1273 assert_checkfalse(execstr("prod(d,1,1)"   ,"errcatch") == 0);
1274  
1275 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"),"prod",3);
1276  
1277 assert_checkerror("prod(d,1,1)", refMsg);
1278  
1279  
1280 //==============================================================================
1281  
1282 // hypermatrices
1283  
1284 d = rand(2,2,2);
1285  
1286 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
1287  
1288 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1289 "prod",2,"""*"",""r"",""c"",""m""");
1290  
1291 assert_checkerror("prod(d, ""orient"")", refMsg);
1292  
1293  
1294 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1295  
1296 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
1297  
1298 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
1299  
1300  
1301 //==============================================================================
1302  
1303 // polynome
1304  
1305 s = poly(0, "s");
1306  
1307 d = [s s^2;s*%i 1];
1308  
1309 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
1310  
1311 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1312 "prod",2,"""*"",""r"",""c"",""m""");
1313  
1314 assert_checkerror("prod(d, ""orient"")", refMsg);
1315  
1316  
1317 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1318  
1319 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
1320  
1321 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
1322  
1323  
1324 //==============================================================================
1325  
1326 // rational matrices
1327  
1328 s = poly(0, "s");
1329  
1330 d = [1/s 1/s^2; 1/s 1];
1331  
1332 assert_checkfalse(execstr("prod(d, ""orient"")"   ,"errcatch") == 0);
1333  
1334 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1335 "prod",2,"""*"",""r"",""c"",""m""");
1336  
1337 assert_checkerror("prod(d, ""orient"")", refMsg);
1338  
1339  
1340 assert_checkfalse(execstr("prod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1341  
1342 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2);
1343  
1344 assert_checkerror("prod(d, [""r"", ""c""])", refMsg);
1345  
1346  
1347 //empty matrices
1348  
1349 T=list(list(),list("native"),list("double"));
1350  
1351 for typ=T
1352     assert_checkequal(prod([], typ(:)), 1);
1353     assert_checkequal(prod([], "*", typ(:)), 1);
1354     assert_checkequal(prod([], 1, typ(:)), []);
1355     assert_checkequal(prod([], 2, typ(:)), []);
1356     assert_checkequal(prod([], 3, typ(:)), []);
1357 end
1358  
1359  
1360 //=======================================================================
1361  
1362 //float matrices
1363  
1364 d=[1 10;254 9];
1365  
1366 T=list(list(),list("native"),list("double"));
1367  
1368 for typ=T
1369     assert_checkequal(prod(d, typ(:)), 22860);
1370     assert_checkequal(prod(d, "*", typ(:)), 22860);
1371     assert_checkequal(prod(d, 1, typ(:)), [254 90]);
1372     assert_checkequal(prod(d, 2, typ(:)), [10;2286]);
1373     assert_checkequal(prod(d, 3, typ(:)), d);
1374 end
1375  
1376  
1377  
1378 //hypermatrices of floats
1379  
1380 d=[1 10;254 9];d(:,:,2)=1;
1381  
1382 T=list(list(),list("native"),list("double"));
1383  
1384 for typ=T
1385     assert_checkequal(prod(d, typ(:)), 22860);
1386     assert_checkequal(prod(d, "*", typ(:)), 22860);
1387     assert_checkequal(prod(d, 1, typ(:)), hypermat([1,2,2],[254;90;1;1]));
1388     assert_checkequal(prod(d, 2, typ(:)), hypermat([2,1,2],[10;2286;1;1]));
1389     assert_checkequal(prod(d, 3, typ(:)), [1,10;254,9]);
1390     assert_checkequal(prod(d, 5, typ(:)), d);
1391 end
1392  
1393  
1394 //=======================================================================
1395  
1396 //matrices of short integers
1397  
1398 i=uint8([1 10;254 9]);
1399  
1400 T=list(list(),list("native"));
1401  
1402 for typ=T
1403     assert_checkequal(prod(i, typ(:)), uint8(76));
1404     assert_checkequal(prod(i, "*", typ(:)), uint8(76));
1405     assert_checkequal(prod(i, 1, typ(:)), uint8([254 90]));
1406     assert_checkequal(prod(i, 2, typ(:)), uint8([10;238]));
1407     assert_checkequal(prod(i, 3, typ(:)), double(i));
1408 end
1409  
1410  
1411 assert_checkequal(prod(i, "double"), 22860);
1412  
1413 assert_checkequal(prod(i, "*", "double"), 22860);
1414  
1415 assert_checkequal(prod(i, 1, "double"), [254 90]);
1416  
1417 assert_checkequal(prod(i, 2, "double"), [10;2286]);
1418  
1419 assert_checkequal(prod(i, 3, "double"), double(i));
1420  
1421  
1422 //with hypermatrices
1423  
1424 i=uint8([1 10;254 9]);i(:,:,2)=uint8(1);
1425  
1426 T = list(list(),list("native"));
1427  
1428 for typ=T
1429     assert_checkequal(prod(i, typ(:)), uint8(76));
1430     assert_checkequal(prod(i, "*", typ(:)), uint8(76));
1431     assert_checkequal(prod(i, 1, typ(:)), hypermat([1,2,2],uint8([254;90;1;1])));
1432     assert_checkequal(prod(i, 2, typ(:)), hypermat([2,1,2],uint8([10;238;1;1])));
1433     assert_checkequal(prod(i, 3, typ(:)), uint8([1,10;254,9]));
1434     assert_checkequal(prod(i, 5, typ(:)), i);
1435 end
1436  
1437  
1438 assert_checkequal(prod(i, "double"), 22860);
1439  
1440 assert_checkequal(prod(i, "*", "double"), 22860);
1441  
1442 assert_checkequal(prod(i, 1, "double"), hypermat([1,2,2],[254;90;1;1]));
1443  
1444 assert_checkequal(prod(i, 2, "double"), hypermat([2,1,2],[10;2286;1;1]));
1445  
1446 assert_checkequal(prod(i, 3, "double"), [1,10;254,9]);
1447  
1448 assert_checkequal(prod(i, 5, "double"), double(i));
1449  
1450  
1451 //Polynomials
1452  
1453 s=%s;p=[s s+1;s^2 1];
1454  
1455 T=list(list(),list("native"),list("double"));
1456  
1457 for typ=T
1458     assert_checkequal(prod(p, typ(:)), s^3+s^4);
1459     assert_checkequal(prod(p, "*", typ(:)), s^3+s^4);
1460     assert_checkequal(prod(p, 1, typ(:)), [s^3,1+s]);
1461     assert_checkequal(prod(p, 2, typ(:)), [s+s^2;s^2]);
1462     assert_checkequal(prod(p, 3, typ(:)), p);
1463 end
1464  
1465 //with hypermatrices
1466  
1467 s=%s;p=[s s+1;s^2 1];p(:,:,2)=[1 s;s+1 2];
1468  
1469 T=list(list(),list("native"),list("double"));
1470  
1471 for typ=T
1472     assert_checkequal(prod(p, typ(:)), 2*s^4+4*s^5+2*s^6);
1473     assert_checkequal(prod(p, "*", typ(:)), 2*s^4+4*s^5+2*s^6);
1474     assert_checkequal(prod(p, 1, typ(:)), hypermat([1,2,2],[s^3;1+s;1+s;2*s]));
1475     assert_checkequal(prod(p, 2, typ(:)), hypermat([2,1,2],[s+s^2;s^2;s;2+2*s]));
1476     assert_checkequal(prod(p, 3, typ(:)), [s,s+s^2;s^2+s^3,2]);
1477     assert_checkequal(prod(p, 5, typ(:)), p);
1478 end
1479  
1480  
1481 //=======================================================================
1482  
1483 //Matrices of rationals
1484  
1485 s=%s;r=1.0 ./[s s+1;s^2 1];
1486  
1487 T=list(list(),list("native"),list("double"));
1488  
1489 for typ=T
1490     assert_checkequal(prod(r, typ(:)), 1.0/(s^3+s^4));
1491     assert_checkequal(prod(r, "*", typ(:)), 1.0/(s^3+s^4));
1492     assert_checkequal(prod(r, 1, typ(:)), [1,1]./[s^3,1+s]);
1493     assert_checkequal(prod(r, 2, typ(:)), [1;1]./[s+s^2;s^2]);
1494     assert_checkequal(prod(r, 3, typ(:)), r);
1495 end
1496  
1497  
1498 //=======================================================================
1499  
1500 //Matrices of booleans
1501  
1502 b=[%t %t; %f %t];
1503  
1504 T = list(list(),list("double"));
1505  
1506 for typ=T
1507     assert_checkequal(prod(b, typ(:)), 0);
1508     assert_checkequal(prod(b, "*", typ(:)), 0);
1509     assert_checkequal(prod(b, 1, typ(:)), [0 1]);
1510     assert_checkequal(prod(b, 2, typ(:)), [1;0]);
1511     assert_checkequal(prod(b, 3, typ(:)), double(b));
1512 end
1513  
1514  
1515 assert_checkequal(prod(b, "native"), %f);
1516  
1517 assert_checkequal(prod(b, "*", "native"), %f);
1518  
1519 assert_checkequal(prod(b, 1, "native"), [%f %t]);
1520  
1521 assert_checkequal(prod(b, 2, "native"), [%t;%f]);
1522  
1523 assert_checkequal(prod(b, 3, "native"), b);
1524  
1525  
1526 //with hypermatrices
1527  
1528 b=[%t %t;%f %t];b(1,1,2)=%t;
1529  
1530 T = list(list(),list("double"));
1531  
1532 for typ=T
1533     assert_checkequal(prod(b, typ(:)), 0);
1534     assert_checkequal(prod(b, "*", typ(:)), 0);
1535     assert_checkequal(prod(b, 1, typ(:)), hypermat([1,2,2],[0;1;0;0]));
1536     assert_checkequal(prod(b, 2, typ(:)), hypermat([2,1,2],[1;0;0;0]));
1537     assert_checkequal(prod(b, 3, typ(:)), [1,0;0,0]);
1538     assert_checkequal(prod(b, 5, typ(:)), double(b));
1539 end
1540  
1541  
1542 assert_checkequal(prod(b, "native"), %f);
1543  
1544 assert_checkequal(prod(b, "*", "native"), %f);
1545  
1546 assert_checkequal(prod(b, 1, "native"), hypermat([1,2,2],[%f;%t;%f;%f]));
1547  
1548 assert_checkequal(prod(b, 2, "native"), hypermat([2,1,2],[%t;%f;%f;%f]));
1549  
1550 assert_checkequal(prod(b, 3, "native"), [%t,%f;%f,%f]);
1551  
1552 assert_checkequal(prod(b, 5, "native"), b);
1553  
1554  
1555 //=======================================================================
1556  
1557 //sparse matrices of floats
1558  
1559 s=sparse([1 10 2;-1 254 9]);
1560  
1561 T=list(list(),list("native"),list("double"));
1562  
1563 for typ=T
1564     assert_checkequal(prod(s, typ(:)), -45720);
1565     assert_checkequal(prod(s, "*", typ(:)), -45720);
1566     assert_checkequal(prod(s, 1, typ(:)), sparse([-1 2540 18]));
1567     assert_checkequal(prod(s, 2, typ(:)), sparse([20;-2286]));
1568     assert_checkequal(prod(s, 3, typ(:)), s);
1569 end
1570  
1571  
1572 //=======================================================================
1573  
1574 //sparse  matrices of boolean
1575  
1576 bs=sparse([%t %t %f;%t %t %t]);
1577  
1578 T = list(list(),list("double"));
1579  
1580 for typ=T
1581     assert_checkequal(prod(bs, typ(:)), 0);
1582     assert_checkequal(prod(bs, "*", typ(:)), 0);
1583     assert_checkequal(prod(bs, 1, typ(:)), sparse([1,1,0]));
1584     assert_checkequal(prod(bs, 2, typ(:)), sparse([0;1]));
1585     assert_checkequal(prod(bs, 3, typ(:)), bool2s(bs));
1586 end
1587  
1588  
1589 assert_checkequal(prod(bs, "native"), %f);
1590  
1591 assert_checkequal(prod(bs, "*", "native"), %f);
1592  
1593 assert_checkequal(prod(bs, 1, "native"), sparse([%t,%t,%f]));
1594  
1595 assert_checkequal(prod(bs, 2, "native"), sparse([%f;%t]));
1596  
1597 assert_checkequal(prod(bs, 3, "native"), bs);
1598  
1599  
1600 // TODO : test the "m" option
1601  
1602 exec SCI/modules/elementary_functions/tests/unit_tests/cumprod.tst
1603  
1604 // =============================================================================
1605  
1606 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
1607  
1608 // Copyright (C) 2010 - INRIA - Serge Steer
1609  
1610 // Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
1611  
1612 // Copyright (C) 2013 - Scilab Enterprises - Adeline CARNIS
1613  
1614 //
1615  
1616 //  This file is distributed under the same license as the Scilab package.
1617  
1618 // =============================================================================
1619  
1620  
1621 // <-- CLI SHELL MODE 
1622  
1623 // Check error
1624  
1625 //==============================================================================
1626  
1627 //float matrices
1628  
1629 d=[1 10;254 9];
1630  
1631  
1632 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
1633  
1634 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
1635  
1636 assert_checkerror("cumprod(d, ""orient"")", refMsg);
1637  
1638  
1639 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1640  
1641 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
1642  
1643 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
1644  
1645  
1646 //==============================================================================
1647  
1648 // matrices of integer
1649  
1650 i = uint8(d);
1651  
1652  
1653 assert_checkfalse(execstr("cumprod(i, ""orient"")"   ,"errcatch") == 0);
1654  
1655 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
1656  
1657 assert_checkerror("cumprod(i, ""orient"")", refMsg);
1658  
1659  
1660 assert_checkfalse(execstr("cumprod(i, [""r"", ""c""])"   ,"errcatch") == 0);
1661  
1662 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 2);
1663  
1664 assert_checkerror("cumprod(i, [""r"", ""c""])", refMsg);
1665  
1666  
1667 assert_checkfalse(execstr("cumprod(i,""r"", ""nat"")"   ,"errcatch") == 0);
1668  
1669 refMsg = msprintf(_("Wrong value for argument #%d.\n"), 3);
1670  
1671 assert_checkerror("cumprod(i,""r"", ""nat"")", refMsg);
1672  
1673  
1674 assert_checkfalse(execstr("cumprod(i,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
1675  
1676 refMsg = msprintf(_("Wrong size for argument #%d.\n"), 3);
1677  
1678 assert_checkerror("cumprod(i,""r"", [""nat"" ""dble""])", refMsg);
1679  
1680  
1681 assert_checkfalse(execstr("cumprod(i,""orient"", ""t"")"   ,"errcatch") == 0);
1682  
1683 refMsg = msprintf(_("Wrong argument #%d.\n"), 2);
1684  
1685 assert_checkerror("cumprod(i,""orient"", ""t"")", refMsg);
1686  
1687  
1688 assert_checkfalse(execstr("cumprod(i,1,1)"   ,"errcatch") == 0);
1689  
1690 refMsg = msprintf(_("Wrong type for argument #%d: String expected.\n"), 3);
1691  
1692 assert_checkerror("cumprod(i,1,1)", refMsg);
1693  
1694  
1695 //==============================================================================
1696  
1697 // sparse matrices
1698  
1699 d = sparse(d);
1700  
1701 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
1702  
1703 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1704 "cumprod",2,"""*"",""r"",""c"",""m""");
1705  
1706 assert_checkerror("cumprod(d, ""orient"")", refMsg);
1707  
1708  
1709 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1710  
1711 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
1712  
1713 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
1714  
1715  
1716 //==============================================================================
1717  
1718 // boolean matrices
1719  
1720 d = [%f %t;%t %f];
1721  
1722 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
1723  
1724 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),"cumprod",2,"""*"",""r"",""c"",""m""");
1725  
1726 assert_checkerror("cumprod(d, ""orient"")", refMsg);
1727  
1728  
1729 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1730  
1731 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
1732  
1733 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
1734  
1735  
1736 assert_checkfalse(execstr("cumprod(d,""r"", ""nat"")"   ,"errcatch") == 0);
1737  
1738 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"cumprod", 3, "native", "double");
1739  
1740 assert_checkerror("cumprod(d,""r"", ""nat"")", refMsg);
1741  
1742  
1743 assert_checkfalse(execstr("cumprod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
1744  
1745 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",3);
1746  
1747 assert_checkerror("cumprod(d,""r"", [""nat"" ""dble""])", refMsg);
1748  
1749  
1750 assert_checkfalse(execstr("cumprod(d,""orient"", ""t"")"   ,"errcatch") == 0);
1751  
1752 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1753 "cumprod",2,"""*"",""r"",""c"",""m""");
1754  
1755 assert_checkerror("cumprod(d,""orient"", ""t"")", refMsg);
1756  
1757  
1758 assert_checkfalse(execstr("cumprod(d,1,1)"   ,"errcatch") == 0);
1759  
1760 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"),"cumprod",3);
1761  
1762 assert_checkerror("cumprod(d,1,1)", refMsg);
1763  
1764  
1765 //==============================================================================
1766  
1767 // sparse boolean matrices
1768  
1769 d = sparse(d);
1770  
1771 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
1772  
1773 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1774 "cumprod",2,"""*"",""r"",""c"",""m""");
1775  
1776 assert_checkerror("cumprod(d, ""orient"")", refMsg);
1777  
1778  
1779 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1780  
1781 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
1782  
1783 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
1784  
1785  
1786 assert_checkfalse(execstr("cumprod(d,""r"", ""nat"")"   ,"errcatch") == 0);
1787  
1788 refMsg = msprintf(_("%s: Wrong value for input argument #%d: ""%s"" or ""%s"" expected.\n"),"cumprod", 3, "native", "double");
1789  
1790 assert_checkerror("cumprod(d,""r"", ""nat"")", refMsg);
1791  
1792  
1793 assert_checkfalse(execstr("cumprod(d,""r"", [""nat"" ""dble""])"   ,"errcatch") == 0);
1794  
1795 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",3);
1796  
1797 assert_checkerror("cumprod(d,""r"", [""nat"" ""dble""])", refMsg);
1798  
1799  
1800 assert_checkfalse(execstr("cumprod(d,""orient"", ""t"")"   ,"errcatch") == 0);
1801  
1802 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1803 "cumprod",2,"""*"",""r"",""c"",""m""");
1804  
1805 assert_checkerror("cumprod(d,""orient"", ""t"")", refMsg);
1806  
1807  
1808 assert_checkfalse(execstr("cumprod(d,1,1)"   ,"errcatch") == 0);
1809  
1810 refMsg = msprintf(_("%s: Wrong type for input argument #%d: A string expected.\n"),"cumprod",3);
1811  
1812 assert_checkerror("cumprod(d,1,1)", refMsg);
1813  
1814  
1815 //==============================================================================
1816  
1817 // hypermatrices
1818  
1819 d = rand(2,2,2);
1820  
1821 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
1822  
1823 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1824 "cumprod",2,"""*"",""r"",""c"",""m""");
1825  
1826 assert_checkerror("cumprod(d, ""orient"")", refMsg);
1827  
1828  
1829 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1830  
1831 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
1832  
1833 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
1834  
1835  
1836 //==============================================================================
1837  
1838 // polynome
1839  
1840 s = poly(0, "s");
1841  
1842 d = [s s^2;s*%i 1];
1843  
1844 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
1845  
1846 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1847 "cumprod",2,"""*"",""r"",""c"",""m""");
1848  
1849 assert_checkerror("cumprod(d, ""orient"")", refMsg);
1850  
1851  
1852 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1853  
1854 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
1855  
1856 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
1857  
1858  
1859 //==============================================================================
1860  
1861 // rational matrices
1862  
1863 s = poly(0, "s");
1864  
1865 d = [1/s 1/s^2; 1/s 1];
1866  
1867 assert_checkfalse(execstr("cumprod(d, ""orient"")"   ,"errcatch") == 0);
1868  
1869 refMsg = msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
1870 "cumprod",2,"""*"",""r"",""c"",""m""");
1871  
1872 assert_checkerror("cumprod(d, ""orient"")", refMsg);
1873  
1874  
1875 assert_checkfalse(execstr("cumprod(d, [""r"", ""c""])"   ,"errcatch") == 0);
1876  
1877 refMsg = msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2);
1878  
1879 assert_checkerror("cumprod(d, [""r"", ""c""])", refMsg);
1880  
1881  
1882 //cumprod
1883  
1884 //Empty matrices
1885  
1886 T=list(list(),list("native"),list("double"));
1887  
1888 for typ=T
1889     assert_checkequal(cumprod([],typ(:)), []);
1890     assert_checkequal(cumprod([],"*",typ(:)), []);
1891     assert_checkequal(cumprod([],1,typ(:)), []);
1892     assert_checkequal(cumprod([],2,typ(:)), []);
1893     assert_checkequal(cumprod([],3,typ(:)), []);
1894 end
1895  
1896  
1897 //=======================================================================
1898  
1899 //float matrices
1900  
1901 d=[1 10;254 9];
1902  
1903 T=list(list(),list("native"),list("double"));
1904  
1905 for typ=T
1906     assert_checkequal(cumprod(d,typ(:)), [1,2540;254,22860]);
1907     assert_checkequal(cumprod(d,"*",typ(:)), [1,2540;254,22860]);
1908     assert_checkequal(cumprod(d,1,typ(:)), [1,10;254,90]);
1909     assert_checkequal(cumprod(d,2,typ(:)), [1,10;254,2286]);
1910     assert_checkequal(cumprod(d,3,typ(:)), d);
1911 end
1912  
1913  
1914 //hypermatrices of floats
1915  
1916 d=[1 10;254 9];d(1,1,2)=1;
1917  
1918 T=list(list(),list("native"),list("double"));
1919  
1920 for typ=T
1921     assert_checkequal(cumprod(d,typ(:)), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
1922     assert_checkequal(cumprod(d,"*",typ(:)), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
1923     assert_checkequal(cumprod(d,1,typ(:)), hypermat([2,2,2],[1;254;10;90;1;0;0;0]));
1924     assert_checkequal(cumprod(d,2,typ(:)), hypermat([2,2,2],[1;254;10;2286;1;0;0;0]));
1925     assert_checkequal(cumprod(d,3,typ(:)), hypermat([2,2,2],[1;254;10;9;1;0;0;0]));
1926     assert_checkequal(cumprod(d,5,typ(:)), d);
1927 end
1928  
1929  
1930 //=======================================================================
1931  
1932 //Integers
1933  
1934 i=uint8([1 10;254 9]);
1935  
1936 for typ=list(list(),list("native"));
1937     assert_checkequal(cumprod(i,typ(:)), uint8([1,236;254,76]));
1938     assert_checkequal(cumprod(i,"*",typ(:)), uint8([1,236;254,76]));
1939     assert_checkequal(cumprod(i,1,typ(:)), uint8([1,10;254,90]));
1940     assert_checkequal(cumprod(i,2,typ(:)), uint8([1,10;254,238]));
1941     assert_checkequal(cumprod(i,3,typ(:)), double(i));
1942 end
1943  
1944  
1945 assert_checkequal(cumprod(i,"double"), [1,2540;254,22860]);
1946  
1947 assert_checkequal(cumprod(i,"*","double"), [1,2540;254,22860]);
1948  
1949 assert_checkequal(cumprod(i,1,"double"), [1,10;254,90]);
1950  
1951 assert_checkequal(cumprod(i,2,"double"), [1,10;254,2286]);
1952  
1953 assert_checkequal(cumprod(i,3,"double"), double(i));
1954  
1955  
1956 //with hypermatrices
1957  
1958 i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
1959  
1960 for typ=list(list(),list("native"));
1961     assert_checkequal(cumprod(i,typ(:)), hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0])));
1962     assert_checkequal(cumprod(i,"*",typ(:)), hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0])));
1963     assert_checkequal(cumprod(i,1,typ(:)), hypermat([2,2,2],uint8([1;254;10;90;1;0;0;0])));
1964     assert_checkequal(cumprod(i,2,typ(:)), hypermat([2,2,2],uint8([1;254;10;238;1;0;0;0])));
1965     assert_checkequal(cumprod(i,3,typ(:)), hypermat([2,2,2],uint8([1;254;10;9;1;0;0;0])));
1966     assert_checkequal(cumprod(i,5,typ(:)), i);
1967 end
1968  
1969  
1970  
1971 assert_checkequal(cumprod(i,"double"), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
1972  
1973 assert_checkequal(cumprod(i,"*","double"), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
1974  
1975 assert_checkequal(cumprod(i,1,"double"), hypermat([2,2,2],[1;254;10;90;1;0;0;0]));
1976  
1977 assert_checkequal(cumprod(i,2,"double"), hypermat([2,2,2],[1;254;10;2286;1;0;0;0]));
1978  
1979 assert_checkequal(cumprod(i,3,"double"), hypermat([2,2,2],[1;254;10;9;1;0;0;0]));
1980  
1981 assert_checkequal(cumprod(i,5,"double"), double(i));
1982  
1983  
1984 //=======================================================================
1985  
1986 //Matrices of Polynomials
1987  
1988 s=%s;p=[s s+1;s^2 0];
1989  
1990 T=list(list(),list("native"),list("double"));
1991  
1992 for typ=T
1993     assert_checkequal(cumprod(p,typ(:)), [s,s^3+s^4;s^3,0*s]);
1994     assert_checkequal(cumprod(p,"*",typ(:)), [s,s^3+s^4;s^3,0*s]);
1995     assert_checkequal(cumprod(p,1,typ(:)), [s,1+s;s^3,0*s]);
1996     assert_checkequal(cumprod(p,2,typ(:)), [s,s+s^2;s^2,0*s]);
1997     assert_checkequal(cumprod(p,3,typ(:)), p);
1998 end
1999  
2000  
2001 //with hypermatrices
2002  
2003 s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
2004  
2005 T=list(list(),list("native"),list("double"));
2006  
2007 for typ=T
2008     assert_checkequal(cumprod(p,typ(:)), hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s]));
2009     assert_checkequal(cumprod(p,"*",typ(:)), hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s]));
2010     assert_checkequal(cumprod(p,1,typ(:)), hypermat([2,2,2],[s;s^3;1+s;0*s;-1;0*s;0*s;0*s]));
2011     assert_checkequal(cumprod(p,2,typ(:)), hypermat([2,2,2],[s;s^2;s+s^2;0*s;-1;0*s;0*s;0*s]));
2012     assert_checkequal(cumprod(p,3,typ(:)), hypermat([2,2,2],[s;s^2;1+s;0*s;-s;0*s;0*s;0*s]));
2013     assert_checkequal(cumprod(p,5,typ(:)), p);
2014 end
2015  
2016 //=======================================================================
2017  
2018 //Matrices of rationals
2019  
2020 s=%s;r=1.0 ./[s s+1;s^2 1];
2021  
2022 T=list(list(),list("native"),list("double"));
2023  
2024 for typ=T
2025     assert_checkequal(cumprod(r,typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
2026     assert_checkequal(cumprod(r,"*",typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
2027     assert_checkequal(cumprod(r,1,typ(:)), [1,1;1,1]./[s,1+s;s^3,1+s]);
2028     assert_checkequal(cumprod(r,2,typ(:)), [1,1;1,1]./[s,s+s^2;s^2,s^2]);
2029     assert_checkequal(cumprod(r,3,typ(:)), r);
2030 end
2031  
2032  
2033 //=======================================================================
2034  
2035 ///Matrices of boolean
2036  
2037  
2038 b=[%t %t;%f %t];
2039  
2040 for typ=list(list(),list("double"));
2041     assert_checkequal(cumprod(b,typ(:)), [1,0;0,0]);
2042     assert_checkequal(cumprod(b,"*",typ(:)), [1,0;0,0]);
2043     assert_checkequal(cumprod(b,1,typ(:)), [1,1;0,1]);
2044     assert_checkequal(cumprod(b,2,typ(:)), [1,1;0,0]);
2045     assert_checkequal(cumprod(b,3,typ(:)), double(b));
2046 end
2047  
2048 assert_checkequal(cumprod(b,"native"), [%t,%f;%f,%f]);
2049  
2050 assert_checkequal(cumprod(b,"*","native"), [%t,%f;%f,%f]);
2051  
2052 assert_checkequal(cumprod(b,1,"native"), [%t,%t;%f,%t]);
2053  
2054 assert_checkequal(cumprod(b,2,"native"), [%t,%t;%f,%f]);
2055  
2056 assert_checkequal(cumprod(b,3,"native"), b);
2057  
2058  
2059 //with hypermatrices
2060  
2061 b=[%t %t;%f %t];b(1,1,2)=%f;
2062  
2063 for typ=list(list(),list("double"));
2064     assert_checkequal(cumprod(b,typ(:)), hypermat([2,2,2],[1;0;0;0;0;0;0;0]));
2065     assert_checkequal(cumprod(b,"*",typ(:)), hypermat([2,2,2],[1;0;0;0;0;0;0;0]));
2066     assert_checkequal(cumprod(b,1,typ(:)), hypermat([2,2,2],[1;0;1;1;0;0;0;0]));
2067     assert_checkequal(cumprod(b,2,typ(:)), hypermat([2,2,2],[1;0;1;0;0;0;0;0]));
2068     assert_checkequal(cumprod(b,3,typ(:)), hypermat([2,2,2],[1;0;1;1;0;0;0;0]));
2069     assert_checkequal(cumprod(b,5,typ(:)), double(b));
2070 end
2071  
2072  
2073 assert_checkequal(cumprod(b,"native"), hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f]));
2074  
2075 assert_checkequal(cumprod(b,"*","native"), hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f]));
2076  
2077 assert_checkequal(cumprod(b,1,"native"), hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f]));
2078  
2079 assert_checkequal(cumprod(b,2,"native"), hypermat([2,2,2],[%t;%f;%t;%f;%f;%f;%f;%f]));
2080  
2081 assert_checkequal(cumprod(b,3,"native"), hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f]));
2082  
2083 assert_checkequal(cumprod(b,5,"native"), b);
2084  
2085  
2086 //=======================================================================
2087  
2088 //sparse matrices of floats
2089  
2090 s=sparse([1 10 0;-1 0 9]);
2091  
2092 T=list(list(),list("native"),list("double"));
2093  
2094 for typ=T
2095     assert_checkequal(cumprod(s,typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
2096     assert_checkequal(cumprod(s,"*",typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
2097     assert_checkequal(cumprod(s,1,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
2098     assert_checkequal(cumprod(s,2,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
2099     assert_checkequal(cumprod(s,3,typ(:)), s);
2100 end
2101  
2102  
2103 //=======================================================================
2104  
2105 //sparse  matrices of boolean
2106  
2107 bs=sparse([%t %t %f;%t %t %t]);
2108  
2109 for typ=list(list(),list("double"));
2110     assert_checkequal(cumprod(bs,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
2111     assert_checkequal(cumprod(bs,"*",typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
2112     assert_checkequal(cumprod(bs,1,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
2113     assert_checkequal(cumprod(bs,2,typ(:)), sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3]));
2114     assert_checkequal(cumprod(bs,3,typ(:)), bool2s(bs));
2115 end
2116  
2117  
2118 assert_checkequal(cumprod(bs,"native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
2119  
2120 assert_checkequal(cumprod(bs,"*","native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
2121  
2122  
2123 assert_checkequal(cumprod(bs,1,"native"), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
2124  
2125  
2126 assert_checkequal(cumprod(bs,2,"native"), sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3]));
2127  
2128 assert_checkequal(cumprod(bs,3,"native"), bs);
2129  
2130  
2131 // TODO : test the "m" option
2132