* Bug 15028 fixed: assert_checkalmostequal() did not accept polynomials 76/19476/3
Samuel GOUGEON [Tue, 10 Oct 2017 01:51:12 +0000 (03:51 +0200)]
  http://bugzilla.scilab.org/15028

Change-Id: Id09016f27be00788a962a811e0f2f8fd238a1dd8

scilab/CHANGES.md
scilab/modules/development_tools/help/en_US/assert/assert_checkalmostequal.xml
scilab/modules/development_tools/help/ja_JP/assert/assert_checkalmostequal.xml
scilab/modules/development_tools/macros/assert/assert_checkalmostequal.sci
scilab/modules/development_tools/tests/unit_tests/assert/checkalmostequal.dia.ref [deleted file]
scilab/modules/development_tools/tests/unit_tests/assert/checkalmostequal.tst

index c4e40b9..7542157 100644 (file)
@@ -181,6 +181,7 @@ input and output arguments.
 * `ode`: `y0` is restricted to a column vector.
 * `pppdiv`: Returns a scalar of type 'constant' when the rank is 0.
 * `pdiv`: Returns a matrix of type 'constant' when all the rank are 0.
+* `assert_checkalmostequal` can now work with polynomials.
 * `test_run` can now take `[]` as argument to be used on console; for instance: `test_run string [] no_check_ref`.
 * `typeof(:)` and `typeof(n:$)` now return `"implicitlist"` instead of respectively `"constant"` and `"size implicit"`.
 * `linspace(a, b, n<=0)` now returns `[]` instead of b.
