use assert functions in some tests of elementary functions. 14/8714/2
Cedric Delamarre [Thu, 16 Aug 2012 09:28:32 +0000 (11:28 +0200)]
test_run('elementary_functions','abs')
test_run('elementary_functions','asin')
test_run('elementary_functions','cos')
test_run('elementary_functions','cumprod')
test_run('elementary_functions','cumsum')
test_run('elementary_functions','rat')
test_run('elementary_functions','sin')

Change-Id: I543ec4f68c65978954ed9329f5ea9958bb3eaa39

14 files changed:
scilab/modules/elementary_functions/tests/unit_tests/abs.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/abs.tst
scilab/modules/elementary_functions/tests/unit_tests/asin.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/asin.tst
scilab/modules/elementary_functions/tests/unit_tests/cos.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/cos.tst
scilab/modules/elementary_functions/tests/unit_tests/cumprod.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/cumprod.tst
scilab/modules/elementary_functions/tests/unit_tests/cumsum.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/cumsum.tst
scilab/modules/elementary_functions/tests/unit_tests/rat.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/rat.tst
scilab/modules/elementary_functions/tests/unit_tests/sin.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/sin.tst

index 1851c64..289e2cb 100644 (file)
@@ -1,22 +1,23 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Pierre MARECHAL <pierre.marechal@inria.fr>
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- CLI SHELL MODE -->
 // unit tests for abs() function (absolute value, magnitude)
 // =============================================================================
-if execstr("abs()"   ,"errcatch") == 0 then bugmes();quit;end
-if execstr("abs(1,2)","errcatch") == 0 then bugmes();quit;end
-if abs(10)     <> 10  then bugmes();quit;end
-if abs(-4.3)   <> 4.3 then bugmes();quit;end
-if abs(6+8*%i) <> 10  then bugmes();quit;end
-if abs(6-8*%i) <> 10  then bugmes();quit;end
-if or(abs([ 7.6 , 8*%i ; 6+8*%i 6-8*%i ])   <> [7.6 , 8 ; 10 , 10 ]) then bugmes();quit;end
-if or(abs([ 7.6 8*%i 6+8*%i 6-8*%i ])       <> [7.6 8 10 10 ])       then bugmes();quit;end
-if or(abs([ 7.6 ; 8*%i ; 6+8*%i ; 6-8*%i ]) <> [7.6 ; 8 ; 10 ; 10 ]) then bugmes();quit;end
-if ~isnan(abs(%nan)) then bugmes();quit;end
-if ~isnan(abs(-%nan)) then bugmes();quit;end
-if abs(%inf) <> %inf then bugmes();quit;end
-if abs(-%inf) <> %inf then bugmes();quit;end
+assert_checkfalse(execstr("abs()", "errcatch") == 0);
+assert_checkfalse(execstr("abs(1,2)", "errcatch") == 0);
+assert_checkequal(abs(10)     ,10);
+assert_checkequal(abs(-4.3)   ,4.3);
+assert_checkequal(abs(6+8*%i) ,10);
+assert_checkequal(abs(6-8*%i) ,10);
+assert_checkequal(abs([ 7.6 , 8*%i ; 6+8*%i 6-8*%i ]), [7.6 , 8 ; 10 , 10 ]);
+assert_checkequal(abs([ 7.6 8*%i 6+8*%i 6-8*%i ]), [7.6 8 10 10 ]);
+assert_checkequal(abs([ 7.6 ; 8*%i ; 6+8*%i ; 6-8*%i ]), [7.6 ; 8 ; 10 ; 10 ]);
+assert_checktrue(isnan(abs(%nan)));
+assert_checktrue(isnan(abs(-%nan)));
+assert_checkequal(abs(%inf), %inf);
+assert_checkequal(abs(-%inf), %inf);
index da283c7..5005f1c 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Pierre MARECHAL <pierre.marechal@inria.fr>
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // unit tests for abs() function (absolute value, magnitude)
 // =============================================================================
 
-if execstr("abs()"   ,"errcatch") == 0 then pause, end
-if execstr("abs(1,2)","errcatch") == 0 then pause, end
+assert_checkfalse(execstr("abs()", "errcatch") == 0);
+assert_checkfalse(execstr("abs(1,2)", "errcatch") == 0);
 
-if abs(10)     <> 10  then pause, end
-if abs(-4.3)   <> 4.3 then pause, end
-if abs(6+8*%i) <> 10  then pause, end
-if abs(6-8*%i) <> 10  then pause, end
+assert_checkequal(abs(10)     ,10);
+assert_checkequal(abs(-4.3)   ,4.3);
+assert_checkequal(abs(6+8*%i) ,10);
+assert_checkequal(abs(6-8*%i) ,10);
 
-if or(abs([ 7.6 , 8*%i ; 6+8*%i 6-8*%i ])   <> [7.6 , 8 ; 10 , 10 ]) then pause, end
-if or(abs([ 7.6 8*%i 6+8*%i 6-8*%i ])       <> [7.6 8 10 10 ])       then pause, end
-if or(abs([ 7.6 ; 8*%i ; 6+8*%i ; 6-8*%i ]) <> [7.6 ; 8 ; 10 ; 10 ]) then pause, end
+assert_checkequal(abs([ 7.6 , 8*%i ; 6+8*%i 6-8*%i ]), [7.6 , 8 ; 10 , 10 ]);
+assert_checkequal(abs([ 7.6 8*%i 6+8*%i 6-8*%i ]), [7.6 8 10 10 ]);
+assert_checkequal(abs([ 7.6 ; 8*%i ; 6+8*%i ; 6-8*%i ]), [7.6 ; 8 ; 10 ; 10 ]);
 
 
-if ~isnan(abs(%nan)) then pause, end
-if ~isnan(abs(-%nan)) then pause, end
+assert_checktrue(isnan(abs(%nan)));
+assert_checktrue(isnan(abs(-%nan)));
 
-if abs(%inf) <> %inf then pause, end
-if abs(-%inf) <> %inf then pause, end
+assert_checkequal(abs(%inf), %inf);
+assert_checkequal(abs(-%inf), %inf);
index 9144cd4..af1a848 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Pierre MARECHAL <pierre.marechal@scilab.org>
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // =============================================================================
 // 1. Interface
 // ============
-if execstr("asin()"   ,"errcatch") == 0 then bugmes();quit;end
-if execstr("asin(1,2)","errcatch") == 0 then bugmes();quit;end
+assert_checkfalse(execstr("asin()", "errcatch") == 0);
+assert_checkfalse(execstr("asin(1,2)", "errcatch") == 0);
 // 2. Singular Values
 // ==================
 rt2 = sqrt(2);
 rt3 = sqrt(3);
 v   = [0 , %pi/6 , %pi/4 , %pi/3 , %pi/2    , %pi/3 , %pi/4 , %pi/6 , 0 ];
 x   = [0 , 1/2   , rt2/2 , rt3/2 , 1        , rt3/2 , rt2/2 , 1/2   , 0 ];
-if or(abs(asin(x)-v) > sqrt (%eps)) then bugmes();quit;end
+y = asin(x);
+assert_checkalmostequal(y,v,2*%eps,[],"element");
 // 3. Not A Number
 // ===============
-if ~isnan(asin(%nan))        then bugmes();quit;end
-if ~isnan(asin(-%nan))       then bugmes();quit;end
+assert_checktrue(isnan(asin(%nan)));
+assert_checktrue(isnan(asin(-%nan)));
 // 4. Limit values
 // ===============
+assert_checkequal(imag(asin(%inf)),%inf);
+assert_checkequal(imag(asin(-%inf)),%inf);
 // 5. Properties
 // =============
 A = rand(100,100);
 // asin(-x) = - asin(x)
-if or( asin(-A) + asin(A) > %eps) then bugmes();quit;end
+assert_checkalmostequal(asin(-A), -asin(A), %eps);
 // asin(x) = acos(-x) - pi/2
-if or( (asin(A) - acos(-A) + %pi/2) > %eps ) then bugmes();quit;end
+assert_checkalmostequal(asin(A), acos(-A) - %pi / 2, %eps, %eps, "element");
index cfbd9bd..3d37b97 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Pierre MARECHAL <pierre.marechal@scilab.org>
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
@@ -14,9 +15,8 @@
 // 1. Interface
 // ============
 
-if execstr("asin()"   ,"errcatch") == 0 then pause, end
-if execstr("asin(1,2)","errcatch") == 0 then pause, end
-
+assert_checkfalse(execstr("asin()", "errcatch") == 0);
+assert_checkfalse(execstr("asin(1,2)", "errcatch") == 0);
 
 // 2. Singular Values
 // ==================
@@ -26,27 +26,33 @@ rt3 = sqrt(3);
 v   = [0 , %pi/6 , %pi/4 , %pi/3 , %pi/2    , %pi/3 , %pi/4 , %pi/6 , 0 ];
 x   = [0 , 1/2   , rt2/2 , rt3/2 , 1        , rt3/2 , rt2/2 , 1/2   , 0 ];
 
-if or(abs(asin(x)-v) > sqrt (%eps)) then pause, end
+y = asin(x);
+assert_checkalmostequal(y,v,2*%eps,[],"element");
 
 
 // 3. Not A Number
 // ===============
 
-if ~isnan(asin(%nan))        then pause, end
-if ~isnan(asin(-%nan))       then pause, end
+assert_checktrue(isnan(asin(%nan)));
+assert_checktrue(isnan(asin(-%nan)));
 
 
 // 4. Limit values
 // ===============
 
+assert_checkequal(imag(asin(%inf)),%inf);
+assert_checkequal(imag(asin(-%inf)),%inf);
+
+
 // 5. Properties
 // =============
 
 A = rand(100,100);
 
 // asin(-x) = - asin(x)
-if or( asin(-A) + asin(A) > %eps) then pause, end
+assert_checkalmostequal(asin(-A), -asin(A), %eps);
 
 
 // asin(x) = acos(-x) - pi/2
-if or( (asin(A) - acos(-A) + %pi/2) > %eps ) then pause, end
+assert_checkalmostequal(asin(A), acos(-A) - %pi / 2, %eps, %eps, "element");
+
index 4a0b474..cf2b56d 100644 (file)
 // TODO : complex arithmetic
 // 1. Interface
 // ============
-if execstr("cos()"   ,"errcatch")           == 0 then bugmes();quit;end
-if execstr("cos(1,2)","errcatch")           == 0 then bugmes();quit;end
-if execstr("cos(''my string'')","errcatch") == 0 then bugmes();quit;end
+assert_checkfalse(execstr("cos()" ,"errcatch") == 0);
+assert_checkfalse(execstr("cos(1,2)","errcatch") == 0);
+assert_checkfalse(execstr("cos(''my string'')","errcatch") == 0);
 // 2. Singular Values
 // ==================
-if ( cos(0) <> 1 ) then bugmes();quit;end
-if ( cos(-0) <> 1 ) then bugmes();quit;end
+assert_checkequal(cos(0), 1);
+assert_checkequal(cos(-0), 1);
 // The following tests check cos for a small number of x in the range [0,pi].
-// The variable x contains correctly rounded values of the exact value of x. 
-// The variable v contains correctly rounded values of the exact value of cos 
+// The variable x contains correctly rounded values of the exact value of x.
+// The variable v contains correctly rounded values of the exact value of cos
 // on the exact double representing the various values of x.
-// For example, the floating point number which is closest to %pi/2 is 
-// 7074237752028440 * 2^(0-53+1), which can be written with the decimal string 
-// 1.570796326794896558D+00. 
-// We have cos(7074237752028440 * 2^(0-53+1)) = 6.123233995736765886...*10^-17
+// For example, the floating point number which is closest to %pi/2 is
+// 7074237752028440 * 2^-52, which can be written with the decimal string
+// 1.570796326794896558D+00.
+// We have cos(7074237752028440 * 2^-52) = 6.123233995736765886...*10^-17
 // exactly.
-// If Scilab had support for hex, we would have used it. 
+// If Scilab had support for hex, we would have used it.
 // The exact values are computed in Wolfram Alpha.
-// We use more that 17 digits, which, if the decimal to binary conversion is 
-// correct, and if the rounding is round-to-nearest, must exactly produce 
+// We use more that 17 digits, which, if the decimal to binary conversion is
+// correct, and if the rounding is round-to-nearest, must exactly produce
 // values in this table.
 // We avoid using values such as 2*%pi/3, which introduce one multiplication
-// and one addition (the test fail is the multiplication or division 
+// and one addition (the test fail is the multiplication or division
 // is not accurate, while the current test is not sensitive to this, i.e.
