Scilab: fix for tests, added the tolerance.

Change-Id: I7489923702756795423335557667aa9f43fffcf0

diff --git a/scilab/modules/elementary_functions/tests/unit_tests/sinc.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/sinc.dia.ref
index 29cc0d0..659e55c 100644 (file)
--- a/scilab/modules/elementary_functions/tests/unit_tests/sinc.dia.ref
+++ b/scilab/modules/elementary_functions/tests/unit_tests/sinc.dia.ref
@@ -14,14 +14,14 @@ assert_checktrue(isnan(sinc(%inf))==%t);
 assert_checktrue(isnan(sinc(%nan))==%t);
 // Vector
 x=linspace(1,%pi,100);
-assert_checkequal(sinc(x),sin(x)./x);
-assert_checkequal(sinc(-x),sinc(x));
+assert_checkalmostequal(sinc(x),sin(x)./x, [], 1e-12);
+assert_checkalmostequal(sinc(-x),sinc(x), [], 1e-12);
 // Hypermat
 x2=rand(2,2,2,2);
-assert_checkequal(sinc(x2),sin(x2)./x2);
+assert_checkalmostequal(sinc(x2),sin(x2)./x2, [], 1e-12);
 // Sparse
 x2=sparse(x);
-assert_checkequal(sinc(x2),sin(x2)./x2);
+assert_checkalmostequal(sinc(x2),sin(x2)./x2, [], 1e-12);
 // Error messages
 error_msg = msprintf(gettext("Wrong number of input arguments."));
 assert_checkerror("sinc(1,2,3)",error_msg,58);
@@ -33,6 +33,6 @@ assert_checkerror("sinc(list(1,2,3))",error_msg);
 assert_checkerror("sinc(abs)",error_msg);
 assert_checkerror("sinc(poly(0,''s''))",error_msg);
 A=[0,1;0,0];B=[1;1];C=[1,1];
-S1=syslin('c',A,B,C);
+S1=syslin("c",A,B,C);
 assert_checkerror("sinc(S1)",error_msg);
 assert_checkerror("sinc(ss2tf(S1))",error_msg);

diff --git a/scilab/modules/elementary_functions/tests/unit_tests/sinc.tst b/scilab/modules/elementary_functions/tests/unit_tests/sinc.tst
index 8dcb3d6..e905ce7 100644 (file)
--- a/scilab/modules/elementary_functions/tests/unit_tests/sinc.tst
+++ b/scilab/modules/elementary_functions/tests/unit_tests/sinc.tst
@@ -17,14 +17,14 @@ assert_checktrue(isnan(sinc(%inf))==%t);
 assert_checktrue(isnan(sinc(%nan))==%t);
 // Vector
 x=linspace(1,%pi,100);
-assert_checkequal(sinc(x),sin(x)./x);
-assert_checkequal(sinc(-x),sinc(x));
+assert_checkalmostequal(sinc(x),sin(x)./x, [], 1e-12);
+assert_checkalmostequal(sinc(-x),sinc(x), [], 1e-12);
 // Hypermat
 x2=rand(2,2,2,2);
-assert_checkequal(sinc(x2),sin(x2)./x2);
+assert_checkalmostequal(sinc(x2),sin(x2)./x2, [], 1e-12);
 // Sparse
 x2=sparse(x);
-assert_checkequal(sinc(x2),sin(x2)./x2);
+assert_checkalmostequal(sinc(x2),sin(x2)./x2, [], 1e-12);
 
 // Error messages
 error_msg = msprintf(gettext("Wrong number of input arguments."));
@@ -37,6 +37,6 @@ assert_checkerror("sinc(list(1,2,3))",error_msg);
 assert_checkerror("sinc(abs)",error_msg);
 assert_checkerror("sinc(poly(0,''s''))",error_msg);
 A=[0,1;0,0];B=[1;1];C=[1,1];
-S1=syslin('c',A,B,C);
+S1=syslin("c",A,B,C);
 assert_checkerror("sinc(S1)",error_msg);
 assert_checkerror("sinc(ss2tf(S1))",error_msg);