@@ -460,6 +461,7 @@ the [development mailing list](dev@lists.scilab.org) for a particular toolbox.
 * [#15019](http://bugzilla.scilab.org/show_bug.cgi?id=15019): Add 'csci6' in the calling of ilib_build in 'Getting started with API_Scilab' help page.
 * [#15023](http://bugzilla.scilab.org/show_bug.cgi?id=15023): `clf()` wrongly reset `figure_id`.
 * [#15024](http://bugzilla.scilab.org/show_bug.cgi?id=15024): Xcos labels were not preserved at diagram compilation.
+* [#15028](http://bugzilla.scilab.org/show_bug.cgi?id=15028): `assert_checkalmostequal` could not work with polynomials.
 * [#15034](http://bugzilla.scilab.org/show_bug.cgi?id=15034): It was no longer possible to create a structure through a mlist.
 * [#15037](http://bugzilla.scilab.org/show_bug.cgi?id=15037): the `residu` function might crash Scilab.
 * [#15039](http://bugzilla.scilab.org/show_bug.cgi?id=15039): New Xcos graphical features needed some demos.
index d1309a3..a25ad87 100644 (file)
  * along with this program.
  *
  -->
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns3="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="assert_checkalmostequal" xml:lang="en">
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
+          xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns3="http://www.w3.org/1999/xhtml"
+          xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook"
+          xmlns:scilab="http://www.scilab.org" xml:id="assert_checkalmostequal" xml:lang="en">
     <refnamediv>
         <refname>assert_checkalmostequal</refname>
         <refpurpose>Check that computed and expected are numerically close.</refpurpose>
             <varlistentry>
                 <term>computed:</term>
                 <listitem>
-                    <para> a matrix of doubles, a sparse matrix of doubles, or an hypermatrix of doubles, the computed result</para>
+                    <para>
+                      matrix or hypermatrix or sparse matrix of decimal real or complex numbers;
+                      or matrix or hypermatrix of polynomials with real or complex coefficients:
+                      the computed result.
+                    </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>expected :</term>
                 <listitem>
-                    <para> a matrix of doubles, a sparse matrix of doubles, or an hypermatrix of doubles, the expected result</para>
+                    <para>
+                      matrix or hypermatrix or sparse matrix of decimal real or complex numbers;
+                      or matrix or hypermatrix of polynomials with real or complex coefficients:
+                      the expected result.
+                    </para>
+                  <para>
+                    If <literal>computed</literal> are polynomials, <literal>expected</literal>
+                    must be polynomials as well.
+                  </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>reltol :</term>
                 <listitem>
-                    <para> a 1-by-1 matrix of doubles, the relative tolerance (default reltol=sqrt(%eps)).</para>
+                    <para>real number: the relative tolerance (default reltol=sqrt(%eps)).</para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>abstol :</term>
                 <listitem>
-                    <para> a 1-by-1 matrix of doubles, the absolute tolerance (default abstol=0).</para>
+                    <para>real number: the absolute tolerance (default abstol=0).</para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>comptype :</term>
                 <listitem>
-                    <para> a 1-by-1 matrix of strings, "matrix" or "element" (default comptype="element"). The comparison type.</para>
+                  <para>keyword <literal>"matrix"</literal> or <literal>"element"</literal>
+                    (default <literal>"element"</literal>). The comparison type.</para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>flag :</term>
                 <listitem>
-                    <para> a 1-by-1 matrix of boolean, %t if computed is close to expected, %f if not</para>
+                  <para>
+                    <literal>%t</literal> if computed is close to expected; else <literal>%f</literal>.
+                  </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>errmsg :</term>
                 <listitem>
-                    <para> a 1-by-1 matrix of strings, the error message. If flag==%t, then errormsg=="". If flag==%f, then errmsg contains the error message.</para>
+                    <para>
+                      Unique string: the error message. If flag==%t, then errormsg=="".
+                      If flag==%f, then errmsg contains the error message.
+                    </para>
                 </listitem>
             </varlistentry>
         </variablelist>
     <refsection>
         <title>Description</title>
         <para>
-            Performs silently if the two matrices of doubles or complex doubles
-            computed and expected are close.
+            Performs silently if the two arrays of doubles or complex doubles, or the two arrays
+            of real or complex polynomials computed and expected are close.
             The variables computed and expected can be exchanged without changing the result.
         </para>
         <para>
+          In case of polynomials, the size of both arrays, the degrees, and finally the
+          matrices of their coefficients are compared within the given or default tolerances.
+        </para>
+        <para>
             Any optional input argument equal to the empty matrix is replaced by its default value.
         </para>
         <para>
@@ -267,7 +292,14 @@ assert_checkalmostequal ( 1+%i , 1+(1+1.e-4)*%i , 1.e-5 , [], "element" );
         <revhistory>
             <revision>
                 <revnumber>5.4.0</revnumber>
-                <revdescription>Function introduced
+                <revdescription>
+                    Function introduced.
+                </revdescription>
+            </revision>
+            <revision>
+                <revnumber>6.0.1</revnumber>
+                <revdescription>
+                    Extension to polynomials.
                 </revdescription>
             </revision>
         </revhistory>
index 3c9009e..189d93f 100644 (file)
  * along with this program.
  *
  -->
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns3="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="assert_checkalmostequal" xml:lang="ja">
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
+          xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns3="http://www.w3.org/1999/xhtml"
+          xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook"
+          xmlns:scilab="http://www.scilab.org" xml:id="assert_checkalmostequal" xml:lang="ja">
     <refnamediv>
         <refname>assert_checkalmostequal</refname>
         <refpurpose>計算値と予測値が数値的に近いことを調べる.</refpurpose>
@@ -36,8 +39,9 @@
                 <term>computed:</term>
                 <listitem>
                     <para>
-                        doubleの行列, doubleの疎行列, または
-                        doubleのハイパー行列, 計算結果
+                      matrix or hypermatrix or sparse matrix of decimal real or complex numbers;
+                      or matrix or hypermatrix of polynomials with real or complex coefficients:
+                      the computed result.
                     </para>
                 </listitem>
             </varlistentry>
                 <term>expected :</term>
                 <listitem>
                     <para>
-                        doubleの行列, doubleの疎行列, または
-                        doubleのハイパー行列, 予測する結果
+                      matrix or hypermatrix or sparse matrix of decimal real or complex numbers;
+                      or matrix or hypermatrix of polynomials with real or complex coefficients:
+                      the expected result.
                     </para>
+                  <para>
+                    If <literal>computed</literal> are polynomials, <literal>expected</literal>
+                    must be polynomials as well.
+                  </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
     <refsection>
         <title>説明</title>
         <para>
-            doubleまたは複素数doubleの2つの行列, computed と expected が近い
-            場合にそのまま実行されます.
-            変数computedとexpectedを交換しても結果に影響しません.
+            Performs silently if the two arrays of doubles or complex doubles, or the two arrays
+            of real or complex polynomials computed and expected are close.
+            The variables computed and expected can be exchanged without changing the result.
+        </para>
+        <para>
+          In case of polynomials, the size of both arrays, the degrees, and finally the
+          matrices of their coefficients are compared within the given or default tolerances.
         </para>
         <para>
             オプションの入力引数に空の行列w指定するとデフォルト値で
@@ -293,6 +306,12 @@ assert_checkalmostequal ( 1+%i , 1+(1+1.e-4)*%i , 1.e-5 , [], "element" );
                 <revdescription>関数が導入されました
                 </revdescription>
             </revision>
+            <revision>
+                <revnumber>6.0.1</revnumber>
+                <revdescription>
+                    Extension to polynomials.
+                </revdescription>
+            </revision>
         </revhistory>
     </refsection>
 </refentry>
index f851fd8..0f647d5 100644 (file)
@@ -1,6 +1,7 @@
 // Copyright (C) 2008 - 2009 - INRIA - Michael Baudin
 // Copyright (C) 2009 - 2011 - DIGITEO - Michael Baudin
 // Copyright (C) 2012 - Michael Baudin
+// Copyright (C) 2017 - Samuel GOUGEON
 //
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
 //
 // along with this program.
 
 function [flag,errmsg] = assert_checkalmostequal ( varargin )
-    // Returns the indices where
-    //  * kpinf : x(kpinf) == +%inf,
-    //  * kninf : x(kninf) == -%inf,
-    //  * knan : x(knan) is a %nan
-    //  * kreg : x(kreg) is not an infinity, not a nan
-    //  * xreg = x(kreg)
-    // These 4 sets of indices have no intersection.
-    //
-    // Example :
-    // x = [1 2 3 -%inf %inf %nan %inf %nan -%inf 4 5 6]
-    // [kpinf , kninf , knan , kreg , xreg] = infnanindices ( x )
-    // xreg = [1 2 3 4 5 6]
-    // kreg = [1 2 3 10 11 12]
-    // knan = [6 8]
-    // kninf = [4 9]
-    // kpinf = [5 7]
+
     function [kpinf , kninf , knan , kreg , xreg] = infnanindices ( x )
+        // Returns the indices where
+        //  * kpinf : x(kpinf) == +%inf,
+        //  * kninf : x(kninf) == -%inf,
+        //  * knan : x(knan) is a %nan
+        //  * kreg : x(kreg) is not an infinity, not a nan
+        //  * xreg = x(kreg)
+        // These 4 sets of indices have no intersection.
+        //
+        // Example :
+        // x = [1 2 3 -%inf %inf %nan %inf %nan -%inf 4 5 6]
+        // [kpinf , kninf , knan , kreg , xreg] = infnanindices ( x )
+        // xreg = [1 2 3 4 5 6]
+        // kreg = [1 2 3 10 11 12]
+        // knan = [6 8]
+        // kninf = [4 9]
+        // kpinf = [5 7]
+
         kpinf = find(x==%inf)
         kninf = find(x==-%inf)
         knan = find(isnan(x))
@@ -36,7 +39,6 @@ function [flag,errmsg] = assert_checkalmostequal ( varargin )
         xreg = x(kreg)
     endfunction
 
-
     function areequal = assert_arealmostequal ( computed , expected , reltol , abstol , comptype )
         //
         // Decompose the expected value into nan indices, inf indices and regular indices
@@ -69,6 +71,7 @@ function [flag,errmsg] = assert_checkalmostequal ( varargin )
         // * the +%inf must be at the same place,
         // * the -%inf must be at the same place,
         // * the %nan must be at the same place.
+
         areequal = ( areclose & and(kcpinf == kepinf) & and(kcninf == keninf) & and(kcnan == kenan) )
     endfunction
 
@@ -86,14 +89,14 @@ function [flag,errmsg] = assert_checkalmostequal ( varargin )
             end
         end
     endfunction
-
+    // ============================================================================================
 
     //  Check that computed and expected are numerically close.
 
     [lhs,rhs]=argn()
     if ( and(rhs <> [2 3 4 5] ) ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong number of input arguments: %d to %d expected.") , "assert_checkalmostequal" , 2 , 5 )
-        error(errmsg)
+        errmsg = gettext("%s: Wrong number of input arguments: %d to %d expected.")
+        error(msprintf(errmsg, "assert_checkalmostequal" , 2 , 5 ))
     end
     //
     // Get arguments
@@ -104,61 +107,75 @@ function [flag,errmsg] = assert_checkalmostequal ( varargin )
     comptype = assert_argindefault ( rhs , varargin , 5 , "element" )
     //
     // Check types of variables
-    if ( and(typeof(computed) <> ["constant" "sparse" "hypermat"]) ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong type for input argument #%d: Matrix expected.\n") , "assert_checkalmostequal" , 1 )
-        error(errmsg)
+    if ( and(typeof(computed) <> ["constant" "sparse" "polynomial"]) ) then
+        errmsg = gettext("%s: Wrong type for input argument #%d: Matrix expected.\n")
+        error(msprintf(errmsg, "assert_checkalmostequal", 1))
+    end
+    if ( and(typeof(expected) <> ["constant" "sparse" "polynomial"]) ) then
+        errmsg = gettext("%s: Wrong type for input argument #%d: Matrix expected.\n")
+        error(msprintf (errmsg, "assert_checkalmostequal" , 2 ))
     end
-    if ( and(typeof(expected) <> ["constant" "sparse" "hypermat"]) ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong type for input argument #%d: Matrix expected.\n") , "assert_checkalmostequal" , 2 )
-        error(errmsg)
+    if typeof(computed)=="polynomial" & typeof(expected)~="polynomial" then
+        errmsg = gettext("%s: Wrong type for input argument #%d: Polynomial expected.\n")
+        error(msprintf (errmsg, "assert_checkalmostequal" , 2 ))
     end
     if ( typeof(reltol) <> "constant" ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong type for input argument #%d: Matrix expected.\n") , "assert_checkalmostequal" , 3 )
-        error(errmsg)
+        errmsg = gettext("%s: Wrong type for input argument #%d: Matrix expected.\n")
+        error(sprintf(errmsg, "assert_checkalmostequal", 3 ))
     end
     if ( typeof(abstol) <> "constant" ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong type for input argument #%d: Matrix expected.\n") , "assert_checkalmostequal" , 4 )
-        error(errmsg)
+        errmsg = gettext("%s: Wrong type for input argument #%d: Matrix expected.\n")
+        error(sprintf(errmsg, "assert_checkalmostequal", 4 ))
     end
     if ( typeof(comptype) <> "string" ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong type for input argument #%d: Matrix of strings expected.\n") , "assert_checkalmostequal" , 5 )
-        error(errmsg)
+        errmsg = gettext("%s: Wrong type for input argument #%d: Matrix of strings expected.\n")
+        error(sprintf(errmsg, "assert_checkalmostequal", 5))
     end
     //
     // Check sizes of variables
     if ( size(reltol,"*") <> 1 ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n") , "assert_checkalmostequal" , 3 , 1 , 1 )
-        error(errmsg)
+        errmsg = gettext("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n")
+        error(msprintf(errmsg, "assert_checkalmostequal", 3, 1, 1))
     end
     if ( size(abstol,"*") <> 1 ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n") , "assert_checkalmostequal" , 4 , 1 , 1 )
-        error(errmsg)
+        errmsg = gettext("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n")
+        error(msprintf(errmsg, "assert_checkalmostequal", 4, 1, 1))
     end
     if ( size(comptype,"*") <> 1 ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n") , "assert_checkalmostequal" , 5 , 1 , 1 )
-        error(errmsg)
+        errmsg = gettext("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n")
+        error(msprintf(errmsg, "assert_checkalmostequal", 5, 1, 1))
     end
     //
     // Check values of variables
     if ( reltol < 0 ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong value for input argument #%d: Must be > %d.\n") , "assert_checkalmostequal" , 3 , 0 )
-        error(errmsg)
+        errmsg = gettext("%s: Wrong value for input argument #%d: Must be > %d.\n")
+        error(msprintf(errmsg, "assert_checkalmostequal", 3, 0))
     end
     if ( abstol < 0 ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong value for input argument #%d: Must be > %d.\n") , "assert_checkalmostequal" , 4 , 0 )
-        error(errmsg)
+        errmsg = gettext("%s: Wrong value for input argument #%d: Must be > %d.\n")
+        error(msprintf(errmsg, "assert_checkalmostequal", 4, 0))
     end
     if ( and ( comptype <> ["matrix" "element"] ) ) then
-        errmsg = sprintf ( gettext ( "%s: Wrong value for input argument #%d: Must be in the set  {%s}.\n") , "assert_checkalmostequal" , 5 , """matrix"",""element""" )
-        error(errmsg)
+        errmsg = gettext("%s: Wrong value for input argument #%d: Must be in the set  {%s}.\n")
+        error(msprintf(errmsg, "assert_checkalmostequal", 5, """matrix"",""element"""))
     end
     //
     // Proceed...
     ncom = size(computed)
     nexp = size(expected)
     if ( or(ncom <> nexp) ) then
-        errmsg = sprintf ( gettext ( "%s: Incompatible input arguments #%d and #%d: Same sizes expected.\n" ) , "assert_checkalmostequal" , 1 , 2 )
-        error(errmsg)
+        errmsg = gettext("%s: Incompatible input arguments #%d and #%d: Same sizes expected.\n")
+        error(msprintf(errmsg, "assert_checkalmostequal", 1, 2))
+    end
+    if typeof(computed)=="polynomial" then
+        if or(degree(computed) <> degree(expected) ) then
+            errmsg = gettext("%s: Arguments #%d and #%d: Same degrees expected.\n")
+            error(msprintf(errmsg, "assert_checkalmostequal", 1, 2))
+        end
+        computed0 = computed;
+        expected0 = expected;
+        computed = coeff(computed(:));
+        expected = coeff(expected(:));
     end
     //
     areequal_re = assert_arealmostequal ( real(computed) , real(expected) , reltol , abstol , comptype )
@@ -173,6 +190,10 @@ function [flag,errmsg] = assert_checkalmostequal ( varargin )
         errmsg = ""
     else
         flag = %f
+        if isdef("computed0","l") then
+            computed = computed0;
+            expected = expected0;
+        end
         // Change the message if the matrix contains more than one value
         if ( size(expected,"*") == 1 ) then
             estr = string(expected)
@@ -186,7 +207,8 @@ function [flag,errmsg] = assert_checkalmostequal ( varargin )
         end
         relstr = string(reltol)
         absstr = string(abstol)
-        errmsg = msprintf(gettext("%s: Assertion failed: expected = %s while computed = %s"),"assert_checkalmostequal",estr,cstr)
+        errmsg = gettext("%s: Assertion failed: expected = %s while computed = %s")
+        errmsg = msprintf(errmsg, "assert_checkalmostequal", estr, cstr)
         if ( lhs < 2 ) then
             // If no output variable is given, generate an error
             assert_generror ( errmsg )
diff --git a/scilab/modules/development_tools/tests/unit_tests/assert/checkalmostequal.dia.ref b/scilab/modules/development_tools/tests/unit_tests/assert/checkalmostequal.dia.ref
deleted file mode 100644 (file)
index bba739e..0000000
+++ /dev/null
@@ -1,251 +0,0 @@
-// Copyright (C) 2008 - INRIA - Michael Baudin
-// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
-//
-// Copyright (C) 2012 - 2016 - Scilab Enterprises
-//
-// This file is hereby licensed under the terms of the GNU GPL v2.0,
-// pursuant to article 5.3.4 of the CeCILL v.2.1.
-// This file was originally licensed under the terms of the CeCILL v2.1,
-// and continues to be available under such terms.
-// For more information, see the COPYING file which you should have received
-// along with this program.
-// <-- CLI SHELL MODE -->
-// <-- ENGLISH IMPOSED -->
-function flag = MY_assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-function checkassert ( flag , errmsg , ctype )
-  if ( ctype == "success" ) then
-    MY_assert_equal ( (flag==%t) & (errmsg==""), %t )
-  else
-    MY_assert_equal ( (flag==%f) & (errmsg<>""), %t )
-  end
-endfunction
-format("v",10);
-// Check error message when number of arguments is false
-instr = "assert_checkalmostequal ( )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//
-instr = "assert_checkalmostequal ( 1 )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//
-instr = "[o1,o2,o3]=assert_checkalmostequal ( 1 , 1 , %eps )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 999 );
-//
-//////////////////////////////////////////
-// Check error message when type of arguments is false
-instr = "assert_checkalmostequal ( ""a"" , 2 , %eps )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//
-instr = "assert_checkalmostequal ( 1 , ""b"" , %eps )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//
-instr = "assert_checkalmostequal ( 1 , 2 , ""c"" )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//
-instr = "assert_checkalmostequal ( 1 , 2 , %eps , ""c"" )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//
-instr = "assert_checkalmostequal ( 1 , 2 , %eps , 0 , %t )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//////////////////////////////////////////
-// Check error message when size of arguments is false
-instr = "assert_checkalmostequal ( 1 , 2 , [1 1] )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//
-instr = "assert_checkalmostequal ( 1 , 2 , %eps , [1 1] )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//
-instr = "assert_checkalmostequal ( 1 , 2 , %eps , 0 , [""a"" ""b""] )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//
-instr = "assert_checkalmostequal ( 1 , [2 3] , %eps )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-//////////////////////////////////////////
-//
-// Check that the error message is correctly handled.
-instr = "assert_checkalmostequal ( 1 , 2 )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-errmsg = lasterror();
-refmsg = msprintf(_("%s: Assertion failed: expected = %s while computed = %s"), "assert_checkalmostequal", "2", "1");
-MY_assert_equal ( errmsg , refmsg );
-//
-// Check that the error message is correctly handled.
-instr = "assert_checkalmostequal ( 1 , 2 , %eps )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-errmsg = lasterror();
-refmsg = msprintf(_("%s: Assertion failed: expected = %s while computed = %s"), "assert_checkalmostequal", "2", "1");
-MY_assert_equal ( errmsg , refmsg );
-//
-// Check that the error message is correctly handled.
-instr = "assert_checkalmostequal ( 1 , 1 , %eps )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 0 );
-errmsg = lasterror();
-MY_assert_equal ( errmsg , [] );
-//
-// Obvious failure : Check the error message
-instr = "assert_checkalmostequal ( zeros(10,1)+1.e-4 , zeros(10,1) , 1.e-5 )";
-ierr=execstr(instr,"errcatch");
-MY_assert_equal ( ierr , 10000 );
-errmsg = lasterror();
-refmsg = msprintf(_("%s: Assertion failed: expected = %s while computed = %s"), "assert_checkalmostequal", "[0 ...]", "[0.0001 ...]");
-MY_assert_equal ( errmsg , refmsg );
-//////////////////////////////////////////
-//
-// Test empty matrix
-//
-// Obvious success
-[flag,errmsg] = assert_checkalmostequal ( [] , [] );
-checkassert ( flag , errmsg , "success" );
-//
-// Obvious success
-[flag,errmsg] = assert_checkalmostequal ( [] , [] , [], [], "matrix");
-checkassert ( flag , errmsg , "success" );
-//
-// Obvious success
-[flag,errmsg] = assert_checkalmostequal ( [] , [] , [], [], "element");
-checkassert ( flag , errmsg , "success" );
-//////////////////////////////////////////
-//
-//
-// Obvious success
-[flag,errmsg] = assert_checkalmostequal ( 1 , 1 );
-checkassert ( flag , errmsg , "success" );
-// Obvious success
-[flag,errmsg] = assert_checkalmostequal ( 1 , 1 , %eps );
-checkassert ( flag , errmsg , "success" );
-//
-// Obvious success
-[flag,errmsg] = assert_checkalmostequal ( ones(10,1) , ones(10,1) , %eps );
-checkassert ( flag , errmsg , "success" );
-//
-// Obvious success
-[flag,errmsg] = assert_checkalmostequal ( ones(10,1)+%eps , ones(10,1) , %eps );
-checkassert ( flag , errmsg , "success" );
-//
-// Obvious success
-[flag,errmsg] = assert_checkalmostequal ( zeros(10,1) , zeros(10,1) , 1.e-5 );
-checkassert ( flag , errmsg , "success" );
-//
-// Obvious failure
-[flag,errmsg] = assert_checkalmostequal ( 1 , 2 , %eps );
-checkassert ( flag , errmsg , "failure" );
-//
-// Obvious failure
-[flag,errmsg] = assert_checkalmostequal ( zeros(10,1)+1.e-4 , zeros(10,1) , 1.e-5 );
-checkassert ( flag , errmsg , "failure" );
-//
-// Success: not obvious!
-// The two values are equal, very small, but nonzero.
-// The relative tolerance must be used here.
-// If, instead, a bug in the assert function is so that the 
-// absolute tolerance is used as 10^-16, then the output 
-// of this comparison is wrong.
-[flag,errmsg] = assert_checkalmostequal ( 1.23456789123456789e-30 , 1.23456789123456789e-30 , %eps );
-checkassert ( flag , errmsg , "success" );
-//
-// Failure : not obvious!
-// There is only one significant digit here and we require the 
-// maximum precision.
-// The test must fail because the relative tolerance must be used here.
-// If, instead, there is a bug in the comparison and 
-// the absolute tolerance is used and set to
-// 10^-16, the output of this test is wrong.
-[flag,errmsg] = assert_checkalmostequal ( 1.23456789123456789e-30 , 1.3e-30 , %eps );
-checkassert ( flag , errmsg , "failure" );
-//
-// Success : not obvious!
-// The expected result is zero, so that the absolute tolerance is used.
-[flag,errmsg] = assert_checkalmostequal ( 1.23456789123456789e-30 , 0 , 0 , 1.e-10 );
-checkassert ( flag , errmsg , "success" );
-//
-// Check that nans are correctly handled
-[flag,errmsg] = assert_checkalmostequal ( [1 %nan], [1 %nan] , %eps );
-checkassert ( flag , errmsg , "success" );
-//
-// Check that nans are correctly handled
-[flag,errmsg] = assert_checkalmostequal ( [1 %nan 1 %nan] , [1 %nan 1 %nan] , %eps );
-checkassert ( flag , errmsg , "success" );
-//
-[flag,errmsg] = assert_checkalmostequal ( [%nan 1], [1 %nan] , %eps );
-checkassert ( flag , errmsg , "failure" );
-//
-// Check that slightly different values cannot pass basic test
-// Simple sequence with default settings
-[flag,errmsg] = assert_checkalmostequal ( 1 + 5 * %eps , 1 , %eps );
-checkassert ( flag , errmsg , "failure" );
-//
-// Customize the relative precision so that a test can pass
-// Simple sequence with default settings
-[flag,errmsg] = assert_checkalmostequal ( 1 + 5 * %eps , 1 , 10*%eps );
-checkassert ( flag , errmsg , "success" );
-//
-// Customize the absolute precision so that a test can pass
-// Simple sequence with default settings
-[flag,errmsg] = assert_checkalmostequal ( 0 + 5 * %eps , 0 , 0 , 10*%eps );
-checkassert ( flag , errmsg , "success" );
-//
-// An example where the relative error is used,
-// with a customized tolerance.
-[flag,errmsg] = assert_checkalmostequal ( 1.23456 , 1.23457 , 1.e11*%eps );
-checkassert ( flag , errmsg , "success" );
-//
-// Put all IEEE values
-[flag,errmsg] = assert_checkalmostequal ( [1.2345 %inf -%inf %nan] , [1.2346 %inf -%inf %nan] , 1.e-4 );
-checkassert ( flag , errmsg , "success" );
-///////////////////////////////////////////////////////////////////////////////
-// Test elementwise algo
-// If "matrix" type is used, this test pass.
-[flag,errmsg] = assert_checkalmostequal ( [1 1.e5] , [2 1.e5] , 1.e-3 , [], "element" );
-checkassert ( flag , errmsg , "failure" );
-//
-// Force the test to pass
-[flag,errmsg] = assert_checkalmostequal ( [1 1.e5] , [1 1.e5] , 1.e-3 , [], "element" );
-checkassert ( flag , errmsg , "success" );
-//
-[flag,errmsg] = assert_checkalmostequal ( [1 %nan] , [2 %nan] , 1.e-3 , [], "element" );
-checkassert ( flag , errmsg , "failure" );
-//
-[flag,errmsg] = assert_checkalmostequal ( [1 %inf] , [2 %inf] , 1.e-3 , [], "element" );
-checkassert ( flag , errmsg , "failure" );
-//
-[flag,errmsg] = assert_checkalmostequal ( [1 %inf] , [1 %inf] , 1.e-3 , [], "element" );
-checkassert ( flag , errmsg , "success" );
-//
-[flag,errmsg] = assert_checkalmostequal ( [1 %inf -%inf %nan] , [1 %inf -%inf %nan] , 1.e-3 , [], "element" );
-checkassert ( flag , errmsg , "success" );
-//
-[flag,errmsg] = assert_checkalmostequal ( [1 %inf -%inf %nan] , [1 -%inf %inf %nan] , 1.e-3 , [], "element" );
-checkassert ( flag , errmsg , "failure" );
-///////////////////////////////////////////////////////////////////////////////
-// Test complex elementwise algo
-//
-[flag,errmsg] = assert_checkalmostequal ( 1+%i , 1+(1+1.e-4)*%i , 1.e-3 , [], "element" );
-checkassert ( flag , errmsg , "success" );
-[flag,errmsg] = assert_checkalmostequal ( 1+%i , 1+(1+1.e-4)*%i , 1.e-5 , [], "element" );
-checkassert ( flag , errmsg , "failure" );
-//
-// Use absolute tolerance
-[flag,errmsg] = assert_checkalmostequal ( 1+%i , 0 , [], 1.e-3 , "element" );
-checkassert ( flag , errmsg , "failure" );
-//
index f18f9e1..6eaf6a0 100644 (file)
@@ -1,5 +1,6 @@
 // Copyright (C) 2008 - INRIA - Michael Baudin
 // Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
+// Copyright (C) 2017 - Samuel GOUGEON
 //
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
 //
@@ -12,6 +13,7 @@
 
 // <-- CLI SHELL MODE -->
 // <-- ENGLISH IMPOSED -->
+// <-- NO CHECK REF -->
 
 function flag = MY_assert_equal ( computed , expected )
   if computed==expected then
@@ -29,7 +31,7 @@ function checkassert ( flag , errmsg , ctype )
     MY_assert_equal ( (flag==%f) & (errmsg<>""), %t )
   end
 endfunction
-    
+
 
 format("v",10);
 
@@ -167,17 +169,17 @@ checkassert ( flag , errmsg , "failure" );
 // Success: not obvious!
 // The two values are equal, very small, but nonzero.
 // The relative tolerance must be used here.
-// If, instead, a bug in the assert function is so that the 
-// absolute tolerance is used as 10^-16, then the output 
+// If, instead, a bug in the assert function is so that the
+// absolute tolerance is used as 10^-16, then the output
 // of this comparison is wrong.
 [flag,errmsg] = assert_checkalmostequal ( 1.23456789123456789e-30 , 1.23456789123456789e-30 , %eps );
 checkassert ( flag , errmsg , "success" );
 //
 // Failure : not obvious!
-// There is only one significant digit here and we require the 
+// There is only one significant digit here and we require the
 // maximum precision.
 // The test must fail because the relative tolerance must be used here.
-// If, instead, there is a bug in the comparison and 
+// If, instead, there is a bug in the comparison and
 // the absolute tolerance is used and set to
 // 10^-16, the output of this test is wrong.
 [flag,errmsg] = assert_checkalmostequal ( 1.23456789123456789e-30 , 1.3e-30 , %eps );
@@ -223,6 +225,7 @@ checkassert ( flag , errmsg , "success" );
 [flag,errmsg] = assert_checkalmostequal ( [1.2345 %inf -%inf %nan] , [1.2346 %inf -%inf %nan] , 1.e-4 );
 checkassert ( flag , errmsg , "success" );
 
+
 ///////////////////////////////////////////////////////////////////////////////
 // Test elementwise algo
 
@@ -261,4 +264,21 @@ checkassert ( flag , errmsg , "failure" );
 [flag,errmsg] = assert_checkalmostequal ( 1+%i , 0 , [], 1.e-3 , "element" );
 checkassert ( flag , errmsg , "failure" );
 //
+///////////////////////////////////////////////////////////////////////////////
+// Tests with polynomials
+//
+assert_checkalmostequal(%z, %z);
+assert_checkalmostequal([%z %z], [%z %z]);
+assert_checkalmostequal([%z %z^2], [%z %z^2]);
+
+assert_checkalmostequal(%z+%eps, %z-%eps, [], 10*%eps);
+assert_checkalmostequal([(1+%eps)*%z %z], [(1-%eps)*%z %z], [], %eps);
+assert_checkalmostequal([%z %z^2]+%eps, [%z %z^2]-%eps, [], 2*%eps);
+
+assert_checkalmostequal(%i+%z, %i+%z);
+assert_checkalmostequal([%i+%z %i*%z], [%i+%z %i*%z]);
+assert_checkalmostequal([1+%i*%z, %i-%z^2], [1+%i*%z, %i-%z^2]);
 
+assert_checkalmostequal(%i+%z+%eps, %i+%z-%eps, [], 2*%eps);
+assert_checkalmostequal([%i+%z %i*%z]+%eps, [%i+%z %i*%z]-%eps, [], 2*%eps);
+assert_checkalmostequal([1+%i*%z, %i-%z^2]-%eps, [1+%i*%z, %i-%z^2]+%eps, [], 2*%eps);