-// we test "cos", not "*"). 
+// we test "cos", not "*").
 // Failing this test may be caused by:
 // * a bad decimal to binary conversion,
 // * a wrong implementation of cos.
 x = [
-  5.235987755982988157D-01 // %pi/6 
+  5.235987755982988157D-01 // %pi/6
   7.853981633974482790D-01 // %pi/4
   1.047197551196597631D+00 // %pi/3
   1.570796326794896558D+00 // %pi/2
@@ -50,30 +50,30 @@ x = [
   3.141592653589793116D+00 // %pi
 ];
 v = [
-    8.660254037844386755D-01  
-    7.071067811865475727D-01  
+    8.660254037844386755D-01
+    7.071067811865475727D-01
     5.000000000000000994D-01
     6.123233995736765886D-17
    -4.999999999999998011D-01
    -7.071067811865474595D-01
    -8.660254037844386698D-01
-   -1.000000000000000000D+00  
+   -1.000000000000000000D+00
 ];
 C = cos(x);
 rtol = ceil(abs(C-v)./abs(v)/%eps);
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 ulptol = 1;
-if ( or(rtol>ulptol) ) then bugmes();quit;end
+assert_checkfalse(rtol > ulptol);
 //
 // Check symetry on these points
 x = -x;
 C = cos(x);
 rtol = ceil(abs(C-v)./abs(v)/%eps);
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 ulptol = 1;
-if ( or(rtol>ulptol) ) then bugmes();quit;end
+assert_checkfalse(rtol > ulptol);
 //
 // cos(x) == 1 for |x| < sqrt(2)*2^-27
 // Reference:
@@ -85,46 +85,46 @@ if ( or(rtol>ulptol) ) then bugmes();quit;end
 // Check positive and negative normal numbers.
 x = [2^(-1022:-27) -2^(-1022:-27)];
 // Check that the values are close to 1.
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 C = cos(x);
 rtol = ceil(abs(C-1)/%eps);
 ulptol = 1;
-if ( or(rtol>ulptol) ) then bugmes();quit;end
+assert_checkfalse(rtol > ulptol);
 // Check that the values are lower or equal to 1.
 // No matter how bad our library is, we must have abs(cos(x))<= 1.
 // If this test fails, the math library is to be absolutely rejected.
-if ( or(abs(C)>1) ) then bugmes();quit;end
+assert_checkfalse(abs(C) > 1);
 // Compute the number of floats for which cos(x)<>1.
 // An excellent library should produce s=0.
 // This failure happens for x=2^n and n usually close to -27.
 notexact = sum(C<>1);
 rtol = 30;
-if ( notexact>rtol ) then bugmes();quit;end
+assert_checkfalse(notexact > rtol);
 // Check that abs(cos(x))<= 1, for large normal floating point numbers x.
 // If this test fails, the math library is to be absolutely rejected.
 x = [2^(0:1023) -2^(0:1023)];
 C = cos(x);
-if ( or(abs(C)>1) ) then bugmes();quit;end
+assert_checkfalse(abs(C) > 1);
 // 3. Not A Number
 // ===============
-if ~isnan(cos(%nan)) then bugmes();quit;end
-if ~isnan(cos(-%nan)) then bugmes();quit;end
+assert_checktrue(isnan(cos(%nan)));
+assert_checktrue(isnan(cos(-%nan)));
 // 4. Limit values
 // ===============
-if ~isnan(real(cos(%inf)))    then bugmes();quit;end
-if imag(cos(%inf)) <> 0       then bugmes();quit;end
-if ~isnan(real(cos(-%inf)))   then bugmes();quit;end
-if imag(cos(-%inf)) <> 0      then bugmes();quit;end
+assert_checktrue(isnan(real(cos(%inf))));
+assert_checkequal(imag(cos(%inf)), 0);
+assert_checktrue(isnan(real(cos(-%inf))));
+assert_checkequal(imag(cos(-%inf)), 0);
 // 5. Properties
 // =============
-// All the tests below are based on equalities of the form C=0, 
+// All the tests below are based on equalities of the form C=0,
 // with C = f(A,B) and A, B matrices.
-// We consider the elementwise absolute error abs(C), and 
+// We consider the elementwise absolute error abs(C), and
 // focus on the maximum of this error, that is, we compute max(abs(C)).
-// This absolute error is compared to atolratio * %eps, but it is 
+// This absolute error is compared to atolratio * %eps, but it is
 // expressed as max(abs(C))/%eps.
-// Indeed, if this test fail, we first compute max(abs(C))/%eps, see 
+// Indeed, if this test fail, we first compute max(abs(C))/%eps, see
 // its value (e.g. 0.9, 1.2 or 2.3) and set the tolerance to the minimum
 // integer larger than this.
 rand("seed",0);
@@ -134,45 +134,45 @@ B = rand(100,100);
 atolratio = 5;
 // cos(-x) = cos(x)
 C = cos(-A) - cos(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // cos(%pi - x) = - cos(x)
 C = cos(%pi - A) + cos(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // cos(%pi + x) = - cos(x)
 C = cos(%pi + A) + cos(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 // cos(2a) = 2 cos^2(a) - 1
 C = cos(2*A) - 2 * (cos(A)).^2 + 1;
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 //
 // At this point, we do not test the accuracy of cos anymore:
 // we test the matching between cos and sin.
 // Thus, these tests may be put into cos.tst or sin.tst
-// 
+//
 // cos(%pi/2 - x) = sin(x)
 C = cos(%pi/2 - A) - sin(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 // cos(%pi/2 + x) = - sin(x)
 C = cos(%pi/2 + A) + sin(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 // cos^2(a) + sin^2(a) = 1
 C = (cos(A)).^2 + (sin(A)).^2 - 1;
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 // cos(a + b) = cos(a) cos(b) - sin(a) sin(b)
 C = cos(A + B) - cos(A).*cos(B) + sin(A).*sin(B);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 // cos(a -b) = cos(a) cos(b) + sin(a) sin(b)
 C = cos(A - B) - cos(A).*cos(B) - sin(A).*sin(B);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 // sin(a + b) = sin(a) cos(b) + sin(b) cos(a)
 C = sin(A + B) - sin(A).*cos(B) - sin(B).*cos(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 // sin(a -b) = sin(a) cos(b) - sin(b) cos(a)
 C = sin(A - B) - sin(A).*cos(B) + sin(B).*cos(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
-// cos(2a) = cos^2(a) - sin^2(a) 
+assert_checkfalse( max(abs(C))/%eps > atolratio);
+// cos(2a) = cos^2(a) - sin^2(a)
 C = cos(2*A) - (cos(A)).^2 + (sin(A)).^2;
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 // cos(2a) = 1 - 2 sin^2(a)
 C = cos(2*A) - 1 + 2 * (sin(A)).^2;
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
index b73f734..ac79b6a 100644 (file)
@@ -2,6 +2,7 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Pierre MARECHAL <pierre.marechal@inria.fr>
 // Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2012 - Scilab Enterprises - Delamarre Cedric
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // 1. Interface
 // ============
 
-if execstr("cos()"   ,"errcatch")           == 0 then pause, end
-if execstr("cos(1,2)","errcatch")           == 0 then pause, end
-if execstr("cos(''my string'')","errcatch") == 0 then pause, end
+assert_checkfalse(execstr("cos()" ,"errcatch") == 0);
+assert_checkfalse(execstr("cos(1,2)","errcatch") == 0);
+assert_checkfalse(execstr("cos(''my string'')","errcatch") == 0);
 
 // 2. Singular Values
 // ==================
 
-if ( cos(0) <> 1 ) then pause, end
-if ( cos(-0) <> 1 ) then pause, end
+assert_checkequal(cos(0), 1);
+assert_checkequal(cos(-0), 1);
 
 // The following tests check cos for a small number of x in the range [0,pi].
-// The variable x contains correctly rounded values of the exact value of x. 
-// The variable v contains correctly rounded values of the exact value of cos 
+// The variable x contains correctly rounded values of the exact value of x.
+// The variable v contains correctly rounded values of the exact value of cos
 // on the exact double representing the various values of x.
-// For example, the floating point number which is closest to %pi/2 is 
-// 7074237752028440 * 2^-52, which can be written with the decimal string 
-// 1.570796326794896558D+00. 
+// For example, the floating point number which is closest to %pi/2 is
+// 7074237752028440 * 2^-52, which can be written with the decimal string
+// 1.570796326794896558D+00.
 // We have cos(7074237752028440 * 2^-52) = 6.123233995736765886...*10^-17
 // exactly.
-// If Scilab had support for hex, we would have used it. 
+// If Scilab had support for hex, we would have used it.
 // The exact values are computed in Wolfram Alpha.
-// We use more that 17 digits, which, if the decimal to binary conversion is 
-// correct, and if the rounding is round-to-nearest, must exactly produce 
+// We use more that 17 digits, which, if the decimal to binary conversion is
+// correct, and if the rounding is round-to-nearest, must exactly produce
 // values in this table.
 // We avoid using values such as 2*%pi/3, which introduce one multiplication
-// and one addition (the test fail is the multiplication or division 
+// and one addition (the test fail is the multiplication or division
 // is not accurate, while the current test is not sensitive to this, i.e.
-// we test "cos", not "*"). 
+// we test "cos", not "*").
 // Failing this test may be caused by:
 // * a bad decimal to binary conversion,
 // * a wrong implementation of cos.
 x = [
-  5.235987755982988157D-01 // %pi/6 
+  5.235987755982988157D-01 // %pi/6
   7.853981633974482790D-01 // %pi/4
   1.047197551196597631D+00 // %pi/3
   1.570796326794896558D+00 // %pi/2
@@ -58,31 +59,31 @@ x = [
   3.141592653589793116D+00 // %pi
 ];
 v = [
-    8.660254037844386755D-01  
-    7.071067811865475727D-01  
+    8.660254037844386755D-01
+    7.071067811865475727D-01
     5.000000000000000994D-01
     6.123233995736765886D-17
    -4.999999999999998011D-01
    -7.071067811865474595D-01
    -8.660254037844386698D-01
-   -1.000000000000000000D+00  
+   -1.000000000000000000D+00
 ];
 
 C = cos(x);
 rtol = ceil(abs(C-v)./abs(v)/%eps);
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 ulptol = 1;
-if ( or(rtol>ulptol) ) then pause, end
+assert_checkfalse(rtol > ulptol);
 //
 // Check symetry on these points
 x = -x;
 C = cos(x);
 rtol = ceil(abs(C-v)./abs(v)/%eps);
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 ulptol = 1;
-if ( or(rtol>ulptol) ) then pause, end
+assert_checkfalse(rtol > ulptol);
 
 //
 // cos(x) == 1 for |x| < sqrt(2)*2^-27
@@ -95,57 +96,57 @@ if ( or(rtol>ulptol) ) then pause, end
 // Check positive and negative normal numbers.
 x = [2^(-1022:-27) -2^(-1022:-27)];
 // Check that the values are close to 1.
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 C = cos(x);
 rtol = ceil(abs(C-1)/%eps);
 ulptol = 1;
-if ( or(rtol>ulptol) ) then pause, end
+assert_checkfalse(rtol > ulptol);
 // Check that the values are lower or equal to 1.
 // No matter how bad our library is, we must have abs(cos(x))<= 1.
 // If this test fails, the math library is to be absolutely rejected.
-if ( or(abs(C)>1) ) then pause, end
+assert_checkfalse(abs(C) > 1);
 // Compute the number of floats for which cos(x)<>1.
 // An excellent library should produce s=0.
 // This failure happens for x=2^n and n usually close to -27.
 notexact = sum(C<>1);
 rtol = 30;
-if ( notexact>rtol ) then pause, end
+assert_checkfalse(notexact > rtol);
 
 // Check that abs(cos(x))<= 1, for large normal floating point numbers x.
 // If this test fails, the math library is to be absolutely rejected.
 x = [2^(0:1023) -2^(0:1023)];
 C = cos(x);
-if ( or(abs(C)>1) ) then pause, end
+assert_checkfalse(abs(C) > 1);
 
 // 3. Not A Number
 // ===============
 
-if ~isnan(cos(%nan)) then pause, end
-if ~isnan(cos(-%nan)) then pause, end
+assert_checktrue(isnan(cos(%nan)));
+assert_checktrue(isnan(cos(-%nan)));
 
 
 // 4. Limit values
 // ===============
 
-if ~isnan(real(cos(%inf)))    then pause, end
-if imag(cos(%inf)) <> 0       then pause, end
+assert_checktrue(isnan(real(cos(%inf))));
+assert_checkequal(imag(cos(%inf)), 0);
 
-if ~isnan(real(cos(-%inf)))   then pause, end
-if imag(cos(-%inf)) <> 0      then pause, end
+assert_checktrue(isnan(real(cos(-%inf))));
+assert_checkequal(imag(cos(-%inf)), 0);
 
 
 
 // 5. Properties
 // =============
 
-// All the tests below are based on equalities of the form C=0, 
+// All the tests below are based on equalities of the form C=0,
 // with C = f(A,B) and A, B matrices.
-// We consider the elementwise absolute error abs(C), and 
+// We consider the elementwise absolute error abs(C), and
 // focus on the maximum of this error, that is, we compute max(abs(C)).
-// This absolute error is compared to atolratio * %eps, but it is 
+// This absolute error is compared to atolratio * %eps, but it is
 // expressed as max(abs(C))/%eps.
-// Indeed, if this test fail, we first compute max(abs(C))/%eps, see 
+// Indeed, if this test fail, we first compute max(abs(C))/%eps, see
 // its value (e.g. 0.9, 1.2 or 2.3) and set the tolerance to the minimum
 // integer larger than this.
 
@@ -158,59 +159,59 @@ atolratio = 5;
 
 // cos(-x) = cos(x)
 C = cos(-A) - cos(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // cos(%pi - x) = - cos(x)
 C = cos(%pi - A) + cos(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // cos(%pi + x) = - cos(x)
 C = cos(%pi + A) + cos(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
 // cos(2a) = 2 cos^2(a) - 1
 C = cos(2*A) - 2 * (cos(A)).^2 + 1;
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
 //
 // At this point, we do not test the accuracy of cos anymore:
 // we test the matching between cos and sin.
 // Thus, these tests may be put into cos.tst or sin.tst
-// 
+//
 
 // cos(%pi/2 - x) = sin(x)
 C = cos(%pi/2 - A) - sin(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
 // cos(%pi/2 + x) = - sin(x)
 C = cos(%pi/2 + A) + sin(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
 // cos^2(a) + sin^2(a) = 1
 C = (cos(A)).^2 + (sin(A)).^2 - 1;
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
 // cos(a + b) = cos(a) cos(b) - sin(a) sin(b)
 C = cos(A + B) - cos(A).*cos(B) + sin(A).*sin(B);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
 // cos(a -b) = cos(a) cos(b) + sin(a) sin(b)
 C = cos(A - B) - cos(A).*cos(B) - sin(A).*sin(B);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
 // sin(a + b) = sin(a) cos(b) + sin(b) cos(a)
 C = sin(A + B) - sin(A).*cos(B) - sin(B).*cos(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
 // sin(a -b) = sin(a) cos(b) - sin(b) cos(a)
 C = sin(A - B) - sin(A).*cos(B) + sin(B).*cos(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
-// cos(2a) = cos^2(a) - sin^2(a) 
+// cos(2a) = cos^2(a) - sin^2(a)
 C = cos(2*A) - (cos(A)).^2 + (sin(A)).^2;
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
 // cos(2a) = 1 - 2 sin^2(a)
 C = cos(2*A) - 1 + 2 * (sin(A)).^2;
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse( max(abs(C))/%eps > atolratio);
 
index bd869ff..ea4ad8b 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2010 - INRIA - Serge Steer
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 //Empty matrices
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if cumprod([],typ(:))<>[] then bugmes();quit;end
-  if cumprod([],'*',typ(:))<>[] then bugmes();quit;end
-  if cumprod([],1,typ(:))<>[] then bugmes();quit;end
-  if cumprod([],2,typ(:))<>[] then bugmes();quit;end
-  if cumprod([],3,typ(:))<>[] then bugmes();quit;end
+  assert_checkequal(cumprod([],typ(:)), []);
+  assert_checkequal(cumprod([],'*',typ(:)), []);
+  assert_checkequal(cumprod([],1,typ(:)), []);
+  assert_checkequal(cumprod([],2,typ(:)), []);
+  assert_checkequal(cumprod([],3,typ(:)), []);
 end
 //=======================================================================
 //float matrices
 d=[1 10;254 9];
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(d,typ(:))<>[1,2540;254,22860]) then bugmes();quit;end
-  if or(cumprod(d,'*',typ(:))<>[1,2540;254,22860]) then bugmes();quit;end
-  if or(cumprod(d,1,typ(:))<>[1,10;254,90]) then bugmes();quit;end
-  if or(cumprod(d,2,typ(:))<>[1,10;254,2286]) then bugmes();quit;end
-  if or(cumprod(d,3,typ(:))<>d) then bugmes();quit;end
+  assert_checkequal(cumprod(d,typ(:)), [1,2540;254,22860]);
+  assert_checkequal(cumprod(d,'*',typ(:)), [1,2540;254,22860]);
+  assert_checkequal(cumprod(d,1,typ(:)), [1,10;254,90]);
+  assert_checkequal(cumprod(d,2,typ(:)), [1,10;254,2286]);
+  assert_checkequal(cumprod(d,3,typ(:)), d);
 end
 //hypermatrices of floats
 d=[1 10;254 9];d(1,1,2)=1;
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(d,typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then bugmes();quit;end
-  if or(cumprod(d,'*',typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then bugmes();quit;end
-  if or(cumprod(d,1,typ(:))<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then bugmes();quit;end
-  if or(cumprod(d,2,typ(:))<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then bugmes();quit;end
-  if or(cumprod(d,3,typ(:))<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then bugmes();quit;end
-  if or(cumprod(d,5,typ(:))<>d) then bugmes();quit;end
+  assert_checkequal(cumprod(d,typ(:)), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
+  assert_checkequal(cumprod(d,'*',typ(:)), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
+  assert_checkequal(cumprod(d,1,typ(:)), hypermat([2,2,2],[1;254;10;90;1;0;0;0]));
+  assert_checkequal(cumprod(d,2,typ(:)), hypermat([2,2,2],[1;254;10;2286;1;0;0;0]));
+  assert_checkequal(cumprod(d,3,typ(:)), hypermat([2,2,2],[1;254;10;9;1;0;0;0]));
+  assert_checkequal(cumprod(d,5,typ(:)), d);
 end
 //=======================================================================
 //Integers
 i=uint8([1 10;254 9]);
 for typ=list(list(),list('native'));
-  if or(cumprod(i,typ(:))<>uint8([1,236;254,76])) then bugmes();quit;end
-  if or(cumprod(i,'*',typ(:))<>uint8([1,236;254,76])) then bugmes();quit;end
-  if or(cumprod(i,1,typ(:))<>uint8([1,10;254,90])) then bugmes();quit;end
-  if or(cumprod(i,2,typ(:))<>uint8([1,10;254,238])) then bugmes();quit;end
-  if or(cumprod(i,3,typ(:))<>i) then bugmes();quit;end
+  assert_checkequal(cumprod(i,typ(:)), uint8([1,236;254,76]));
+  assert_checkequal(cumprod(i,'*',typ(:)), uint8([1,236;254,76]));
+  assert_checkequal(cumprod(i,1,typ(:)), uint8([1,10;254,90]));
+  assert_checkequal(cumprod(i,2,typ(:)), uint8([1,10;254,238]));
+  assert_checkequal(cumprod(i,3,typ(:)), double(i));
 end
-if or(cumprod(i,'double')<>[1,2540;254,22860]) then bugmes();quit;end
-if or(cumprod(i,'*','double')<>[1,2540;254,22860]) then bugmes();quit;end
-if or(cumprod(i,1,'double')<>[1,10;254,90]) then bugmes();quit;end
-if or(cumprod(i,2,'double')<>[1,10;254,2286]) then bugmes();quit;end
-if or(cumprod(i,3,'double')<>double(i)) then bugmes();quit;end
+assert_checkequal(cumprod(i,'double'), [1,2540;254,22860]);
+assert_checkequal(cumprod(i,'*','double'), [1,2540;254,22860]);
+assert_checkequal(cumprod(i,1,'double'), [1,10;254,90]);
+assert_checkequal(cumprod(i,2,'double'), [1,10;254,2286]);
+assert_checkequal(cumprod(i,3,'double'), double(i));
 //with hypermatrices
 i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
 for typ=list(list(),list('native'));
-  if or(cumprod(i,typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then bugmes();quit;end
-  if or(cumprod(i,'*',typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then bugmes();quit;end
-  if or(cumprod(i,1,typ(:))<>hypermat([2,2,2],uint8([1;254;10;90;1;0;0;0]))) then bugmes();quit;end
-  if or(cumprod(i,2,typ(:))<>hypermat([2,2,2],uint8([1;254;10;238;1;0;0;0]))) then bugmes();quit;end
-  if or(cumprod(i,3,typ(:))<>hypermat([2,2,2],uint8([1;254;10;9;1;0;0;0]))) then bugmes();quit;end
-  if or(cumprod(i,5,typ(:))<>i) then bugmes();quit;end
+  assert_checkequal(cumprod(i,typ(:)), hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0])));
+  assert_checkequal(cumprod(i,'*',typ(:)), hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0])));
+  assert_checkequal(cumprod(i,1,typ(:)), hypermat([2,2,2],uint8([1;254;10;90;1;0;0;0])));
+  assert_checkequal(cumprod(i,2,typ(:)), hypermat([2,2,2],uint8([1;254;10;238;1;0;0;0])));
+  assert_checkequal(cumprod(i,3,typ(:)), hypermat([2,2,2],uint8([1;254;10;9;1;0;0;0])));
+  assert_checkequal(cumprod(i,5,typ(:)), double(i));
 end
-if or(cumprod(i,'double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then bugmes();quit;end
-if or(cumprod(i,'*','double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then bugmes();quit;end
-if or(cumprod(i,1,'double')<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then bugmes();quit;end
-if or(cumprod(i,2,'double')<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then bugmes();quit;end
-if or(cumprod(i,3,'double')<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then bugmes();quit;end
-if or(cumprod(i,5,'double')<>double(i)) then bugmes();quit;end
+assert_checkequal(cumprod(i,'double'), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
+assert_checkequal(cumprod(i,'*','double'), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
+assert_checkequal(cumprod(i,1,'double'), hypermat([2,2,2],[1;254;10;90;1;0;0;0]));
+assert_checkequal(cumprod(i,2,'double'), hypermat([2,2,2],[1;254;10;2286;1;0;0;0]));
+assert_checkequal(cumprod(i,3,'double'), hypermat([2,2,2],[1;254;10;9;1;0;0;0]));
+assert_checkequal(cumprod(i,5,'double'), double(i));
 //=======================================================================
-//Matrices of Polynomials 
+//Matrices of Polynomials
 s=%s;p=[s s+1;s^2 0];
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(p,typ(:))<>[s,s^3+s^4;s^3,0*s]) then bugmes();quit;end
-  if or(cumprod(p,'*',typ(:))<>[s,s^3+s^4;s^3,0*s]) then bugmes();quit;end
-  if or(cumprod(p,1,typ(:))<>[s,1+s;s^3,0*s]) then bugmes();quit;end
-  if or(cumprod(p,2,typ(:))<>[s,s+s^2;s^2,0*s]) then bugmes();quit;end
-  if or(cumprod(p,3,typ(:))<>p) then bugmes();quit;end
+  assert_checkequal(cumprod(p,typ(:)), [s,s^3+s^4;s^3,0*s]);
+  assert_checkequal(cumprod(p,'*',typ(:)), [s,s^3+s^4;s^3,0*s]);
+  assert_checkequal(cumprod(p,1,typ(:)), [s,1+s;s^3,0*s]);
+  assert_checkequal(cumprod(p,2,typ(:)), [s,s+s^2;s^2,0*s]);
+  assert_checkequal(cumprod(p,3,typ(:)), p);
 end
 //with hypermatrices
 s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(p,typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then bugmes();quit;end
-  if or(cumprod(p,'*',typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then bugmes();quit;end
-  if or(cumprod(p,1,typ(:))<>hypermat([2,2,2],[s;s^3;1+s;0*s;-1;0*s;0*s;0*s])) then bugmes();quit;end
-  if or(cumprod(p,2,typ(:))<>hypermat([2,2,2],[s;s^2;s+s^2;0*s;-1;0*s;0*s;0*s])) then bugmes();quit;end
-  if or(cumprod(p,3,typ(:))<>hypermat([2,2,2],[s;s^2;1+s;0*s;-s;0*s;0*s;0*s])) then bugmes();quit;end
-  if or(cumprod(p,5,typ(:))<>p) then bugmes();quit;end
+  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]));
+  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]));
+  assert_checkequal(cumprod(p,1,typ(:)), hypermat([2,2,2],[s;s^3;1+s;0*s;-1;0*s;0*s;0*s]));
+  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]));
+  assert_checkequal(cumprod(p,3,typ(:)), hypermat([2,2,2],[s;s^2;1+s;0*s;-s;0*s;0*s;0*s]));
+  assert_checkequal(cumprod(p,5,typ(:)), p);
 end
 //=======================================================================
 //Matrices of rationals
 s=%s;r=1.0 ./[s s+1;s^2 1];
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(r,typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then bugmes();quit;end
-  if or(cumprod(r,'*',typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then bugmes();quit;end
-  if or(cumprod(r,1,typ(:))<>[1,1;1,1]./[s,1+s;s^3,1+s]) then bugmes();quit;end
-  if or(cumprod(r,2,typ(:))<>[1,1;1,1]./[s,s+s^2;s^2,s^2]) then bugmes();quit;end
-  if or(cumprod(r,3,typ(:))<>r) then bugmes();quit;end
+  assert_checkequal(cumprod(r,typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
+  assert_checkequal(cumprod(r,'*',typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
+  assert_checkequal(cumprod(r,1,typ(:)), [1,1;1,1]./[s,1+s;s^3,1+s]);
+  assert_checkequal(cumprod(r,2,typ(:)), [1,1;1,1]./[s,s+s^2;s^2,s^2]);
+  assert_checkequal(cumprod(r,3,typ(:)), r);
 end
 //=======================================================================
 ///Matrices of boolean
 b=[%t %t;%f %t];
 for typ=list(list(),list('double'));
-  if or(cumprod(b,typ(:))<>[1,0;0,0]) then bugmes();quit;end
-  if or(cumprod(b,'*',typ(:))<>[1,0;0,0]) then bugmes();quit;end
-  if or(cumprod(b,1,typ(:))<>[1,1;0,1]) then bugmes();quit;end
-  if or(cumprod(b,2,typ(:))<>[1,1;0,0]) then bugmes();quit;end
-  if or(cumprod(b,3,typ(:))<>double(b)) then bugmes();quit;end
+  assert_checkequal(cumprod(b,typ(:)), [1,0;0,0]);
+  assert_checkequal(cumprod(b,'*',typ(:)), [1,0;0,0]);
+  assert_checkequal(cumprod(b,1,typ(:)), [1,1;0,1]);
+  assert_checkequal(cumprod(b,2,typ(:)), [1,1;0,0]);
+  assert_checkequal(cumprod(b,3,typ(:)), double(b));
 end
-if or(cumprod(b,'native')<>[%t,%f;%f,%f]) then bugmes();quit;end
-if or(cumprod(b,'*','native')<>[%t,%f;%f,%f]) then bugmes();quit;end
-if or(cumprod(b,1,'native')<>[%t,%t;%f,%t]) then bugmes();quit;end
-if or(cumprod(b,2,'native')<>[%t,%t;%f,%f]) then bugmes();quit;end
-if or(cumprod(b,3,'native')<>b) then bugmes();quit;end
+assert_checkequal(cumprod(b,'native'), [%t,%f;%f,%f]);
+assert_checkequal(cumprod(b,'*','native'), [%t,%f;%f,%f]);
+assert_checkequal(cumprod(b,1,'native'), [%t,%t;%f,%t]);
+assert_checkequal(cumprod(b,2,'native'), [%t,%t;%f,%f]);
+assert_checkequal(cumprod(b,3,'native'), b);
 //with hypermatrices
 b=[%t %t;%f %t];b(1,1,2)=%f;
 for typ=list(list(),list('double'));
-  if or(cumprod(b,typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then bugmes();quit;end
-  if or(cumprod(b,'*',typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then bugmes();quit;end
-  if or(cumprod(b,1,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then bugmes();quit;end
-  if or(cumprod(b,2,typ(:))<>hypermat([2,2,2],[1;0;1;0;0;0;0;0])) then bugmes();quit;end
-  if or(cumprod(b,3,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then bugmes();quit;end
-  if or(cumprod(b,5,typ(:))<>double(b)) then bugmes();quit;end
+  assert_checkequal(cumprod(b,typ(:)), hypermat([2,2,2],[1;0;0;0;0;0;0;0]));
+  assert_checkequal(cumprod(b,'*',typ(:)), hypermat([2,2,2],[1;0;0;0;0;0;0;0]));
+  assert_checkequal(cumprod(b,1,typ(:)), hypermat([2,2,2],[1;0;1;1;0;0;0;0]));
+  assert_checkequal(cumprod(b,2,typ(:)), hypermat([2,2,2],[1;0;1;0;0;0;0;0]));
+  assert_checkequal(cumprod(b,3,typ(:)), hypermat([2,2,2],[1;0;1;1;0;0;0;0]));
+  assert_checkequal(cumprod(b,5,typ(:)), double(b));
 end
-if or(cumprod(b,'native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then bugmes();quit;end
-if or(cumprod(b,'*','native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then bugmes();quit;end
-if or(cumprod(b,1,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then bugmes();quit;end
-if or(cumprod(b,2,'native')<>hypermat([2,2,2],[%t;%f;%t;%f;%f;%f;%f;%f])) then bugmes();quit;end
-if or(cumprod(b,3,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then bugmes();quit;end
-if or(cumprod(b,5,'native')<>b) then bugmes();quit;end
+assert_checkequal(cumprod(b,'native'), hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f]));
+assert_checkequal(cumprod(b,'*','native'), hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f]));
+assert_checkequal(cumprod(b,1,'native'), hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f]));
+assert_checkequal(cumprod(b,2,'native'), hypermat([2,2,2],[%t;%f;%t;%f;%f;%f;%f;%f]));
+assert_checkequal(cumprod(b,3,'native'), hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f]));
+assert_checkequal(cumprod(b,5,'native'), b);
 //=======================================================================
 //sparse matrices of floats
 s=sparse([1 10 0;-1 0 9]);
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(s,typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then bugmes();quit;end
-  if or(cumprod(s,'*',typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then bugmes();quit;end
-  if or(cumprod(s,1,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then bugmes();quit;end
-  if or(cumprod(s,2,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then bugmes();quit;end
-  if or(cumprod(s,3,typ(:))<>s) then bugmes();quit;end
+  assert_checkequal(cumprod(s,typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
+  assert_checkequal(cumprod(s,'*',typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
+  assert_checkequal(cumprod(s,1,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
+  assert_checkequal(cumprod(s,2,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
+  assert_checkequal(cumprod(s,3,typ(:)), s);
 end
 //=======================================================================
 //sparse  matrices of boolean
 bs=sparse([%t %t %f;%t %t %t]);
 for typ=list(list(),list('double'));
-  if or(cumprod(bs,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then bugmes();quit;end
-  if or(cumprod(bs,'*',typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then bugmes();quit;end
-  if or(cumprod(bs,1,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then bugmes();quit;end
-  if or(cumprod(bs,2,typ(:))<>sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3])) then bugmes();quit;end
-  if or(cumprod(bs,3,typ(:))<>bool2s(bs)) then bugmes();quit;end
+  assert_checkequal(cumprod(bs,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
+  assert_checkequal(cumprod(bs,'*',typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
+  assert_checkequal(cumprod(bs,1,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
+  assert_checkequal(cumprod(bs,2,typ(:)), sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3]));
+  assert_checkequal(cumprod(bs,3,typ(:)), bool2s(bs));
 end
-if or(cumprod(bs,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
-if or(cumprod(bs,'*','native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
-if or(cumprod(bs,1,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
-if or(cumprod(bs,2,'native')<>sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3])) then bugmes();quit;end
-if or(cumprod(bs,3,'native')<>bs) then bugmes();quit;end
+assert_checkequal(cumprod(bs,'native'), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumprod(bs,'*','native'), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumprod(bs,1,'native'), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumprod(bs,2,'native'), sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumprod(bs,3,'native'), bs);
 // TODO : test the "m" option
index 0127f9a..5feb303 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2010 - INRIA - Serge Steer
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 //Empty matrices
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if cumprod([],typ(:))<>[] then pause,end
-  if cumprod([],'*',typ(:))<>[] then pause,end
-  if cumprod([],1,typ(:))<>[] then pause,end
-  if cumprod([],2,typ(:))<>[] then pause,end
-  if cumprod([],3,typ(:))<>[] then pause,end
+  assert_checkequal(cumprod([],typ(:)), []);
+  assert_checkequal(cumprod([],'*',typ(:)), []);
+  assert_checkequal(cumprod([],1,typ(:)), []);
+  assert_checkequal(cumprod([],2,typ(:)), []);
+  assert_checkequal(cumprod([],3,typ(:)), []);
 end
 
 //=======================================================================
@@ -23,94 +24,94 @@ end
 d=[1 10;254 9];
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(d,typ(:))<>[1,2540;254,22860]) then pause,end
-  if or(cumprod(d,'*',typ(:))<>[1,2540;254,22860]) then pause,end
-  if or(cumprod(d,1,typ(:))<>[1,10;254,90]) then pause,end
-  if or(cumprod(d,2,typ(:))<>[1,10;254,2286]) then pause,end
-  if or(cumprod(d,3,typ(:))<>d) then pause,end
+  assert_checkequal(cumprod(d,typ(:)), [1,2540;254,22860]);
+  assert_checkequal(cumprod(d,'*',typ(:)), [1,2540;254,22860]);
+  assert_checkequal(cumprod(d,1,typ(:)), [1,10;254,90]);
+  assert_checkequal(cumprod(d,2,typ(:)), [1,10;254,2286]);
+  assert_checkequal(cumprod(d,3,typ(:)), d);
 end
 
 //hypermatrices of floats
 d=[1 10;254 9];d(1,1,2)=1;
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(d,typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
-  if or(cumprod(d,'*',typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
-  if or(cumprod(d,1,typ(:))<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then pause,end
-  if or(cumprod(d,2,typ(:))<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then pause,end
-  if or(cumprod(d,3,typ(:))<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then pause,end
-  if or(cumprod(d,5,typ(:))<>d) then pause,end
+  assert_checkequal(cumprod(d,typ(:)), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
+  assert_checkequal(cumprod(d,'*',typ(:)), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
+  assert_checkequal(cumprod(d,1,typ(:)), hypermat([2,2,2],[1;254;10;90;1;0;0;0]));
+  assert_checkequal(cumprod(d,2,typ(:)), hypermat([2,2,2],[1;254;10;2286;1;0;0;0]));
+  assert_checkequal(cumprod(d,3,typ(:)), hypermat([2,2,2],[1;254;10;9;1;0;0;0]));
+  assert_checkequal(cumprod(d,5,typ(:)), d);
 end
 
 //=======================================================================
 //Integers
 i=uint8([1 10;254 9]);
 for typ=list(list(),list('native'));
-  if or(cumprod(i,typ(:))<>uint8([1,236;254,76])) then pause,end
-  if or(cumprod(i,'*',typ(:))<>uint8([1,236;254,76])) then pause,end
-  if or(cumprod(i,1,typ(:))<>uint8([1,10;254,90])) then pause,end
-  if or(cumprod(i,2,typ(:))<>uint8([1,10;254,238])) then pause,end
-  if or(cumprod(i,3,typ(:))<>i) then pause,end
+  assert_checkequal(cumprod(i,typ(:)), uint8([1,236;254,76]));
+  assert_checkequal(cumprod(i,'*',typ(:)), uint8([1,236;254,76]));
+  assert_checkequal(cumprod(i,1,typ(:)), uint8([1,10;254,90]));
+  assert_checkequal(cumprod(i,2,typ(:)), uint8([1,10;254,238]));
+  assert_checkequal(cumprod(i,3,typ(:)), double(i));
 end
 
-if or(cumprod(i,'double')<>[1,2540;254,22860]) then pause,end
-if or(cumprod(i,'*','double')<>[1,2540;254,22860]) then pause,end
-if or(cumprod(i,1,'double')<>[1,10;254,90]) then pause,end
-if or(cumprod(i,2,'double')<>[1,10;254,2286]) then pause,end
-if or(cumprod(i,3,'double')<>double(i)) then pause,end
+assert_checkequal(cumprod(i,'double'), [1,2540;254,22860]);
+assert_checkequal(cumprod(i,'*','double'), [1,2540;254,22860]);
+assert_checkequal(cumprod(i,1,'double'), [1,10;254,90]);
+assert_checkequal(cumprod(i,2,'double'), [1,10;254,2286]);
+assert_checkequal(cumprod(i,3,'double'), double(i));
 
 //with hypermatrices
 i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
 for typ=list(list(),list('native'));
-  if or(cumprod(i,typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then pause,end
-  if or(cumprod(i,'*',typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then pause,end
-  if or(cumprod(i,1,typ(:))<>hypermat([2,2,2],uint8([1;254;10;90;1;0;0;0]))) then pause,end
-  if or(cumprod(i,2,typ(:))<>hypermat([2,2,2],uint8([1;254;10;238;1;0;0;0]))) then pause,end
-  if or(cumprod(i,3,typ(:))<>hypermat([2,2,2],uint8([1;254;10;9;1;0;0;0]))) then pause,end
-  if or(cumprod(i,5,typ(:))<>i) then pause,end
+  assert_checkequal(cumprod(i,typ(:)), hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0])));
+  assert_checkequal(cumprod(i,'*',typ(:)), hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0])));
+  assert_checkequal(cumprod(i,1,typ(:)), hypermat([2,2,2],uint8([1;254;10;90;1;0;0;0])));
+  assert_checkequal(cumprod(i,2,typ(:)), hypermat([2,2,2],uint8([1;254;10;238;1;0;0;0])));
+  assert_checkequal(cumprod(i,3,typ(:)), hypermat([2,2,2],uint8([1;254;10;9;1;0;0;0])));
+  assert_checkequal(cumprod(i,5,typ(:)), double(i));
 end
 
 
-if or(cumprod(i,'double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
-if or(cumprod(i,'*','double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
-if or(cumprod(i,1,'double')<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then pause,end
-if or(cumprod(i,2,'double')<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then pause,end
-if or(cumprod(i,3,'double')<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then pause,end
-if or(cumprod(i,5,'double')<>double(i)) then pause,end
+assert_checkequal(cumprod(i,'double'), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
+assert_checkequal(cumprod(i,'*','double'), hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0]));
+assert_checkequal(cumprod(i,1,'double'), hypermat([2,2,2],[1;254;10;90;1;0;0;0]));
+assert_checkequal(cumprod(i,2,'double'), hypermat([2,2,2],[1;254;10;2286;1;0;0;0]));
+assert_checkequal(cumprod(i,3,'double'), hypermat([2,2,2],[1;254;10;9;1;0;0;0]));
+assert_checkequal(cumprod(i,5,'double'), double(i));
 
 //=======================================================================
-//Matrices of Polynomials 
+//Matrices of Polynomials
 s=%s;p=[s s+1;s^2 0];
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(p,typ(:))<>[s,s^3+s^4;s^3,0*s]) then pause,end
-  if or(cumprod(p,'*',typ(:))<>[s,s^3+s^4;s^3,0*s]) then pause,end
-  if or(cumprod(p,1,typ(:))<>[s,1+s;s^3,0*s]) then pause,end
-  if or(cumprod(p,2,typ(:))<>[s,s+s^2;s^2,0*s]) then pause,end
-  if or(cumprod(p,3,typ(:))<>p) then pause,end
+  assert_checkequal(cumprod(p,typ(:)), [s,s^3+s^4;s^3,0*s]);
+  assert_checkequal(cumprod(p,'*',typ(:)), [s,s^3+s^4;s^3,0*s]);
+  assert_checkequal(cumprod(p,1,typ(:)), [s,1+s;s^3,0*s]);
+  assert_checkequal(cumprod(p,2,typ(:)), [s,s+s^2;s^2,0*s]);
+  assert_checkequal(cumprod(p,3,typ(:)), p);
 end
 
 //with hypermatrices
 s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(p,typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then pause,end
-  if or(cumprod(p,'*',typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then pause,end
-  if or(cumprod(p,1,typ(:))<>hypermat([2,2,2],[s;s^3;1+s;0*s;-1;0*s;0*s;0*s])) then pause,end
-  if or(cumprod(p,2,typ(:))<>hypermat([2,2,2],[s;s^2;s+s^2;0*s;-1;0*s;0*s;0*s])) then pause,end
-  if or(cumprod(p,3,typ(:))<>hypermat([2,2,2],[s;s^2;1+s;0*s;-s;0*s;0*s;0*s])) then pause,end
-  if or(cumprod(p,5,typ(:))<>p) then pause,end
+  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]));
+  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]));
+  assert_checkequal(cumprod(p,1,typ(:)), hypermat([2,2,2],[s;s^3;1+s;0*s;-1;0*s;0*s;0*s]));
+  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]));
+  assert_checkequal(cumprod(p,3,typ(:)), hypermat([2,2,2],[s;s^2;1+s;0*s;-s;0*s;0*s;0*s]));
+  assert_checkequal(cumprod(p,5,typ(:)), p);
 end
 //=======================================================================
 //Matrices of rationals
 s=%s;r=1.0 ./[s s+1;s^2 1];
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(r,typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then pause,end
-  if or(cumprod(r,'*',typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then pause,end
-  if or(cumprod(r,1,typ(:))<>[1,1;1,1]./[s,1+s;s^3,1+s]) then pause,end
-  if or(cumprod(r,2,typ(:))<>[1,1;1,1]./[s,s+s^2;s^2,s^2]) then pause,end
-  if or(cumprod(r,3,typ(:))<>r) then pause,end
+  assert_checkequal(cumprod(r,typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
+  assert_checkequal(cumprod(r,'*',typ(:)), [1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]);
+  assert_checkequal(cumprod(r,1,typ(:)), [1,1;1,1]./[s,1+s;s^3,1+s]);
+  assert_checkequal(cumprod(r,2,typ(:)), [1,1;1,1]./[s,s+s^2;s^2,s^2]);
+  assert_checkequal(cumprod(r,3,typ(:)), r);
 end
 
 //=======================================================================
@@ -118,64 +119,64 @@ end
 
 b=[%t %t;%f %t];
 for typ=list(list(),list('double'));
-  if or(cumprod(b,typ(:))<>[1,0;0,0]) then pause,end
-  if or(cumprod(b,'*',typ(:))<>[1,0;0,0]) then pause,end
-  if or(cumprod(b,1,typ(:))<>[1,1;0,1]) then pause,end
-  if or(cumprod(b,2,typ(:))<>[1,1;0,0]) then pause,end
-  if or(cumprod(b,3,typ(:))<>double(b)) then pause,end
+  assert_checkequal(cumprod(b,typ(:)), [1,0;0,0]);
+  assert_checkequal(cumprod(b,'*',typ(:)), [1,0;0,0]);
+  assert_checkequal(cumprod(b,1,typ(:)), [1,1;0,1]);
+  assert_checkequal(cumprod(b,2,typ(:)), [1,1;0,0]);
+  assert_checkequal(cumprod(b,3,typ(:)), double(b));
 end
-if or(cumprod(b,'native')<>[%t,%f;%f,%f]) then pause,end
-if or(cumprod(b,'*','native')<>[%t,%f;%f,%f]) then pause,end
-if or(cumprod(b,1,'native')<>[%t,%t;%f,%t]) then pause,end
-if or(cumprod(b,2,'native')<>[%t,%t;%f,%f]) then pause,end
-if or(cumprod(b,3,'native')<>b) then pause,end
+assert_checkequal(cumprod(b,'native'), [%t,%f;%f,%f]);
+assert_checkequal(cumprod(b,'*','native'), [%t,%f;%f,%f]);
+assert_checkequal(cumprod(b,1,'native'), [%t,%t;%f,%t]);
+assert_checkequal(cumprod(b,2,'native'), [%t,%t;%f,%f]);
+assert_checkequal(cumprod(b,3,'native'), b);
 
 //with hypermatrices
 b=[%t %t;%f %t];b(1,1,2)=%f;
 for typ=list(list(),list('double'));
-  if or(cumprod(b,typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then pause,end
-  if or(cumprod(b,'*',typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then pause,end
-  if or(cumprod(b,1,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then pause,end
-  if or(cumprod(b,2,typ(:))<>hypermat([2,2,2],[1;0;1;0;0;0;0;0])) then pause,end
-  if or(cumprod(b,3,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then pause,end
-  if or(cumprod(b,5,typ(:))<>double(b)) then pause,end
+  assert_checkequal(cumprod(b,typ(:)), hypermat([2,2,2],[1;0;0;0;0;0;0;0]));
+  assert_checkequal(cumprod(b,'*',typ(:)), hypermat([2,2,2],[1;0;0;0;0;0;0;0]));
+  assert_checkequal(cumprod(b,1,typ(:)), hypermat([2,2,2],[1;0;1;1;0;0;0;0]));
+  assert_checkequal(cumprod(b,2,typ(:)), hypermat([2,2,2],[1;0;1;0;0;0;0;0]));
+  assert_checkequal(cumprod(b,3,typ(:)), hypermat([2,2,2],[1;0;1;1;0;0;0;0]));
+  assert_checkequal(cumprod(b,5,typ(:)), double(b));
 end
 
-if or(cumprod(b,'native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then pause,end
-if or(cumprod(b,'*','native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then pause,end
-if or(cumprod(b,1,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then pause,end
-if or(cumprod(b,2,'native')<>hypermat([2,2,2],[%t;%f;%t;%f;%f;%f;%f;%f])) then pause,end
-if or(cumprod(b,3,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then pause,end
-if or(cumprod(b,5,'native')<>b) then pause,end
+assert_checkequal(cumprod(b,'native'), hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f]));
+assert_checkequal(cumprod(b,'*','native'), hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f]));
+assert_checkequal(cumprod(b,1,'native'), hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f]));
+assert_checkequal(cumprod(b,2,'native'), hypermat([2,2,2],[%t;%f;%t;%f;%f;%f;%f;%f]));
+assert_checkequal(cumprod(b,3,'native'), hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f]));
+assert_checkequal(cumprod(b,5,'native'), b);
 
 //=======================================================================
 //sparse matrices of floats
 s=sparse([1 10 0;-1 0 9]);
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumprod(s,typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then pause,end
-  if or(cumprod(s,'*',typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then pause,end
-  if or(cumprod(s,1,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then pause,end
-  if or(cumprod(s,2,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then pause,end
-  if or(cumprod(s,3,typ(:))<>s) then pause,end
+  assert_checkequal(cumprod(s,typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
+  assert_checkequal(cumprod(s,'*',typ(:)), sparse([1,1;1,2;2,1],[1;-10;-1],[2,3]));
+  assert_checkequal(cumprod(s,1,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
+  assert_checkequal(cumprod(s,2,typ(:)), sparse([1,1;1,2;2,1],[1;10;-1],[2,3]));
+  assert_checkequal(cumprod(s,3,typ(:)), s);
 end
 
 //=======================================================================
 //sparse  matrices of boolean
 bs=sparse([%t %t %f;%t %t %t]);
 for typ=list(list(),list('double'));
-  if or(cumprod(bs,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
-  if or(cumprod(bs,'*',typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
-  if or(cumprod(bs,1,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
-  if or(cumprod(bs,2,typ(:))<>sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3])) then pause,end
-  if or(cumprod(bs,3,typ(:))<>bool2s(bs)) then pause,end
+  assert_checkequal(cumprod(bs,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
+  assert_checkequal(cumprod(bs,'*',typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
+  assert_checkequal(cumprod(bs,1,typ(:)), sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3]));
+  assert_checkequal(cumprod(bs,2,typ(:)), sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3]));
+  assert_checkequal(cumprod(bs,3,typ(:)), bool2s(bs));
 end
 
-if or(cumprod(bs,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
-if or(cumprod(bs,'*','native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
+assert_checkequal(cumprod(bs,'native'), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumprod(bs,'*','native'), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
 
-if or(cumprod(bs,1,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
-if or(cumprod(bs,2,'native')<>sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3])) then pause,end
-if or(cumprod(bs,3,'native')<>bs) then pause,end
+assert_checkequal(cumprod(bs,1,'native'), sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumprod(bs,2,'native'), sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumprod(bs,3,'native'), bs);
 
 // TODO : test the "m" option
index 70564e3..d7815d6 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2010 - INRIA - Serge Steer
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 //empty matrices
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if cumsum([],typ(:))<>[] then bugmes();quit;end
-  if cumsum([],'*',typ(:))<>[] then bugmes();quit;end
-  if cumsum([],1,typ(:))<>[] then bugmes();quit;end
-  if cumsum([],2,typ(:))<>[] then bugmes();quit;end
-  if cumsum([],3,typ(:))<>[] then bugmes();quit;end
+    assert_checkequal(cumsum([],typ(:)), []);
+    assert_checkequal(cumsum([],'*',typ(:)), []);
+    assert_checkequal(cumsum([],1,typ(:)), []);
+    assert_checkequal(cumsum([],2,typ(:)), []);
+    assert_checkequal(cumsum([],3,typ(:)), []);
 end
 //=======================================================================
 //float matrices
 d=[1 10;254 9];
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumsum(d,typ(:))<>[1,265;255,274]) then bugmes();quit;end
-  if or(cumsum(d,'*',typ(:))<>[1,265;255,274]) then bugmes();quit;end
-  if or(cumsum(d,1,typ(:))<>[1,10;255,19]) then bugmes();quit;end
-  if or(cumsum(d,2,typ(:))<>[1,11;254,263]) then bugmes();quit;end
-  if or(cumsum(d,3,typ(:))<>d) then bugmes();quit;end
+    assert_checkequal(cumsum(d,typ(:)), [1,265;255,274]);
+    assert_checkequal(cumsum(d,'*',typ(:)), [1,265;255,274]);
+    assert_checkequal(cumsum(d,1,typ(:)), [1,10;255,19]);
+    assert_checkequal(cumsum(d,2,typ(:)), [1,11;254,263]);
+    assert_checkequal(cumsum(d,3,typ(:)), d);
 end
 //hypermatrices of floats
 d=[1 10;254 9];d(1,1,2)=1;
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumsum(d,typ(:))<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then bugmes();quit;end
-  if or(cumsum(d,'*',typ(:))<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then bugmes();quit;end
-  if or(cumsum(d,1,typ(:))<>hypermat([2,2,2],[1;255;10;19;1;1;0;0])) then bugmes();quit;end
-  if or(cumsum(d,2,typ(:))<>hypermat([2,2,2],[1;254;11;263;1;0;1;0])) then bugmes();quit;end
-  if or(cumsum(d,3,typ(:))<>hypermat([2,2,2],[1;254;10;9;2;254;10;9])) then bugmes();quit;end
-  if or(cumsum(d,5,typ(:))<>d) then bugmes();quit;end
+    assert_checkequal(cumsum(d,typ(:)), hypermat([2,2,2],[1;255;265;274;275;275;275;275]));
+    assert_checkequal(cumsum(d,'*',typ(:)), hypermat([2,2,2],[1;255;265;274;275;275;275;275]));
+    assert_checkequal(cumsum(d,1,typ(:)), hypermat([2,2,2],[1;255;10;19;1;1;0;0]));
+    assert_checkequal(cumsum(d,2,typ(:)), hypermat([2,2,2],[1;254;11;263;1;0;1;0]));
+    assert_checkequal(cumsum(d,3,typ(:)), hypermat([2,2,2],[1;254;10;9;2;254;10;9]));
+    assert_checkequal(cumsum(d,5,typ(:)), d);
 end
 //=======================================================================
 //Integers
 i=uint8([1 10;254 9]);
 for typ=list(list(),list('native'));
-  if or(cumsum(i,typ(:))<>uint8([1,9;255,18])) then bugmes();quit;end
-  if or(cumsum(i,'*',typ(:))<>uint8([1,9;255,18])) then bugmes();quit;end
-  if or(cumsum(i,1,typ(:))<>uint8([1,10;255,19])) then bugmes();quit;end
-  if or(cumsum(i,2,typ(:))<>uint8([1,11;254,7])) then bugmes();quit;end
-  if or(cumsum(i,3,typ(:))<>i) then bugmes();quit;end
+    assert_checkequal(cumsum(i,typ(:)), uint8([1,9;255,18]));
+    assert_checkequal(cumsum(i,'*',typ(:)), uint8([1,9;255,18]));
+    assert_checkequal(cumsum(i,1,typ(:)), uint8([1,10;255,19]));
+    assert_checkequal(cumsum(i,2,typ(:)), uint8([1,11;254,7]));
+    assert_checkequal(cumsum(i,3,typ(:)), double(i));
 end
-if or(cumsum(i,'double')<>[1,265;255,274]) then bugmes();quit;end
-if or(cumsum(i,'*','double')<>[1,265;255,274]) then bugmes();quit;end
-if or(cumsum(i,1,'double')<>[1,10;255,19]) then bugmes();quit;end
-if or(cumsum(i,2,'double')<>[1,11;254,263]) then bugmes();quit;end
-if or(cumsum(i,3,'double')<>double(i)) then bugmes();quit;end
+assert_checkequal(cumsum(i,'double'), [1,265;255,274]);
+assert_checkequal(cumsum(i,'*','double'), [1,265;255,274]);
+assert_checkequal(cumsum(i,1,'double'), [1,10;255,19]);
+assert_checkequal(cumsum(i,2,'double'), [1,11;254,263]);
+assert_checkequal(cumsum(i,3,'double'), double(i));
 //with hypermatrices
 i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
 for typ=list(list(),list('native'));
-  if or(cumsum(i,typ(:))<>hypermat([2,2,2],uint8([1;255;9;18;19;19;19;19]))) then bugmes();quit;end
-  if or(cumsum(i,'*',typ(:))<>hypermat([2,2,2],uint8([1;255;9;18;19;19;19;19]))) then bugmes();quit;end
-  if or(cumsum(i,1,typ(:))<>hypermat([2,2,2],uint8([1;255;10;19;1;1;0;0]))) then bugmes();quit;end
-  if or(cumsum(i,2,typ(:))<>hypermat([2,2,2],uint8([1;254;11;7;1;0;1;0]))) then bugmes();quit;end
-  if or(cumsum(i,3,typ(:))<>hypermat([2,2,2],uint8([1;254;10;9;2;254;10;9]))) then bugmes();quit;end
-  if or(cumsum(i,5,typ(:))<>i) then bugmes();quit;end
+    assert_checkequal(cumsum(i,typ(:)), hypermat([2,2,2],[1;255;9;18;19;19;19;19]));
+    assert_checkequal(cumsum(i,'*',typ(:)), hypermat([2,2,2],[1;255;9;18;19;19;19;19]));
+    assert_checkequal(cumsum(i,1,typ(:)), hypermat([2,2,2],[1;255;10;19;1;1;0;0]));
+    assert_checkequal(cumsum(i,2,typ(:)), hypermat([2,2,2],[1;254;11;7;1;0;1;0]));
+    assert_checkequal(cumsum(i,3,typ(:)), hypermat([2,2,2],[1;254;10;9;2;254;10;9]));
+    assert_checkequal(cumsum(i,5,typ(:)), double(i));
 end
-if or(cumsum(i,'double')<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then bugmes();quit;end
-if or(cumsum(i,'*','double')<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then bugmes();quit;end
-if or(cumsum(i,1,'double')<>hypermat([2,2,2],[1;255;10;19;1;1;0;0])) then bugmes();quit;end
-if or(cumsum(i,2,'double')<>hypermat([2,2,2],[1;254;11;263;1;0;1;0])) then bugmes();quit;end
-if or(cumsum(i,3,'double')<>hypermat([2,2,2],[1;254;10;9;2;254;10;9])) then bugmes();quit;end
-if or(cumsum(i,5,'double')<>double(i)) then bugmes();quit;end
+assert_checkequal(cumsum(i,'double'), hypermat([2,2,2],[1;255;265;274;275;275;275;275]));
+assert_checkequal(cumsum(i,'*','double'), hypermat([2,2,2],[1;255;265;274;275;275;275;275]));
+assert_checkequal(cumsum(i,1,'double'), hypermat([2,2,2],[1;255;10;19;1;1;0;0]));
+assert_checkequal(cumsum(i,2,'double'), hypermat([2,2,2],[1;254;11;263;1;0;1;0]));
+assert_checkequal(cumsum(i,3,'double'), hypermat([2,2,2],[1;254;10;9;2;254;10;9]));
+assert_checkequal(cumsum(i,5,'double'), double(i));
 //=======================================================================
 //Matrices of Polynomials
 s=%s;p=[s s+1;s^2 0];
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumsum(p,typ(:))<>[s,1+2*s+s^2;s+s^2,1+2*s+s^2]) then bugmes();quit;end
-  if or(cumsum(p,'*',typ(:))<>[s,1+2*s+s^2;s+s^2,1+2*s+s^2]) then bugmes();quit;end
-  if or(cumsum(p,1,typ(:))<>[s,1+s;s+s^2,1+s]) then bugmes();quit;end
-  if or(cumsum(p,2,typ(:))<>[s,1+2*s;s^2,s^2]) then bugmes();quit;end
-  if or(cumsum(p,3,typ(:))<>p) then bugmes();quit;end
+  assert_checkequal(cumsum(p,typ(:)), [s,1+2*s+s^2;s+s^2,1+2*s+s^2]);
+  assert_checkequal(cumsum(p,'*',typ(:)), [s,1+2*s+s^2;s+s^2,1+2*s+s^2]);
+  assert_checkequal(cumsum(p,1,typ(:)), [s,1+s;s+s^2,1+s]);
+  assert_checkequal(cumsum(p,2,typ(:)), [s,1+2*s;s^2,s^2]);
+  assert_checkequal(cumsum(p,3,typ(:)), p);
 end
 //with hypermatrices
 s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumsum(p,typ(:))<>hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2])) then bugmes();quit;end
-  if or(cumsum(p,'*',typ(:))<>hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2])) then bugmes();quit;end
-  if or(cumsum(p,1,typ(:))<>hypermat([2,2,2],[s;s+s^2;1+s;1+s;-1;-1;0*s;0*s])) then bugmes();quit;end
-  if or(cumsum(p,2,typ(:))<>hypermat([2,2,2],[s;s^2;1+2*s;s^2;-1;0*s;-1;0*s])) then bugmes();quit;end
-  if or(cumsum(p,3,typ(:))<>hypermat([2,2,2],[s;s^2;1+s;0*s;-1+s;s^2;1+s;0*s])) then bugmes();quit;end
-  if or(cumsum(p,5,typ(:))<>p) then bugmes();quit;end
+  assert_checkequal(cumsum(p,typ(:)), hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2]));
+  assert_checkequal(cumsum(p,'*',typ(:)), hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2]));
+  assert_checkequal(cumsum(p,1,typ(:)), hypermat([2,2,2],[s;s+s^2;1+s;1+s;-1;-1;0*s;0*s]));
+  assert_checkequal(cumsum(p,2,typ(:)), hypermat([2,2,2],[s;s^2;1+2*s;s^2;-1;0*s;-1;0*s]));
+  assert_checkequal(cumsum(p,3,typ(:)), hypermat([2,2,2],[s;s^2;1+s;0*s;-1+s;s^2;1+s;0*s]));
+  assert_checkequal(cumsum(p,5,typ(:)), p);
 end
 //=======================================================================
 ///Matrices of boolean
 b=[%t %t;%f %t];
 for typ=list(list(),list('double'));
-  if or(cumsum(b,typ(:))<>[1,2;1,3]) then bugmes();quit;end
-  if or(cumsum(b,'*',typ(:))<>[1,2;1,3]) then bugmes();quit;end
-  if or(cumsum(b,1,typ(:))<>[1,1;1,2]) then bugmes();quit;end
-  if or(cumsum(b,2,typ(:))<>[1,2;0,1]) then bugmes();quit;end
-  if or(cumsum(b,3,typ(:))<>double(b)) then bugmes();quit;end
+  assert_checkequal(cumsum(b,typ(:)), [1,2;1,3]);
+  assert_checkequal(cumsum(b,'*',typ(:)), [1,2;1,3]);
+  assert_checkequal(cumsum(b,1,typ(:)), [1,1;1,2]);
+  assert_checkequal(cumsum(b,2,typ(:)), [1,2;0,1]);
+  assert_checkequal(cumsum(b,3,typ(:)), double(b));
 end
-if or(cumsum(b,'native')<>[%t %t;%t %t]) then bugmes();quit;end
-if or(cumsum(b,'*','native')<>[%t %t;%t %t]) then bugmes();quit;end
-if or(cumsum(b,1,'native')<>[%t %t;%t %t]) then bugmes();quit;end
-if or(cumsum(b,2,'native')<>[%t %t;%f %t]) then bugmes();quit;end
-if or(cumsum(b,3,'native')<>b) then bugmes();quit;end
+assert_checkequal(cumsum(b,'native'), [%t %t;%t %t]);
+assert_checkequal(cumsum(b,'*','native'), [%t %t;%t %t]);
+assert_checkequal(cumsum(b,1,'native'), [%t %t;%t %t]);
+assert_checkequal(cumsum(b,2,'native'), [%t %t;%f %t]);
+assert_checkequal(cumsum(b,3,'native'), b);
 //with hypermatrices
 b=[%t %t;%f %t];b(1,1,2)=%f;
 for typ=list(list(),list('double'));
-  if or(cumsum(b,typ(:))<>hypermat([2,2,2],[1;1;2;3;3;3;3;3])) then bugmes();quit;end
-  if or(cumsum(b,'*',typ(:))<>hypermat([2,2,2],[1;1;2;3;3;3;3;3])) then bugmes();quit;end
-  if or(cumsum(b,1,typ(:))<>hypermat([2,2,2],[1;1;1;2;0;0;0;0])) then bugmes();quit;end
-  if or(cumsum(b,2,typ(:))<>hypermat([2,2,2],[1;0;2;1;0;0;0;0])) then bugmes();quit;end
-  if or(cumsum(b,3,typ(:))<>hypermat([2,2,2],[1;0;1;1;1;0;1;1])) then bugmes();quit;end
-  if or(cumsum(b,5,typ(:))<>double(b)) then bugmes();quit;end
+  assert_checkequal(cumsum(b,typ(:)), hypermat([2,2,2],[1;1;2;3;3;3;3;3]));
+  assert_checkequal(cumsum(b,'*',typ(:)), hypermat([2,2,2],[1;1;2;3;3;3;3;3]));
+  assert_checkequal(cumsum(b,1,typ(:)), hypermat([2,2,2],[1;1;1;2;0;0;0;0]));
+  assert_checkequal(cumsum(b,2,typ(:)), hypermat([2,2,2],[1;0;2;1;0;0;0;0]));
+  assert_checkequal(cumsum(b,3,typ(:)), hypermat([2,2,2],[1;0;1;1;1;0;1;1]));
+  assert_checkequal(cumsum(b,5,typ(:)), double(b));
 end
-if or(cumsum(b,'native')<>hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t])) then bugmes();quit;end
-if or(cumsum(b,'*','native')<>hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t])) then bugmes();quit;end
-if or(cumsum(b,1,'native')<>hypermat([2,2,2],[%t;%t;%t;%t;%f;%f;%f;%f])) then bugmes();quit;end
-if or(cumsum(b,2,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then bugmes();quit;end
-if or(cumsum(b,3,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%t;%f;%t;%t])) then bugmes();quit;end
-if or(cumsum(b,5,'native')<>b) then bugmes();quit;end
+assert_checkequal(cumsum(b,'native'), hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t]));
+assert_checkequal(cumsum(b,'*','native'), hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t]));
+assert_checkequal(cumsum(b,1,'native'), hypermat([2,2,2],[%t;%t;%t;%t;%f;%f;%f;%f]));
+assert_checkequal(cumsum(b,2,'native'), hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f]));
+assert_checkequal(cumsum(b,3,'native'), hypermat([2,2,2],[%t;%f;%t;%t;%t;%f;%t;%t]));
+assert_checkequal(cumsum(b,5,'native'), b);
 //=======================================================================
 //sparse matrices of floats
 s=sparse([0 10 0;0 254 9]);
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumsum(s,typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3])) then bugmes();quit;end
-  if or(cumsum(s,'*',typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3])) then bugmes();quit;end
-  if or(cumsum(s,1,typ(:))<>sparse([1,2;2,2;2,3],[10;264;9],[2,3])) then bugmes();quit;end
-  if or(cumsum(s,2,typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;10;254;263],[2,3])) then bugmes();quit;end
-  if or(cumsum(s,3,typ(:))<>s) then bugmes();quit;end
+  assert_checkequal(cumsum(s,typ(:)), sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3]));
+  assert_checkequal(cumsum(s,'*',typ(:)), sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3]));
+  assert_checkequal(cumsum(s,1,typ(:)), sparse([1,2;2,2;2,3],[10;264;9],[2,3]));
+  assert_checkequal(cumsum(s,2,typ(:)), sparse([1,2;1,3;2,2;2,3],[10;10;254;263],[2,3]));
+  assert_checkequal(cumsum(s,3,typ(:)), s);
 end
 //=======================================================================
 //sparse  matrices of boolean
 bs=sparse([0 10 0;0 254 9])<>0;
 for typ=list(list(),list('double'));
-  if or(cumsum(bs,typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3])) then bugmes();quit;end
-  if or(cumsum(bs,'*',typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3])) then bugmes();quit;end
-  if or(cumsum(bs,1,typ(:))<>sparse([1,2;2,2;2,3],[1;2;1],[2,3])) then bugmes();quit;end
-  if or(cumsum(bs,2,typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;1;1;2],[2,3])) then bugmes();quit;end
-  if or(cumsum(bs,3,typ(:))<>bool2s(bs)) then bugmes();quit;end
+  assert_checkequal(cumsum(bs,typ(:)), sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3]));
+  assert_checkequal(cumsum(bs,'*',typ(:)), sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3]));
+  assert_checkequal(cumsum(bs,1,typ(:)), sparse([1,2;2,2;2,3],[1;2;1],[2,3]));
+  assert_checkequal(cumsum(bs,2,typ(:)), sparse([1,2;1,3;2,2;2,3],[1;1;1;2],[2,3]));
+  assert_checkequal(cumsum(bs,3,typ(:)), bool2s(bs));
 end
-if or(cumsum(bs,'native')<> sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
-if or(cumsum(bs,'*','native')<> sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
-if or(cumsum(bs,1,'native')<>sparse([1,2;2,2;2,3],[%t;%t;%t],[2,3])) then bugmes();quit;end
-if or(cumsum(bs,2,'native')<>sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
-if or(cumsum(bs,3,'native')<>bs) then bugmes();quit;end
+assert_checkequal(cumsum(bs,'native'),  sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumsum(bs,'*','native'),  sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumsum(bs,1,'native'), sparse([1,2;2,2;2,3],[%t;%t;%t],[2,3]));
+assert_checkequal(cumsum(bs,2,'native'), sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumsum(bs,3,'native'), bs);
 // TODO : test the "m" option
index 2aab340..030082b 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2010 - INRIA - Serge Steer
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 //empty matrices
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if cumsum([],typ(:))<>[] then pause,end
-  if cumsum([],'*',typ(:))<>[] then pause,end
-  if cumsum([],1,typ(:))<>[] then pause,end
-  if cumsum([],2,typ(:))<>[] then pause,end
-  if cumsum([],3,typ(:))<>[] then pause,end
+    assert_checkequal(cumsum([],typ(:)), []);
+    assert_checkequal(cumsum([],'*',typ(:)), []);
+    assert_checkequal(cumsum([],1,typ(:)), []);
+    assert_checkequal(cumsum([],2,typ(:)), []);
+    assert_checkequal(cumsum([],3,typ(:)), []);
 end
 
 //=======================================================================
@@ -22,83 +23,83 @@ end
 d=[1 10;254 9];
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumsum(d,typ(:))<>[1,265;255,274]) then pause,end
-  if or(cumsum(d,'*',typ(:))<>[1,265;255,274]) then pause,end
-  if or(cumsum(d,1,typ(:))<>[1,10;255,19]) then pause,end
-  if or(cumsum(d,2,typ(:))<>[1,11;254,263]) then pause,end
-  if or(cumsum(d,3,typ(:))<>d) then pause,end
+    assert_checkequal(cumsum(d,typ(:)), [1,265;255,274]);
+    assert_checkequal(cumsum(d,'*',typ(:)), [1,265;255,274]);
+    assert_checkequal(cumsum(d,1,typ(:)), [1,10;255,19]);
+    assert_checkequal(cumsum(d,2,typ(:)), [1,11;254,263]);
+    assert_checkequal(cumsum(d,3,typ(:)), d);
 end
 
 //hypermatrices of floats
 d=[1 10;254 9];d(1,1,2)=1;
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumsum(d,typ(:))<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then pause,end
-  if or(cumsum(d,'*',typ(:))<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then pause,end
-  if or(cumsum(d,1,typ(:))<>hypermat([2,2,2],[1;255;10;19;1;1;0;0])) then pause,end
-  if or(cumsum(d,2,typ(:))<>hypermat([2,2,2],[1;254;11;263;1;0;1;0])) then pause,end
-  if or(cumsum(d,3,typ(:))<>hypermat([2,2,2],[1;254;10;9;2;254;10;9])) then pause,end
-  if or(cumsum(d,5,typ(:))<>d) then pause,end
+    assert_checkequal(cumsum(d,typ(:)), hypermat([2,2,2],[1;255;265;274;275;275;275;275]));
+    assert_checkequal(cumsum(d,'*',typ(:)), hypermat([2,2,2],[1;255;265;274;275;275;275;275]));
+    assert_checkequal(cumsum(d,1,typ(:)), hypermat([2,2,2],[1;255;10;19;1;1;0;0]));
+    assert_checkequal(cumsum(d,2,typ(:)), hypermat([2,2,2],[1;254;11;263;1;0;1;0]));
+    assert_checkequal(cumsum(d,3,typ(:)), hypermat([2,2,2],[1;254;10;9;2;254;10;9]));
+    assert_checkequal(cumsum(d,5,typ(:)), d);
 end
 
 //=======================================================================
 //Integers
 i=uint8([1 10;254 9]);
 for typ=list(list(),list('native'));
-  if or(cumsum(i,typ(:))<>uint8([1,9;255,18])) then pause,end
-  if or(cumsum(i,'*',typ(:))<>uint8([1,9;255,18])) then pause,end
-  if or(cumsum(i,1,typ(:))<>uint8([1,10;255,19])) then pause,end
-  if or(cumsum(i,2,typ(:))<>uint8([1,11;254,7])) then pause,end
-  if or(cumsum(i,3,typ(:))<>i) then pause,end
+    assert_checkequal(cumsum(i,typ(:)), uint8([1,9;255,18]));
+    assert_checkequal(cumsum(i,'*',typ(:)), uint8([1,9;255,18]));
+    assert_checkequal(cumsum(i,1,typ(:)), uint8([1,10;255,19]));
+    assert_checkequal(cumsum(i,2,typ(:)), uint8([1,11;254,7]));
+    assert_checkequal(cumsum(i,3,typ(:)), double(i));
 end
 
-if or(cumsum(i,'double')<>[1,265;255,274]) then pause,end
-if or(cumsum(i,'*','double')<>[1,265;255,274]) then pause,end
-if or(cumsum(i,1,'double')<>[1,10;255,19]) then pause,end
-if or(cumsum(i,2,'double')<>[1,11;254,263]) then pause,end
-if or(cumsum(i,3,'double')<>double(i)) then pause,end
+assert_checkequal(cumsum(i,'double'), [1,265;255,274]);
+assert_checkequal(cumsum(i,'*','double'), [1,265;255,274]);
+assert_checkequal(cumsum(i,1,'double'), [1,10;255,19]);
+assert_checkequal(cumsum(i,2,'double'), [1,11;254,263]);
+assert_checkequal(cumsum(i,3,'double'), double(i));
 
 //with hypermatrices
 i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
 for typ=list(list(),list('native'));
-  if or(cumsum(i,typ(:))<>hypermat([2,2,2],uint8([1;255;9;18;19;19;19;19]))) then pause,end
-  if or(cumsum(i,'*',typ(:))<>hypermat([2,2,2],uint8([1;255;9;18;19;19;19;19]))) then pause,end
-  if or(cumsum(i,1,typ(:))<>hypermat([2,2,2],uint8([1;255;10;19;1;1;0;0]))) then pause,end
-  if or(cumsum(i,2,typ(:))<>hypermat([2,2,2],uint8([1;254;11;7;1;0;1;0]))) then pause,end
-  if or(cumsum(i,3,typ(:))<>hypermat([2,2,2],uint8([1;254;10;9;2;254;10;9]))) then pause,end
-  if or(cumsum(i,5,typ(:))<>i) then pause,end
+    assert_checkequal(cumsum(i,typ(:)), hypermat([2,2,2],[1;255;9;18;19;19;19;19]));
+    assert_checkequal(cumsum(i,'*',typ(:)), hypermat([2,2,2],[1;255;9;18;19;19;19;19]));
+    assert_checkequal(cumsum(i,1,typ(:)), hypermat([2,2,2],[1;255;10;19;1;1;0;0]));
+    assert_checkequal(cumsum(i,2,typ(:)), hypermat([2,2,2],[1;254;11;7;1;0;1;0]));
+    assert_checkequal(cumsum(i,3,typ(:)), hypermat([2,2,2],[1;254;10;9;2;254;10;9]));
+    assert_checkequal(cumsum(i,5,typ(:)), double(i));
 end
 
 
-if or(cumsum(i,'double')<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then pause,end
-if or(cumsum(i,'*','double')<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then pause,end
-if or(cumsum(i,1,'double')<>hypermat([2,2,2],[1;255;10;19;1;1;0;0])) then pause,end
-if or(cumsum(i,2,'double')<>hypermat([2,2,2],[1;254;11;263;1;0;1;0])) then pause,end
-if or(cumsum(i,3,'double')<>hypermat([2,2,2],[1;254;10;9;2;254;10;9])) then pause,end
-if or(cumsum(i,5,'double')<>double(i)) then pause,end
+assert_checkequal(cumsum(i,'double'), hypermat([2,2,2],[1;255;265;274;275;275;275;275]));
+assert_checkequal(cumsum(i,'*','double'), hypermat([2,2,2],[1;255;265;274;275;275;275;275]));
+assert_checkequal(cumsum(i,1,'double'), hypermat([2,2,2],[1;255;10;19;1;1;0;0]));
+assert_checkequal(cumsum(i,2,'double'), hypermat([2,2,2],[1;254;11;263;1;0;1;0]));
+assert_checkequal(cumsum(i,3,'double'), hypermat([2,2,2],[1;254;10;9;2;254;10;9]));
+assert_checkequal(cumsum(i,5,'double'), double(i));
 
 //=======================================================================
 //Matrices of Polynomials
 s=%s;p=[s s+1;s^2 0];
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumsum(p,typ(:))<>[s,1+2*s+s^2;s+s^2,1+2*s+s^2]) then pause,end
-  if or(cumsum(p,'*',typ(:))<>[s,1+2*s+s^2;s+s^2,1+2*s+s^2]) then pause,end
-  if or(cumsum(p,1,typ(:))<>[s,1+s;s+s^2,1+s]) then pause,end
-  if or(cumsum(p,2,typ(:))<>[s,1+2*s;s^2,s^2]) then pause,end
-  if or(cumsum(p,3,typ(:))<>p) then pause,end
+  assert_checkequal(cumsum(p,typ(:)), [s,1+2*s+s^2;s+s^2,1+2*s+s^2]);
+  assert_checkequal(cumsum(p,'*',typ(:)), [s,1+2*s+s^2;s+s^2,1+2*s+s^2]);
+  assert_checkequal(cumsum(p,1,typ(:)), [s,1+s;s+s^2,1+s]);
+  assert_checkequal(cumsum(p,2,typ(:)), [s,1+2*s;s^2,s^2]);
+  assert_checkequal(cumsum(p,3,typ(:)), p);
 end
 
 //with hypermatrices
 s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumsum(p,typ(:))<>hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2])) then pause,end
-  if or(cumsum(p,'*',typ(:))<>hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2])) then pause,end
-  if or(cumsum(p,1,typ(:))<>hypermat([2,2,2],[s;s+s^2;1+s;1+s;-1;-1;0*s;0*s])) then pause,end
-  if or(cumsum(p,2,typ(:))<>hypermat([2,2,2],[s;s^2;1+2*s;s^2;-1;0*s;-1;0*s])) then pause,end
-  if or(cumsum(p,3,typ(:))<>hypermat([2,2,2],[s;s^2;1+s;0*s;-1+s;s^2;1+s;0*s])) then pause,end
-  if or(cumsum(p,5,typ(:))<>p) then pause,end
+  assert_checkequal(cumsum(p,typ(:)), hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2]));
+  assert_checkequal(cumsum(p,'*',typ(:)), hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2]));
+  assert_checkequal(cumsum(p,1,typ(:)), hypermat([2,2,2],[s;s+s^2;1+s;1+s;-1;-1;0*s;0*s]));
+  assert_checkequal(cumsum(p,2,typ(:)), hypermat([2,2,2],[s;s^2;1+2*s;s^2;-1;0*s;-1;0*s]));
+  assert_checkequal(cumsum(p,3,typ(:)), hypermat([2,2,2],[s;s^2;1+s;0*s;-1+s;s^2;1+s;0*s]));
+  assert_checkequal(cumsum(p,5,typ(:)), p);
 end
 
 //=======================================================================
@@ -106,63 +107,63 @@ end
 
 b=[%t %t;%f %t];
 for typ=list(list(),list('double'));
-  if or(cumsum(b,typ(:))<>[1,2;1,3]) then pause,end
-  if or(cumsum(b,'*',typ(:))<>[1,2;1,3]) then pause,end
-  if or(cumsum(b,1,typ(:))<>[1,1;1,2]) then pause,end
-  if or(cumsum(b,2,typ(:))<>[1,2;0,1]) then pause,end
-  if or(cumsum(b,3,typ(:))<>double(b)) then pause,end
+  assert_checkequal(cumsum(b,typ(:)), [1,2;1,3]);
+  assert_checkequal(cumsum(b,'*',typ(:)), [1,2;1,3]);
+  assert_checkequal(cumsum(b,1,typ(:)), [1,1;1,2]);
+  assert_checkequal(cumsum(b,2,typ(:)), [1,2;0,1]);
+  assert_checkequal(cumsum(b,3,typ(:)), double(b));
 end
-if or(cumsum(b,'native')<>[%t %t;%t %t]) then pause,end
-if or(cumsum(b,'*','native')<>[%t %t;%t %t]) then pause,end
-if or(cumsum(b,1,'native')<>[%t %t;%t %t]) then pause,end
-if or(cumsum(b,2,'native')<>[%t %t;%f %t]) then pause,end
-if or(cumsum(b,3,'native')<>b) then pause,end
+assert_checkequal(cumsum(b,'native'), [%t %t;%t %t]);
+assert_checkequal(cumsum(b,'*','native'), [%t %t;%t %t]);
+assert_checkequal(cumsum(b,1,'native'), [%t %t;%t %t]);
+assert_checkequal(cumsum(b,2,'native'), [%t %t;%f %t]);
+assert_checkequal(cumsum(b,3,'native'), b);
 
 //with hypermatrices
 b=[%t %t;%f %t];b(1,1,2)=%f;
 for typ=list(list(),list('double'));
-  if or(cumsum(b,typ(:))<>hypermat([2,2,2],[1;1;2;3;3;3;3;3])) then pause,end
-  if or(cumsum(b,'*',typ(:))<>hypermat([2,2,2],[1;1;2;3;3;3;3;3])) then pause,end
-  if or(cumsum(b,1,typ(:))<>hypermat([2,2,2],[1;1;1;2;0;0;0;0])) then pause,end
-  if or(cumsum(b,2,typ(:))<>hypermat([2,2,2],[1;0;2;1;0;0;0;0])) then pause,end
-  if or(cumsum(b,3,typ(:))<>hypermat([2,2,2],[1;0;1;1;1;0;1;1])) then pause,end
-  if or(cumsum(b,5,typ(:))<>double(b)) then pause,end
+  assert_checkequal(cumsum(b,typ(:)), hypermat([2,2,2],[1;1;2;3;3;3;3;3]));
+  assert_checkequal(cumsum(b,'*',typ(:)), hypermat([2,2,2],[1;1;2;3;3;3;3;3]));
+  assert_checkequal(cumsum(b,1,typ(:)), hypermat([2,2,2],[1;1;1;2;0;0;0;0]));
+  assert_checkequal(cumsum(b,2,typ(:)), hypermat([2,2,2],[1;0;2;1;0;0;0;0]));
+  assert_checkequal(cumsum(b,3,typ(:)), hypermat([2,2,2],[1;0;1;1;1;0;1;1]));
+  assert_checkequal(cumsum(b,5,typ(:)), double(b));
 end
 
-if or(cumsum(b,'native')<>hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t])) then pause,end
-if or(cumsum(b,'*','native')<>hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t])) then pause,end
-if or(cumsum(b,1,'native')<>hypermat([2,2,2],[%t;%t;%t;%t;%f;%f;%f;%f])) then pause,end
-if or(cumsum(b,2,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then pause,end
-if or(cumsum(b,3,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%t;%f;%t;%t])) then pause,end
-if or(cumsum(b,5,'native')<>b) then pause,end
+assert_checkequal(cumsum(b,'native'), hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t]));
+assert_checkequal(cumsum(b,'*','native'), hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t]));
+assert_checkequal(cumsum(b,1,'native'), hypermat([2,2,2],[%t;%t;%t;%t;%f;%f;%f;%f]));
+assert_checkequal(cumsum(b,2,'native'), hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f]));
+assert_checkequal(cumsum(b,3,'native'), hypermat([2,2,2],[%t;%f;%t;%t;%t;%f;%t;%t]));
+assert_checkequal(cumsum(b,5,'native'), b);
 
 //=======================================================================
 //sparse matrices of floats
 s=sparse([0 10 0;0 254 9]);
 T=list(list(),list('native'),list('double'));
 for typ=T
-  if or(cumsum(s,typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3])) then pause,end
-  if or(cumsum(s,'*',typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3])) then pause,end
-  if or(cumsum(s,1,typ(:))<>sparse([1,2;2,2;2,3],[10;264;9],[2,3])) then pause,end
-  if or(cumsum(s,2,typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;10;254;263],[2,3])) then pause,end
-  if or(cumsum(s,3,typ(:))<>s) then pause,end
+  assert_checkequal(cumsum(s,typ(:)), sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3]));
+  assert_checkequal(cumsum(s,'*',typ(:)), sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3]));
+  assert_checkequal(cumsum(s,1,typ(:)), sparse([1,2;2,2;2,3],[10;264;9],[2,3]));
+  assert_checkequal(cumsum(s,2,typ(:)), sparse([1,2;1,3;2,2;2,3],[10;10;254;263],[2,3]));
+  assert_checkequal(cumsum(s,3,typ(:)), s);
 end
 
 //=======================================================================
 //sparse  matrices of boolean
 bs=sparse([0 10 0;0 254 9])<>0;
 for typ=list(list(),list('double'));
-  if or(cumsum(bs,typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3])) then pause,end
-  if or(cumsum(bs,'*',typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3])) then pause,end
-  if or(cumsum(bs,1,typ(:))<>sparse([1,2;2,2;2,3],[1;2;1],[2,3])) then pause,end
-  if or(cumsum(bs,2,typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;1;1;2],[2,3])) then pause,end
-  if or(cumsum(bs,3,typ(:))<>bool2s(bs)) then pause,end
+  assert_checkequal(cumsum(bs,typ(:)), sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3]));
+  assert_checkequal(cumsum(bs,'*',typ(:)), sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3]));
+  assert_checkequal(cumsum(bs,1,typ(:)), sparse([1,2;2,2;2,3],[1;2;1],[2,3]));
+  assert_checkequal(cumsum(bs,2,typ(:)), sparse([1,2;1,3;2,2;2,3],[1;1;1;2],[2,3]));
+  assert_checkequal(cumsum(bs,3,typ(:)), bool2s(bs));
 end
 
-if or(cumsum(bs,'native')<> sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then pause,end
-if or(cumsum(bs,'*','native')<> sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then pause,end
-if or(cumsum(bs,1,'native')<>sparse([1,2;2,2;2,3],[%t;%t;%t],[2,3])) then pause,end
-if or(cumsum(bs,2,'native')<>sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then pause,end
-if or(cumsum(bs,3,'native')<>bs) then pause,end
+assert_checkequal(cumsum(bs,'native'),  sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumsum(bs,'*','native'),  sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumsum(bs,1,'native'), sparse([1,2;2,2;2,3],[%t;%t;%t],[2,3]));
+assert_checkequal(cumsum(bs,2,'native'), sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3]));
+assert_checkequal(cumsum(bs,3,'native'), bs);
 
 // TODO : test the "m" option
index 3534ae4..61978b0 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 //
 // by reference
 [n, d] = rat(%pi);
-if n <> 355 then bugmes();quit;end
-if d <> 113 then bugmes();quit;end
+assert_checkequal(n, 355);
+assert_checkequal(d, 113);
 y = rat(%pi);
-if y <> n/d then bugmes();quit;end
+assert_checkequal(y, n/d);
 [n, d] = rat(%pi, 1.d-12);
-if n <> 1146408 then bugmes();quit;end
-if d <> 364913 then bugmes();quit;end
+assert_checkequal(n, 1146408);
+assert_checkequal(d, 364913);
 // by value
-[n, d] = rat(3.1415927)
- d  =
-    113.  
- n  =
-    355.  
-if n <> 355 then bugmes();quit;end
-if d <> 113 then bugmes();quit;end
+[n, d] = rat(3.1415927);
+assert_checkequal(n, 355);
+assert_checkequal(d, 113);
 y = rat(%pi);
-if y <> n/d then bugmes();quit;end
+assert_checkequal(y, n/d);
 [n, d] = rat(3.1415927, 1.d-12);
-if n <> 1640169 then bugmes();quit;end
-if d <> 522082 then bugmes();quit;end
+assert_checkequal(n, 1640169);
+assert_checkequal(d, 522082);
index 2ab9a64..429ce92 100644 (file)
@@ -1,6 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 //
 // by reference
 [n, d] = rat(%pi);
-if n <> 355 then pause, end
-if d <> 113 then pause, end
+assert_checkequal(n, 355);
+assert_checkequal(d, 113);
 
 y = rat(%pi);
-if y <> n/d then pause, end
+assert_checkequal(y, n/d);
 
 [n, d] = rat(%pi, 1.d-12);
-if n <> 1146408 then pause, end
-if d <> 364913 then pause, end
+assert_checkequal(n, 1146408);
+assert_checkequal(d, 364913);
 
 // by value
-[n, d] = rat(3.1415927)
-if n <> 355 then pause, end
-if d <> 113 then pause, end
+[n, d] = rat(3.1415927);
+assert_checkequal(n, 355);
+assert_checkequal(d, 113);
 
 y = rat(%pi);
-if y <> n/d then pause, end
+assert_checkequal(y, n/d);
 
 [n, d] = rat(3.1415927, 1.d-12);
-if n <> 1640169 then pause, end
-if d <> 522082 then pause, end
+assert_checkequal(n, 1640169);
+assert_checkequal(d, 522082);
 
index bc417be..83b7900 100644 (file)
@@ -1,7 +1,8 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Pierre MARECHAL <pierre.marechal@inria.fr>
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010 - 2011 - DIGITEO - Michael Baudin
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // TODO : complex arithmetic
 // 1. Interface
 // ============
-if execstr("sin()"   ,"errcatch")           == 0 then bugmes();quit;end
-if execstr("sin(1,2)","errcatch")           == 0 then bugmes();quit;end
-if execstr("sin(''my string'')","errcatch") == 0 then bugmes();quit;end
+assert_checkfalse(execstr("sin()"   ,"errcatch") == 0);
+assert_checkfalse(execstr("sin(1,2)","errcatch") == 0);
+assert_checkfalse(execstr("sin(''my string'')","errcatch") == 0);
 // 2. Singular Values
 // ==================
-if ( sin(0) <> 0 ) then bugmes();quit;end
-if ( sin(-0) <> -0 ) then bugmes();quit;end
-// The following tests check cos for a small number of x in the range [0,pi].
-// The variable x contains correctly rounded values of the exact value of x. 
-// The variable v contains correctly rounded values of the exact value of cos 
+assert_checkequal(sin(0), 0);
+assert_checkequal(sin(-0), -0);
+// The following tests check sin for a small number of x in the range [0,pi].
+// The variable x contains correctly rounded values of the exact value of x.
+// The variable v contains correctly rounded values of the exact value of cos
 // on the exact double representing the various values of x.
-// For example, the floating point number which is closest to %pi/2 is 
-// 7074237752028440 * 2^(0-53+1), which can be written with the decimal string 
-// 1.570796326794896558D+00. 
-// We have cos(7074237752028440 * 2^(0-53+1)) = 6.123233995736765886...*10^-17
+// For example, the floating point number which is closest to %pi/2 is
+// 7074237752028440 * 2^-51, which can be written with the decimal string
+// 3.141592653589793116D+00.
+// We have sin(7074237752028440 * 2^-51) = 1.224646799147353177...*10^-16
 // exactly.
-// If Scilab had support for hex, we would have used it. 
+//
+// If Scilab had support for hex, we would have used it.
 // The exact values are computed in Wolfram Alpha.
-// We use more that 17 digits, which, if the decimal to binary conversion is 
-// correct, and if the rounding is round-to-nearest, must exactly produce 
+// We use more that 17 digits, which, if the decimal to binary conversion is
+// correct, and if the rounding is round-to-nearest, must exactly produce
 // values in this table.
+//
 // We avoid using values such as 2*%pi/3, which introduce one multiplication
-// and one addition (the test fail is the multiplication or division 
+// and one addition (the test fail is the multiplication or division
 // is not accurate, while the current test is not sensitive to this, i.e.
-// we test "cos", not "*"). 
+// we test "sin", not "*").
+//
 // Failing this test may be caused by:
 // * a bad decimal to binary conversion,
-// * a wrong implementation of cos.
+// * a wrong implementation of sin.
+//
 x = [
-  5.235987755982988157D-01 // %pi/6 
+  5.235987755982988157D-01 // %pi/6
   7.853981633974482790D-01 // %pi/4
   1.047197551196597631D+00 // %pi/3
   1.570796326794896558D+00 // %pi/2
@@ -50,8 +55,8 @@ x = [
   3.141592653589793116D+00 // %pi
 ];
 v = [
-    4.999999999999999503D-01  
-    7.071067811865475028D-01  
+    4.999999999999999503D-01
+    7.071067811865475028D-01
     8.660254037844385893D-01
     1.000000000000000000D-00
     8.660254037844387616D-01
@@ -61,20 +66,20 @@ v = [
 ];
 S = sin(x);
 rtol = ceil(abs(S-v)./abs(v)/%eps);
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 ulptol = 1;
-if ( or(rtol>ulptol) ) then bugmes();quit;end
+assert_checkfalse(rtol > ulptol);
 //
 // Check symetry on these points
 x = -x;
 S = sin(x);
 v = -v;
 rtol = ceil(abs(S-v)./abs(v)/%eps);
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 ulptol = 1;
-if ( or(rtol>ulptol) ) then bugmes();quit;end
+assert_checkfalse(rtol > ulptol);
 //
 // sin(x) == x for |x| < 1.422...*2^-26
 // Reference:
@@ -85,49 +90,49 @@ if ( or(rtol>ulptol) ) then bugmes();quit;end
 //
 // Check positive and negative normal numbers.
 x = [2^(-1022:-26) -2^(-1022:-26)];
-// Check that the values are close to 1.
-// Our tolerance is : get the exact floating point number, 
+// Check that the values are close to x.
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 S = sin(x);
 rtol = ceil(abs(S-x)/%eps);
 ulptol = 1;
-if ( or(rtol>ulptol) ) then bugmes();quit;end
+assert_checkfalse(rtol > ulptol);
 // Check that the values are lower or equal to 1.
 // No matter how bad our library is, we must have abs(sin(x))<= 1.
 // If this test fails, the math library is to be absolutely rejected.
-if ( or(abs(S)>1) ) then bugmes();quit;end
-// Compute the number of floats for which sin(x)<>1.
+assert_checkfalse(abs(S) > 1);
+// Compute the number of floats for which sin(x)<>x.
 // An excellent library should produce s=0.
 // This failure happens for x=2^n and n usually close to -27.
 notexact = sum(S<>x);
 rtol = 30;
-if ( notexact>rtol ) then bugmes();quit;end
+assert_checkfalse(notexact > rtol);
 // Check that abs(sin(x))<= 1, for large large normal floating point numbers of x.
 // If this test fails, the math library is to be absolutely rejected.
 x = [2^(0:1023) -2^(0:1023)];
 S = sin(x);
-if ( or(abs(S)>1) ) then bugmes();quit;end
+assert_checkfalse(abs(S) > 1);
 // 3. Not A Number
 // ===============
-if ~isnan(sin(%nan)) then bugmes();quit;end
-if ~isnan(sin(-%nan)) then bugmes();quit;end
+assert_checktrue(isnan(sin(%nan)));
+assert_checktrue(isnan(sin(-%nan)));
 // 4. Limit values
 // ===============
-if ~isnan(real(sin(%inf)))    then bugmes();quit;end
-if imag(sin(%inf)) <> 0       then bugmes();quit;end
-if ~isnan(real(sin(-%inf)))   then bugmes();quit;end
-if imag(sin(-%inf)) <> 0      then bugmes();quit;end
+assert_checktrue(isnan(real(sin(%inf))));
+assert_checkequal(imag(sin(%inf)), 0);
+assert_checktrue(isnan(real(sin(-%inf))));
+assert_checkequal(imag(sin(-%inf)), 0);
 // 5. Properties
 // =============
 // The ratio between the absolute tolerance and %eps.
 atolratio = 5;
-// All the tests below are based on equalities of the form C=0, 
+// All the tests below are based on equalities of the form C=0,
 // with C = f(A,B) and A, B matrices.
-// We consider the elementwise absolute error abs(C), and 
+// We consider the elementwise absolute error abs(C), and
 // focus on the maximum of this error, that is, we compute max(abs(C)).
-// This absolute error is compared to atolratio * %eps, but it is 
+// This absolute error is compared to atolratio * %eps, but it is
 // expressed as max(abs(C))/%eps.
-// Indeed, if this test fail, we first compute max(abs(C))/%eps, see 
+// Indeed, if this test fail, we first compute max(abs(C))/%eps, see
 // its value (e.g. 0.9, 1.2 or 2.3) and set the tolerance to the minimum
 // integer larger than this.
 rand("seed",0);
@@ -135,45 +140,45 @@ A = rand(100,100);
 B = rand(100,100);
 // sin(-x) = - sin(x)
 C = sin(-A) + sin(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // sin(%pi - x) = sin(x)
 C = sin(%pi - A) - sin(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // sin(%pi + x) = - sin(x)
 C = sin(%pi + A) + sin(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
-// cos(2a) = 2 cos^2(a) - 1 
+assert_checkfalse(max(abs(C))/%eps > atolratio);
+// cos(2a) = 2 cos^2(a) - 1
 C = cos(2*A) - 2 * (cos(A)).^2 + 1;
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 //
 // At this point, we do not test the accuracy of sin anymore:
 // we test the matching between cos and sin.
 // Thus, these tests may be put into cos.tst or sin.tst
-// 
+//
 // sin(%pi/2 - x) = cos(x)
 C = sin(%pi/2 - A) - cos(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // sin(%pi/2 + x) = cos(x)
 C = sin(%pi/2 + A) - cos(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // cos^2(a) + sin^2(a) = 1
 C = (cos(A)).^2 + (sin(A)).^2 - 1;
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // cos(a + b) = cos(a) cos(b) - sin(a) sin(b)
 C = cos(A + B) - cos(A).*cos(B) + sin(A).*sin(B);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // cos(a -b) = cos(a) cos(b) + sin(a) sin(b)
 C = cos(A - B) - cos(A).*cos(B) - sin(A).*sin(B);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // sin(a + b) = sin(a) cos(b) + sin(b) cos(a)
 C = sin(A + B) - sin(A).*cos(B) - sin(B).*cos(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // sin(a -b) = sin(a) cos(b) - sin(b) cos(a)
 C = sin(A - B) - sin(A).*cos(B) + sin(B).*cos(A);
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
-// cos(2a) = cos^2(a) - sin^2(a) 
+assert_checkfalse(max(abs(C))/%eps > atolratio);
+// cos(2a) = cos^2(a) - sin^2(a)
 C = cos(2*A) - (cos(A)).^2 + (sin(A)).^2;
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 // cos(2a) = 1 - 2 sin^2(a)
 C = cos(2*A) - 1 + 2 * (sin(A)).^2;
-if ( max(abs(C))/%eps > atolratio) then bugmes();quit;end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
index c724803..eb31df8 100644 (file)
@@ -2,6 +2,7 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Pierre MARECHAL <pierre.marechal@inria.fr>
 // Copyright (C) 2010 - 2011 - DIGITEO - Michael Baudin
+// Copyright (C) 2012 - Scilab Enterprises - Cedric Delamarre
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // 1. Interface
 // ============
 
-if execstr("sin()"   ,"errcatch")           == 0 then pause, end
-if execstr("sin(1,2)","errcatch")           == 0 then pause, end
-if execstr("sin(''my string'')","errcatch") == 0 then pause, end
+assert_checkfalse(execstr("sin()"   ,"errcatch") == 0);
+assert_checkfalse(execstr("sin(1,2)","errcatch") == 0);
+assert_checkfalse(execstr("sin(''my string'')","errcatch") == 0);
 
 // 2. Singular Values
 // ==================
 
-if ( sin(0) <> 0 ) then pause, end
-if ( sin(-0) <> -0 ) then pause, end
+assert_checkequal(sin(0), 0);
+assert_checkequal(sin(-0), -0);
 
 
 // The following tests check sin for a small number of x in the range [0,pi].
-// The variable x contains correctly rounded values of the exact value of x. 
-// The variable v contains correctly rounded values of the exact value of cos 
+// The variable x contains correctly rounded values of the exact value of x.
+// The variable v contains correctly rounded values of the exact value of cos
 // on the exact double representing the various values of x.
-// For example, the floating point number which is closest to %pi/2 is 
-// 7074237752028440 * 2^-51, which can be written with the decimal string 
-// 3.141592653589793116D+00. 
+// For example, the floating point number which is closest to %pi/2 is
+// 7074237752028440 * 2^-51, which can be written with the decimal string
+// 3.141592653589793116D+00.
 // We have sin(7074237752028440 * 2^-51) = 1.224646799147353177...*10^-16
 // exactly.
 //
-// If Scilab had support for hex, we would have used it. 
+// If Scilab had support for hex, we would have used it.
 // The exact values are computed in Wolfram Alpha.
-// We use more that 17 digits, which, if the decimal to binary conversion is 
-// correct, and if the rounding is round-to-nearest, must exactly produce 
+// We use more that 17 digits, which, if the decimal to binary conversion is
+// correct, and if the rounding is round-to-nearest, must exactly produce
 // values in this table.
 //
 // We avoid using values such as 2*%pi/3, which introduce one multiplication
-// and one addition (the test fail is the multiplication or division 
+// and one addition (the test fail is the multiplication or division
 // is not accurate, while the current test is not sensitive to this, i.e.
-// we test "sin", not "*"). 
+// we test "sin", not "*").
 //
 // Failing this test may be caused by:
 // * a bad decimal to binary conversion,
 // * a wrong implementation of sin.
 //
 x = [
-  5.235987755982988157D-01 // %pi/6 
+  5.235987755982988157D-01 // %pi/6
   7.853981633974482790D-01 // %pi/4
   1.047197551196597631D+00 // %pi/3
   1.570796326794896558D+00 // %pi/2
@@ -64,8 +65,8 @@ x = [
   3.141592653589793116D+00 // %pi
 ];
 v = [
-    4.999999999999999503D-01  
-    7.071067811865475028D-01  
+    4.999999999999999503D-01
+    7.071067811865475028D-01
     8.660254037844385893D-01
     1.000000000000000000D-00
     8.660254037844387616D-01
@@ -76,20 +77,20 @@ v = [
 
 S = sin(x);
 rtol = ceil(abs(S-v)./abs(v)/%eps);
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 ulptol = 1;
-if ( or(rtol>ulptol) ) then pause, end
+assert_checkfalse(rtol > ulptol);
 //
 // Check symetry on these points
 x = -x;
 S = sin(x);
 v = -v;
 rtol = ceil(abs(S-v)./abs(v)/%eps);
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 ulptol = 1;
-if ( or(rtol>ulptol) ) then pause, end
+assert_checkfalse(rtol > ulptol);
 
 //
 // sin(x) == x for |x| < 1.422...*2^-26
@@ -102,45 +103,45 @@ if ( or(rtol>ulptol) ) then pause, end
 // Check positive and negative normal numbers.
 x = [2^(-1022:-26) -2^(-1022:-26)];
 // Check that the values are close to x.
-// Our tolerance is : get the exact floating point number, 
+// Our tolerance is : get the exact floating point number,
 // or its neighbour.
 S = sin(x);
 rtol = ceil(abs(S-x)/%eps);
 ulptol = 1;
-if ( or(rtol>ulptol) ) then pause, end
+assert_checkfalse(rtol > ulptol);
 // Check that the values are lower or equal to 1.
 // No matter how bad our library is, we must have abs(sin(x))<= 1.
 // If this test fails, the math library is to be absolutely rejected.
-if ( or(abs(S)>1) ) then pause, end
+assert_checkfalse(abs(S) > 1);
 // Compute the number of floats for which sin(x)<>x.
 // An excellent library should produce s=0.
 // This failure happens for x=2^n and n usually close to -27.
 notexact = sum(S<>x);
 rtol = 30;
-if ( notexact>rtol ) then pause, end
+assert_checkfalse(notexact > rtol);
 
 // Check that abs(sin(x))<= 1, for large large normal floating point numbers of x.
 // If this test fails, the math library is to be absolutely rejected.
 x = [2^(0:1023) -2^(0:1023)];
 S = sin(x);
-if ( or(abs(S)>1) ) then pause, end
+assert_checkfalse(abs(S) > 1);
 
 
 // 3. Not A Number
 // ===============
 
-if ~isnan(sin(%nan)) then pause, end
-if ~isnan(sin(-%nan)) then pause, end
+assert_checktrue(isnan(sin(%nan)));
+assert_checktrue(isnan(sin(-%nan)));
 
 
 // 4. Limit values
 // ===============
 
-if ~isnan(real(sin(%inf)))    then pause, end
-if imag(sin(%inf)) <> 0       then pause, end
+assert_checktrue(isnan(real(sin(%inf))));
+assert_checkequal(imag(sin(%inf)), 0);
 
-if ~isnan(real(sin(-%inf)))   then pause, end
-if imag(sin(-%inf)) <> 0      then pause, end
+assert_checktrue(isnan(real(sin(-%inf))));
+assert_checkequal(imag(sin(-%inf)), 0);
 
 
 // 5. Properties
@@ -149,13 +150,13 @@ if imag(sin(-%inf)) <> 0      then pause, end
 // The ratio between the absolute tolerance and %eps.
 atolratio = 5;
 
-// All the tests below are based on equalities of the form C=0, 
+// All the tests below are based on equalities of the form C=0,
 // with C = f(A,B) and A, B matrices.
-// We consider the elementwise absolute error abs(C), and 
+// We consider the elementwise absolute error abs(C), and
 // focus on the maximum of this error, that is, we compute max(abs(C)).
-// This absolute error is compared to atolratio * %eps, but it is 
+// This absolute error is compared to atolratio * %eps, but it is
 // expressed as max(abs(C))/%eps.
-// Indeed, if this test fail, we first compute max(abs(C))/%eps, see 
+// Indeed, if this test fail, we first compute max(abs(C))/%eps, see
 // its value (e.g. 0.9, 1.2 or 2.3) and set the tolerance to the minimum
 // integer larger than this.
 
@@ -165,59 +166,58 @@ B = rand(100,100);
 
 // sin(-x) = - sin(x)
 C = sin(-A) + sin(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // sin(%pi - x) = sin(x)
 C = sin(%pi - A) - sin(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // sin(%pi + x) = - sin(x)
 C = sin(%pi + A) + sin(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
-// cos(2a) = 2 cos^2(a) - 1 
+// cos(2a) = 2 cos^2(a) - 1
 C = cos(2*A) - 2 * (cos(A)).^2 + 1;
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 //
 // At this point, we do not test the accuracy of sin anymore:
 // we test the matching between cos and sin.
 // Thus, these tests may be put into cos.tst or sin.tst
-// 
+//
 
 // sin(%pi/2 - x) = cos(x)
 C = sin(%pi/2 - A) - cos(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // sin(%pi/2 + x) = cos(x)
 C = sin(%pi/2 + A) - cos(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // cos^2(a) + sin^2(a) = 1
 C = (cos(A)).^2 + (sin(A)).^2 - 1;
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // cos(a + b) = cos(a) cos(b) - sin(a) sin(b)
 C = cos(A + B) - cos(A).*cos(B) + sin(A).*sin(B);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // cos(a -b) = cos(a) cos(b) + sin(a) sin(b)
 C = cos(A - B) - cos(A).*cos(B) - sin(A).*sin(B);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // sin(a + b) = sin(a) cos(b) + sin(b) cos(a)
 C = sin(A + B) - sin(A).*cos(B) - sin(B).*cos(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // sin(a -b) = sin(a) cos(b) - sin(b) cos(a)
 C = sin(A - B) - sin(A).*cos(B) + sin(B).*cos(A);
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
-// cos(2a) = cos^2(a) - sin^2(a) 
+// cos(2a) = cos^2(a) - sin^2(a)
 C = cos(2*A) - (cos(A)).^2 + (sin(A)).^2;
-if ( max(abs(C))/%eps > atolratio) then pause, end
+assert_checkfalse(max(abs(C))/%eps > atolratio);
 
 // cos(2a) = 1 - 2 sin^2(a)
 C = cos(2*A) - 1 + 2 * (sin(A)).^2;
-if ( max(abs(C))/%eps > atolratio) then pause, end
-
+assert_checkfalse(max(abs(C))/%eps > atolratio);