diff --git a/scilab/modules/elementary_functions/tests/unit_tests/unwrap.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/unwrap.dia.ref
index 2fa5345..72cc289 100644 (file)
--- a/scilab/modules/elementary_functions/tests/unit_tests/unwrap.dia.ref
+++ b/scilab/modules/elementary_functions/tests/unit_tests/unwrap.dia.ref
@@ -12,29 +12,29 @@ Y = t.^2 + t -1;
 Yw = atan(tan(Y));  // Raw wrapped recovered Y [pi]
 Yunw = unwrap(Yw, %pi);
 assert_checkequal(size(Yunw), size(Y));
-assert_checkequal(max(Yunw), 8.273629385640850486539);
-assert_checkequal(min(Yunw), -13.816370473381940797708);
+assert_checkalmostequal(max(Yunw), 8.273629385640850486539, [], 1e-12);
+assert_checkalmostequal(min(Yunw), -13.816370473381940797708, [], 1e-12);
 // Example #2 (1D wrapped)
 rand("seed", 0);
 c = (rand(1, 1)-0.5)*4;
 Yw = pmodulo(Y, 5) + c;  // unwrap() is unsensitive to a constant and even to a trend
 [Yunw, K] = unwrap(Yw, 0);
 assert_checkequal(size(Yunw), size(Y));
-assert_checkequal(max(Yunw), 9.6852994618564913764658);
-assert_checkequal(min(Yunw), -12.404700397166287473283);
+assert_checkalmostequal(max(Yunw), 9.6852994618564913764658, [], 1e-12);
+assert_checkalmostequal(min(Yunw), -12.404700397166287473283, [], 1e-12);
 assert_checkequal(K, [15 98 233 450 585 668 734 791]);
 // Example #3 (1D folded)
 Yf = 1 + asin(sin(Y));  // Raw folded recovered Y [2.pi], + constant Y shift
 Yunf = unwrap(Yf, "unfold");
 assert_checkequal(size(Yunf), size(Y));
-assert_checkalmostequal(max(Yunf), 9.4279967527199310950436, [], 1e-14);
-assert_checkalmostequal(min(Yunf), -12.436144421661456505035, [], 1e-14);
+assert_checkalmostequal(max(Yunf), 9.4279967527199310950436, [], 1e-12);
+assert_checkalmostequal(min(Yunf), -12.436144421661456505035, [], 1e-12);
 // Example #4 (1D folded)
 Yf = 1 + Y/10 + acos(cos(Y)); // Raw recovered Y [2.pi], + linear trend
 [Yunf, K] = unwrap(Yf, "unfold");
 assert_checkequal(size(Yunf), size(Y));
-assert_checkalmostequal(max(Yunf), 15.801371238872524926933, [], 1e-14);
-assert_checkalmostequal(min(Yunf), -6.1759877188984493301405, [], 1e-14);
+assert_checkalmostequal(max(Yunf), 15.801371238872524926933, [], 1e-12);
+assert_checkalmostequal(min(Yunf), -6.1759877188984493301405, [], 1e-12);
 assert_checkequal(K, [24 75 138 233 451 546 609 660 704 743 779]);
 //Unwrapping 2D surfaces:
 nx = 300;
@@ -49,29 +49,29 @@ m = 2.8;
 Zw = pmodulo(Z, m);     // >raps it
 Zunw  = unwrap(Zw, 0);  // Unwraps it in both directions, with free jumps
 assert_checkequal(size(Zunw), size(Z));
-assert_checkequal(max(Zunw), 19.120000000000032969183);
-assert_checkequal(min(Zunw), -39.199790375290433531);
+assert_checkalmostequal(max(Zunw), 19.120000000000032969183, [], 1e-12);
+assert_checkalmostequal(min(Zunw), -39.199790375290433531, [], 1e-12);
 ZunwR = unwrap(Zw, 0, "r"); // Unwraps it along rows
 assert_checkequal(size(ZunwR), size(Z));
-assert_checkequal(max(ZunwR), 2.78738299382542109583);
-assert_checkequal(min(ZunwR), -28.995103166214036605197);
+assert_checkalmostequal(max(ZunwR), 2.78738299382542109583, [], 1e-12);
+assert_checkalmostequal(min(ZunwR), -28.995103166214036605197, [], 1e-12);
 ZunwC = unwrap(Zw, 0, "c"); // Unwraps it along columns
 assert_checkequal(size(ZunwC), size(Z));
