Bug #11390: update cond function. If c = cond(X), x can be non square. And it is... 56/8756/6
Adeline CARNIS [Tue, 21 Aug 2012 10:29:01 +0000 (12:29 +0200)]
Change-Id: Ic55c82b54985f7459e5465a51e40b7babcd6d25b

SEP/SEP_085_cond_improvement.odt [moved from SEP/SEP_085_conv_improvement.odt with 100% similarity]
scilab/CHANGES_5.4.X
scilab/modules/linear_algebra/help/en_US/matrix/cond.xml
scilab/modules/linear_algebra/help/fr_FR/matrix/cond.xml
scilab/modules/linear_algebra/macros/cond.sci
scilab/modules/linear_algebra/tests/unit_tests/cond.dia.ref [new file with mode: 0644]
scilab/modules/linear_algebra/tests/unit_tests/cond.tst [new file with mode: 0644]

index c69923b..3c6bfb4 100644 (file)
@@ -41,6 +41,11 @@ Compilation
 
 * Switch to JOGL 2.0 rc9
 
+Linear Algebra
+==============
+
+* cond function updated (See SEP #85)
+
 
 Bug Fixes
 =========
@@ -66,6 +71,11 @@ Bug Fixes
 
 * Bug #9976 fixed - The inverse cdfbet function returned wrong value instead of 0.
 
+* bug #11390 fixed - When the cond function has one input argument, matrices can be
+                     non square. Moreover, the cond function has been updated to 
+                     give the possibility to use another norm than that imposed
+                     (by default 2-norm).
+
 * Bug #11411 fixed - save function used unsigned char to store length of string.
                      Now it is an integer.
 
index de19ad2..f8d1916 100644 (file)
@@ -2,6 +2,7 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA
+ * Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  *
  -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" version="5.0-subset Scilab" xml:lang="en" xml:id="cond">
-    <refnamediv>
-        <refname>cond</refname>
-        <refpurpose> condition number</refpurpose>
-    </refnamediv>
-    <refsynopsisdiv>
-        <title>Calling Sequence</title>
-        <synopsis>cond(X)</synopsis>
-    </refsynopsisdiv>
-    <refsection>
-        <title>Arguments</title>
-        <variablelist>
-            <varlistentry>
-                <term>X</term>
-                <listitem>
-                    <para>real or complex square matrix</para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
-    </refsection>
-    <refsection>
-        <title>Description</title>
-        <para>
-            Condition number in 2-norm.  <literal>cond(X)</literal> is the  ratio  of  the
-            largest singular value of  <literal>X</literal>  to the smallest.
-        </para>
-    </refsection>
-    <refsection>
-        <title>Examples</title>
-        <programlisting role="example"><![CDATA[ 
+  <refnamediv>
+    <refname>cond</refname>
+    <refpurpose> condition number</refpurpose>
+  </refnamediv>
+  <refsynopsisdiv>
+    <title>Calling Sequence</title>
+    <synopsis>
+      c = cond(X)
+      c = cond(X, p)
+    </synopsis>
+  </refsynopsisdiv>
+  <refsection>
+    <title>Arguments</title>
+    <variablelist>
+      <varlistentry>
+        <term>X</term>
+        <listitem>
+          <para>real or complex matrix. If c = cond(X, p), X must be real or complex square matrix.</para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>p</term>
+        <listitem>
+          <para>scalar or string (type of norm) (default value = 2).</para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>c</term>
+        <listitem>
+          <para>real scalar, the condition number.</para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsection>
+  <refsection>
+    <title>Description</title>
+    <variablelist>
+      <varlistentry>
+        <term>c = cond(X)</term>
+        <listitem>
+          <para>
+            returns condition number in 2-norm.<literal>cond(X)</literal> is the  ratio  of  the
+            largest singular value of <literal>X</literal> to the smallest.
+          </para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>c = cond(X, p)</term>
+        <listitem>
+          <para>
+            returns condition number in p-norm : <literal>norm(X, p) * norm(inv(X), p)</literal>.
+            If <literal>p</literal> is specified, <literal>p</literal> can be equal to :
+          </para>
+          <itemizedlist>
+            <listitem>
+              <para>
+                p = 1. <literal>cond(X, p)</literal> returns condition number in 1-norm.
+              </para>
+            </listitem>
+            <listitem>
+              <para>
+                p = 2. <literal>cond(X, p)</literal> returns condition number in 2-norm.
+              </para>
+            </listitem>
+            <listitem>
+              <para>
+                p = %inf or 'inf'. <literal>cond(X, p)</literal> returns condition number in infinity norm.
+              </para>
+            </listitem>
+            <listitem>
+              <para>
+                p = 'fro'. <literal>cond(X, p)</literal> returns condition number in Frobenius norm.
+              </para>
+            </listitem>
+          </itemizedlist>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsection>
+  <refsection>
+    <title>Examples</title>
+    <programlisting role="example">
+      <![CDATA[ 
 A=testmatrix('hilb',6);
+// condition number in 2-norm
 cond(A)
- ]]></programlisting>
-    </refsection>
-    <refsection role="see also">
-        <title>See Also</title>
-        <simplelist type="inline">
-            <member>
-                <link linkend="rcond">rcond</link>
-            </member>
-            <member>
-                <link linkend="svd">svd</link>
-            </member>
-        </simplelist>
-    </refsection>
+cond(A, 2)
+
+// condition number in 1-norm
+cond(A, 1)
+
+// condition number in infinity norm
+cond(A, %inf)
+
+// condition number in Frobenius norm
+cond(A, 'fro')
+ ]]>
+    </programlisting>
+  </refsection>
+  <refsection role="see also">
+    <title>See Also</title>
+    <simplelist type="inline">
+      <member>
+        <link linkend="rcond">rcond</link>
+      </member>
+      <member>
+        <link linkend="svd">svd</link>
+      </member>
+      <member>
+        <link linkend="norm">norm</link>
+      </member>
+    </simplelist>
+  </refsection>
+  <refsection>
+    <title>History</title>
+    <revhistory>
+      <revision>
+        <revnumber>5.4.0</revnumber>
+        <revdescription>
+          <para>
+            Calling <literal>cond(X)</literal>, where <literal>X</literal> is
+            non square matrix, is now managed. For example:
+          </para>
+          <programlisting role="">
+            <![CDATA[ 
+X = [1 0; 1 -1; 0 1];
+cond(X)
+ ]]>
+          </programlisting>
+          <para>
+            Calling <literal>cond(X, p)</literal> allows to calculate p-norm
+            condition number. For example:
+          </para>
+          <programlisting role="">
+            <![CDATA[ 
+X = [1 -6 0; 1 0 -4;1 0 2];
+cond(X, 1) // condition number in 1-norm (p = 1)
+ ]]>
+          </programlisting>
+        </revdescription>
+      </revision>
+    </revhistory>
+  </refsection>
 </refentry>
index ded811c..081886f 100644 (file)
@@ -2,6 +2,7 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA
+ * Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  *
  -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" version="5.0-subset Scilab" xml:lang="fr" xml:id="cond">
-  <refnamediv>
-    <refname>cond</refname>
-    <refpurpose> conditionnement  </refpurpose>
-  </refnamediv>
-  <refsynopsisdiv>
-    <title>Séquence d'appel</title>
-    <synopsis>cond(X)</synopsis>
-  </refsynopsisdiv>
-  <refsection>
-    <title>Paramètres</title>
-    <variablelist>
-      <varlistentry>
-        <term>X  </term>
-        <listitem>
-          <para>matrice réelle ou complexe
-          </para>
-        </listitem>
-      </varlistentry>
-    </variablelist>
-  </refsection>
-  <refsection>
-    <title>Description</title>
-    <para>
-      Conditionnement en norme 2. <literal>cond(X)</literal> est le quotient entre la plus grande et la plus petite valeur singulière de <literal>X</literal>.
-    </para>
-  </refsection>
-  <refsection>
-    <title>Exemples</title>
-    <programlisting role="example"><![CDATA[ 
+    <refnamediv>
+        <refname>cond</refname>
+        <refpurpose> conditionnement  </refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Séquence d'appel</title>
+        <synopsis>
+            c = cond(X)
+            c = cond(X, p)
+        </synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Paramètres</title>
+        <variablelist>
+            <varlistentry>
+                <term>X  </term>
+                <listitem>
+                    <para>
+                        matrice réelle ou complexe. Si c = cond(X, p), X doit être une matrice carrée réelle ou complexe.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>p</term>
+                <listitem>
+                    <para>scalaire ou chaine de caractères (valeur par défaut p = 2).</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>c</term>
+                <listitem>
+                    <para>scalaire réel.</para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <variablelist>
+            <varlistentry>
+                <term>c = cond(X)</term>
+                <listitem>
+                    <para>
+                        retourne le conditionnement en norme 2.<literal>cond(X)</literal> est le quotient entre
+                        la plus grande et la plus petite valeur singulière de <literal>X</literal>.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>c = cond(X, p)</term>
+                <listitem>
+                    <para>
+                        retourne le conditionnement en norme p : <literal>norm(X, p) * norm(inv(X), p)</literal>.
+                        Si <literal>p</literal> est spécifié, <literal>p</literal> est égal soit à:
+                    </para>
+                    <itemizedlist>
+                        <listitem>
+                            <para>
+                                p = 1. <literal>cond(X, p)</literal> retourne le conditionnement en norme 1.
+                            </para>
+                        </listitem>
+                        <listitem>
+                            <para>
+                                p = 2. <literal>cond(X, p)</literal> retourne le conditionnement en norme 2.
+                            </para>
+                        </listitem>
+                        <listitem>
+                            <para>
+                                p = %inf or 'inf'. <literal>cond(X, p)</literal> retourne le conditionnement en norme infinie.
+                            </para>
+                        </listitem>
+                        <listitem>
+                            <para>
+                                p = 'fro'. <literal>cond(X, p)</literal> retourne le conditionnement en norme de Frobenius.
+                            </para>
+                        </listitem>
+                    </itemizedlist>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Exemples</title>
+        <programlisting role="example">
+            <![CDATA[ 
 A=testmatrix('hilb',6);
+// conditionnement en norme 2
 cond(A)
- ]]></programlisting>
-  </refsection>
-  <refsection role="see also">
-    <title>Voir aussi</title>
-    <simplelist type="inline">
-      <member>
-        <link linkend="rcond">rcond</link>
-      </member>
-      <member>
-        <link linkend="svd">svd</link>
-      </member>
-    </simplelist>
-  </refsection>
+cond(A, 2)
+
+// conditionnement en norme 1
+cond(A, 1)
+
+// conditionnement en norme infinie
+cond(A, %inf)
+
+// conditionnement en norme de Frobenius
+cond(A, 'fro')
+ ]]>
+        </programlisting>
+    </refsection>
+    <refsection role="see also">
+        <title>Voir aussi</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="rcond">rcond</link>
+            </member>
+            <member>
+                <link linkend="svd">svd</link>
+            </member>
+            <member>
+                <link linkend="norm">norm</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>Historique</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.4.0</revnumber>
+                <revdescription>
+                    <para>
+                        Appel de <literal>cond(X)</literal>, où <literal>X</literal> est une matrice non
+                        carrée, est maintenant gérée. Par exemple :
+                    </para>
+                    <programlisting role="">
+                        <![CDATA[ 
+X = [1 0; 1 -1; 0 1];
+cond(X)
+ ]]>
+                    </programlisting>
+                    <para>
+                        Appel de <literal>cond(X, p)</literal> permet de calculer le contionnement
+                        en norme p. Par exemple :
+                    </para>
+                    <programlisting role="">
+                        <![CDATA[ 
+X = [1 -6 0; 1 0 -4;1 0 2];
+cond(X, 1) // conditionnement en norme 1 (p = 1)
+ ]]>
+                    </programlisting>
+                </revdescription>
+            </revision>
+        </revhistory>
+    </refsection>
 </refentry>
index f2f3164..d448d0b 100644 (file)
@@ -1,6 +1,6 @@
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) ????-2008 - INRIA
+// Copyright (C) 2012- Scilab Enterprises - Adeline CARNIS
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -8,32 +8,51 @@
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
-function c=cond(A)
-// c=cond(A) condition number for 2-norm
-  if type(A)==1 then
-    if A==[] then c=1,return,end
-    if size(A,1)<>size(A,2) then 
-      error(msprintf(gettext("%s: Wrong size for input argument #%d: A square matrix expected.\n"),'cond',1));
-    end
-    s=svd(A)
-    if s($)==0 then
-      c=%inf
-    else
-      c=s(1)/s($)
-    end
-  else
-    if type(A)==16|type(A)==17 then
-      n=getfield(1,A);n=n(1)
-    else
-      [t,n]=typename()
-      n=stripblanks(n(find(t==type(A))))
-    end
-    fun='%'+n+'_cond'
-    if exists(fun)==1 then
-      execstr('y='+fun+'(A,flag)')
-      
+function c = cond(varargin)
+    rhs = argn(2);
+
+    select rhs
+    case 1
+        // c=cond(A) condition number for 2-norm
+        // cond(A) is the ratio of the largest singular of x to the smallest
+        // Warning: the svd function doesn't manage sparse matrices
+        A = varargin(1);
+        if type(A) == 1 then
+            if or(isnan(A)) | or (isinf(A)) then
+                error(msprintf(gettext("%s: Wrong value for input argument #%d: must not contain %s or %s.\n"), "cond", 1, "%nan", "%inf"));
+            end
+            if A == [] then
+                c = 1;
+                return
+            end
+            s = svd(A);
+            if s($) == 0 then
+                c = %inf;
+            else
+                c = s(1)/s($);
+            end
+        else
+            error(msprintf(gettext("%s: Wrong type for input argument #%d: A matrix expected.\n"), "cond", 1));
+        end
+    case 2
+        // c = cond(A, p) where p = 1, %inf, fro, ..
+        // norm(A, p) * norm(inv(A), p)
+        // Warning inv doesn't manage no square and sparse matrices
+        A = varargin(1);
+        p = varargin(2);
+        [m,n] = size(A);
+        if type(A) <> 1 | m <> n then
+            error(msprintf(gettext('%s: Wrong type for input argument #%d: A square matrix expected.\n"),"cond", 1));
+        end
+        if and(type(p) <> [1, 10]) then
+            error(msprintf(gettext('%s: Wrong type for input argument #%d: A scalar or a string expected.\n"),"cond", 2));
+        end
+        if and(p <> [1 2 %inf] & p <> ['inf','fro']) then
+            error(msprintf(gettext('%s: Wrong value for input argument #%d: must be %d, %d, %s, ''%s'' or ''%s''.\n"), "cond", 2, 1, 2, "%inf", "inf", "fro"));
+        end
+        
+        c = norm(A, p) * norm(inv(A), p);
     else
-       error(msprintf(gettext('%s: Type not defined for ''%s''. Check argument or define function %s.'),'cond',n,fun));
-    end
-  end
+        error(msprintf(gettext("%s: Wrong number of input argument(s): %d to %d expected.\n"), "cond", 1, 2));
+    end 
 endfunction
diff --git a/scilab/modules/linear_algebra/tests/unit_tests/cond.dia.ref b/scilab/modules/linear_algebra/tests/unit_tests/cond.dia.ref
new file mode 100644 (file)
index 0000000..81794ad
--- /dev/null
@@ -0,0 +1,61 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- CLI SHELL MODE -->
+// unit tests for cond function
+// =============================================================================
+// Interface
+// ===========
+assert_checkfalse(execstr("cond()", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d to %d expected.\n"), "cond", 1, 2);
+assert_checkerror("cond()", refMsg);
+assert_checkfalse(execstr("cond(1,2,3)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d to %d expected.\n"), "cond", 1, 2);
+assert_checkerror("cond(1,2,3)", refMsg);
+assert_checkfalse(execstr("cond(%nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: must not contain %s or %s.\n"), "cond", 1, "%nan", "%inf");
+assert_checkerror("cond(%nan)", refMsg);
+assert_checkfalse(execstr("cond(%inf)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: must not contain %s or %s.\n"), "cond", 1, "%nan", "%inf");
+assert_checkerror("cond(%inf)", refMsg);
+assert_checkfalse(execstr("cond(%f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A matrix expected.\n"), "cond", 1);
+assert_checkerror("cond(%f)", refMsg);
+assert_checkfalse(execstr("cond(""ah"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A matrix expected.\n"), "cond", 1);
+assert_checkerror("cond(""ah"")", refMsg);
+assert_checkfalse(execstr("cond(""ah"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A matrix expected.\n"), "cond", 1);
+assert_checkerror("cond(""ah"")", refMsg);
+assert_checkfalse(execstr("cond(""ah"", 1)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "cond", 1);
+assert_checkerror("cond(""ah"", 1)", refMsg);
+assert_checkfalse(execstr("cond(1, %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar or a string expected.\n"),"cond", 2);
+assert_checkerror("cond(1, %f)", refMsg);
+assert_checkfalse(execstr("cond(1, 3)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: must be %d, %d, %s, ''%s'' or ''%s''.\n"), "cond", 2, 1, 2, "%inf", "inf", "fro");
+assert_checkerror("cond(1, 3)", refMsg);
+assert_checkfalse(execstr("cond([8 5 2;4 5 6], 1)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"),"cond", 1);
+assert_checkerror("cond([8 5 2;4 5 6], 1)", refMsg);
+// cond(A)
+A = [8 5 2;4 5 6];
+assert_checkalmostequal(cond(A), 3.1529469);
+A = A * %i;
+assert_checkalmostequal(cond(A), 3.1529469);
+A = [9 0 3;2 5 0;7 4 1];
+assert_checkalmostequal(cond(A), 23.411565);
+assert_checkalmostequal(cond(A,1), 33);
+assert_checkalmostequal(cond(A, %inf), 36);
+assert_checkalmostequal(cond(A, 'inf'), 36);
+assert_checkalmostequal(cond(A, 'fro'), 25.702776, 1e-7);
+A = A * %i;
+assert_checkalmostequal(cond(A), 23.411565);
+assert_checkalmostequal(cond(A,1), 33);
+assert_checkalmostequal(cond(A, %inf), 36);
+assert_checkalmostequal(cond(A, 'inf'), 36);
+assert_checkalmostequal(cond(A, 'fro'), 25.702776, 1e-7);
diff --git a/scilab/modules/linear_algebra/tests/unit_tests/cond.tst b/scilab/modules/linear_algebra/tests/unit_tests/cond.tst
new file mode 100644 (file)
index 0000000..f87fc82
--- /dev/null
@@ -0,0 +1,87 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- CLI SHELL MODE -->
+
+// unit tests for cond function
+// =============================================================================
+
+// Interface
+// ===========
+
+assert_checkfalse(execstr("cond()", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d to %d expected.\n"), "cond", 1, 2);
+assert_checkerror("cond()", refMsg);
+
+assert_checkfalse(execstr("cond(1,2,3)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of input argument(s): %d to %d expected.\n"), "cond", 1, 2);
+assert_checkerror("cond(1,2,3)", refMsg);
+
+assert_checkfalse(execstr("cond(%nan)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: must not contain %s or %s.\n"), "cond", 1, "%nan", "%inf");
+assert_checkerror("cond(%nan)", refMsg);
+
+assert_checkfalse(execstr("cond(%inf)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: must not contain %s or %s.\n"), "cond", 1, "%nan", "%inf");
+assert_checkerror("cond(%inf)", refMsg);
+
+assert_checkfalse(execstr("cond(%f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A matrix expected.\n"), "cond", 1);
+assert_checkerror("cond(%f)", refMsg);
+
+assert_checkfalse(execstr("cond(""ah"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A matrix expected.\n"), "cond", 1);
+assert_checkerror("cond(""ah"")", refMsg);
+
+assert_checkfalse(execstr("cond(""ah"")", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A matrix expected.\n"), "cond", 1);
+assert_checkerror("cond(""ah"")", refMsg);
+
+assert_checkfalse(execstr("cond(""ah"", 1)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"), "cond", 1);
+assert_checkerror("cond(""ah"", 1)", refMsg);
+
+assert_checkfalse(execstr("cond(1, %f)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A scalar or a string expected.\n"),"cond", 2);
+assert_checkerror("cond(1, %f)", refMsg);
+
+assert_checkfalse(execstr("cond(1, 3)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: must be %d, %d, %s, ''%s'' or ''%s''.\n"), "cond", 2, 1, 2, "%inf", "inf", "fro");
+assert_checkerror("cond(1, 3)", refMsg);
+
+assert_checkfalse(execstr("cond([8 5 2;4 5 6], 1)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A square matrix expected.\n"),"cond", 1);
+assert_checkerror("cond([8 5 2;4 5 6], 1)", refMsg);
+
+// cond(A)
+A = [8 5 2;4 5 6];
+assert_checkalmostequal(cond(A), 3.1529469);
+
+A = A * %i;
+assert_checkalmostequal(cond(A), 3.1529469);
+
+A = [9 0 3;2 5 0;7 4 1];
+assert_checkalmostequal(cond(A), 23.411565);
+
+assert_checkalmostequal(cond(A,1), 33);
+
+assert_checkalmostequal(cond(A, %inf), 36);
+
+assert_checkalmostequal(cond(A, 'inf'), 36);
+
+assert_checkalmostequal(cond(A, 'fro'), 25.702776, 1e-7);
+
+A = A * %i;
+assert_checkalmostequal(cond(A), 23.411565);
+
+assert_checkalmostequal(cond(A,1), 33);
+
+assert_checkalmostequal(cond(A, %inf), 36);
+
+assert_checkalmostequal(cond(A, 'inf'), 36);
+
+assert_checkalmostequal(cond(A, 'fro'), 25.702776, 1e-7);