-assert_checkequal(max(ZunwC), 20.398076084160148724322);
-assert_checkequal(min(ZunwC), -11.462196183827872530969);
+assert_checkalmostequal(max(ZunwC), 20.398076084160148724322, [], 1e-12);
+assert_checkalmostequal(min(ZunwC), -11.462196183827872530969, [], 1e-12);
 // Example #6 : 2D wrapped
 Z = sqrt(0.3+sinc(sqrt(Z)*3))*17-7; // Defines the surface
 m = 2.8;                     // Wrapping step (jump's amplitude)
 Zw = pmodulo(Z, m);          // Wraps it
 Zunw  = unwrap(Zw, m);       // Unwraps it in both directions, with given jump
 assert_checkequal(size(Zunw), size(Z));
-assert_checkequal(max(Zunw), 12.380638179897072603808);
-assert_checkequal(min(Zunw), -2.109245308884592162713);
+assert_checkalmostequal(max(Zunw), 12.380638179897072603808, [], 1e-12);
+assert_checkalmostequal(min(Zunw), -2.109245308884592162713, [], 1e-12);
 ZunwR = unwrap(Zw, m, "r"); // Unwraps it along rows
 assert_checkequal(size(ZunwR), size(Z));
-assert_checkequal(max(ZunwR), 12.380638179897072603808);
-assert_checkequal(min(ZunwR), -2.109245308884592162713);
+assert_checkalmostequal(max(ZunwR), 12.380638179897072603808, [], 1e-12);
+assert_checkalmostequal(min(ZunwR), -2.109245308884592162713, [], 1e-12);
 ZunwC = unwrap(Zw, m, "c"); // Unwraps it along columns
 assert_checkequal(size(ZunwC), size(Z));
-assert_checkequal(max(ZunwC), 12.380638179897072603808);
-assert_checkequal(min(ZunwC), -2.1092453088845903863557);
+assert_checkalmostequal(max(ZunwC), 12.380638179897072603808, [], 1e-12);
+assert_checkalmostequal(min(ZunwC), -2.1092453088845903863557, [], 1e-12);

diff --git a/scilab/modules/elementary_functions/tests/unit_tests/unwrap.tst b/scilab/modules/elementary_functions/tests/unit_tests/unwrap.tst
index ee800e8..7391fe9 100644 (file)
--- a/scilab/modules/elementary_functions/tests/unit_tests/unwrap.tst
+++ b/scilab/modules/elementary_functions/tests/unit_tests/unwrap.tst
@@ -13,8 +13,8 @@ Y = t.^2 + t -1;
 Yw = atan(tan(Y));  // Raw wrapped recovered Y [pi]
 Yunw = unwrap(Yw, %pi);
 assert_checkequal(size(Yunw), size(Y));
-assert_checkequal(max(Yunw), 8.273629385640850486539);
-assert_checkequal(min(Yunw), -13.816370473381940797708);
+assert_checkalmostequal(max(Yunw), 8.273629385640850486539, [], 1e-12);
+assert_checkalmostequal(min(Yunw), -13.816370473381940797708, [], 1e-12);
 
 // Example #2 (1D wrapped)
 rand("seed", 0);
@@ -22,23 +22,23 @@ c = (rand(1, 1)-0.5)*4;
 Yw = pmodulo(Y, 5) + c;  // unwrap() is unsensitive to a constant and even to a trend
 [Yunw, K] = unwrap(Yw, 0);
 assert_checkequal(size(Yunw), size(Y));
-assert_checkequal(max(Yunw), 9.6852994618564913764658);
-assert_checkequal(min(Yunw), -12.404700397166287473283);
+assert_checkalmostequal(max(Yunw), 9.6852994618564913764658, [], 1e-12);
+assert_checkalmostequal(min(Yunw), -12.404700397166287473283, [], 1e-12);
 assert_checkequal(K, [15 98 233 450 585 668 734 791]);
 
 // Example #3 (1D folded)
 Yf = 1 + asin(sin(Y));  // Raw folded recovered Y [2.pi], + constant Y shift
 Yunf = unwrap(Yf, "unfold");
 assert_checkequal(size(Yunf), size(Y));
-assert_checkalmostequal(max(Yunf), 9.4279967527199310950436, [], 1e-14);
-assert_checkalmostequal(min(Yunf), -12.436144421661456505035, [], 1e-14);
+assert_checkalmostequal(max(Yunf), 9.4279967527199310950436, [], 1e-12);
+assert_checkalmostequal(min(Yunf), -12.436144421661456505035, [], 1e-12);
 
 // Example #4 (1D folded)
 Yf = 1 + Y/10 + acos(cos(Y)); // Raw recovered Y [2.pi], + linear trend
 [Yunf, K] = unwrap(Yf, "unfold");
 assert_checkequal(size(Yunf), size(Y));
-assert_checkalmostequal(max(Yunf), 15.801371238872524926933, [], 1e-14);
-assert_checkalmostequal(min(Yunf), -6.1759877188984493301405, [], 1e-14);
+assert_checkalmostequal(max(Yunf), 15.801371238872524926933, [], 1e-12);
+assert_checkalmostequal(min(Yunf), -6.1759877188984493301405, [], 1e-12);
 assert_checkequal(K, [24 75 138 233 451 546 609 660 704 743 779]);
 
 //Unwrapping 2D surfaces:
@@ -55,16 +55,16 @@ m = 2.8;
 Zw = pmodulo(Z, m);     // >raps it
 Zunw  = unwrap(Zw, 0);  // Unwraps it in both directions, with free jumps
 assert_checkequal(size(Zunw), size(Z));
-assert_checkequal(max(Zunw), 19.120000000000032969183);
-assert_checkequal(min(Zunw), -39.199790375290433531);
+assert_checkalmostequal(max(Zunw), 19.120000000000032969183, [], 1e-12);
+assert_checkalmostequal(min(Zunw), -39.199790375290433531, [], 1e-12);
 ZunwR = unwrap(Zw, 0, "r"); // Unwraps it along rows
 assert_checkequal(size(ZunwR), size(Z));
-assert_checkequal(max(ZunwR), 2.78738299382542109583);
-assert_checkequal(min(ZunwR), -28.995103166214036605197);
+assert_checkalmostequal(max(ZunwR), 2.78738299382542109583, [], 1e-12);
+assert_checkalmostequal(min(ZunwR), -28.995103166214036605197, [], 1e-12);
 ZunwC = unwrap(Zw, 0, "c"); // Unwraps it along columns
 assert_checkequal(size(ZunwC), size(Z));
-assert_checkequal(max(ZunwC), 20.398076084160148724322);
-assert_checkequal(min(ZunwC), -11.462196183827872530969);
+assert_checkalmostequal(max(ZunwC), 20.398076084160148724322, [], 1e-12);
+assert_checkalmostequal(min(ZunwC), -11.462196183827872530969, [], 1e-12);
 
 // Example #6 : 2D wrapped
 Z = sqrt(0.3+sinc(sqrt(Z)*3))*17-7; // Defines the surface
@@ -72,13 +72,13 @@ m = 2.8;                     // Wrapping step (jump's amplitude)
 Zw = pmodulo(Z, m);          // Wraps it
 Zunw  = unwrap(Zw, m);       // Unwraps it in both directions, with given jump
 assert_checkequal(size(Zunw), size(Z));
-assert_checkequal(max(Zunw), 12.380638179897072603808);
-assert_checkequal(min(Zunw), -2.109245308884592162713);
+assert_checkalmostequal(max(Zunw), 12.380638179897072603808, [], 1e-12);
+assert_checkalmostequal(min(Zunw), -2.109245308884592162713, [], 1e-12);
 ZunwR = unwrap(Zw, m, "r"); // Unwraps it along rows
 assert_checkequal(size(ZunwR), size(Z));
-assert_checkequal(max(ZunwR), 12.380638179897072603808);
-assert_checkequal(min(ZunwR), -2.109245308884592162713);
+assert_checkalmostequal(max(ZunwR), 12.380638179897072603808, [], 1e-12);
+assert_checkalmostequal(min(ZunwR), -2.109245308884592162713, [], 1e-12);
 ZunwC = unwrap(Zw, m, "c"); // Unwraps it along columns
 assert_checkequal(size(ZunwC), size(Z));
-assert_checkequal(max(ZunwC), 12.380638179897072603808);
-assert_checkequal(min(ZunwC), -2.1092453088845903863557);
+assert_checkalmostequal(max(ZunwC), 12.380638179897072603808, [], 1e-12);
+assert_checkalmostequal(min(ZunwC), -2.1092453088845903863557, [], 1e-12);