* Bug #10456 fixed - Functions ismatrix, isrow, iscolumn and issquare added (SEP... 55/11455/7
Charlotte HECQUET [Mon, 6 May 2013 14:54:45 +0000 (16:54 +0200)]
Change-Id: I50d14b4128ed28d96a18952904258dd07b4367ed

27 files changed:
SEP/INDEX
SEP/SEP_095_ismatrix_isrow_iscolumn_issquare.odt [new file with mode: 0644]
scilab/CHANGES_5.5.X
scilab/modules/elementary_functions/help/en_US/IsAScalar.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/en_US/iscolumn.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/en_US/ismatrix.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/en_US/isrow.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/en_US/isscalar.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/en_US/issquare.xml [new file with mode: 0644]
scilab/modules/elementary_functions/macros/IsAScalar.sci
scilab/modules/elementary_functions/macros/iscolumn.sci [new file with mode: 0644]
scilab/modules/elementary_functions/macros/ismatrix.sci [new file with mode: 0644]
scilab/modules/elementary_functions/macros/isrow.sci [new file with mode: 0644]
scilab/modules/elementary_functions/macros/isscalar.sci [new file with mode: 0644]
scilab/modules/elementary_functions/macros/issquare.sci [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/IsAScalar.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/IsAScalar.tst [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/iscolumn.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/iscolumn.tst [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/ismatrix.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/ismatrix.tst [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/isrow.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/isrow.tst [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/isscalar.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/isscalar.tst [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/issquare.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/issquare.tst [new file with mode: 0644]

index d2b48a8..ea7e6ff 100644 (file)
--- a/SEP/INDEX
+++ b/SEP/INDEX
@@ -90,4 +90,5 @@ SEP #090: New function to access to numerical data in HDF5 files
 SEP #091: New function daskr
 SEP #092: 
 SEP #093: New function cov
+SEP #095: New functions: ismatrix, isrow,iscolumn and issquare.
 SEP #097: New parameter added at strtod function (decimalseparator)
diff --git a/SEP/SEP_095_ismatrix_isrow_iscolumn_issquare.odt b/SEP/SEP_095_ismatrix_isrow_iscolumn_issquare.odt
new file mode 100644 (file)
index 0000000..1d0bf1f
Binary files /dev/null and b/SEP/SEP_095_ismatrix_isrow_iscolumn_issquare.odt differ
index 4fdcf21..6eaa988 100644 (file)
@@ -18,6 +18,10 @@ BDF methods with direct and preconditioned Krylov linear solvers, from ODEPACK.
  - getURL - Download an URL (HTTP, HTTPS, FTP...)
  - splitURL - Split a URL (HTTP, HTTPS, FTP...)
  - cov - Covariance matrix. Deprecates 'mvvacov'. See bug #11896 fixed.
+ - ismatrix - Check if a variable is a matrix. See bug #10456 fixed.
+ - isrow - Check if a variable is a row vector. See bug #10456 fixed.
+ - iscolumn - Check if a variable is a column vector. See bug #10456 fixed.
+ - issquare - Check if a variable is a square matrix. See bug #10456 fixed.
 
 * Add a complete set of functions to read and write any HDF5 file from Scilab.
 
@@ -54,6 +58,9 @@ Obsolete
 * nfreq() tagged as obsolete. Will be removed for Scilab 5.5.1.
   Use tabul() instead.
 
+* IsAScalar() tagged as obsolete. Will be removed for Scilab 5.5.1.
+  Use isscalar() instead.
+
 
 Xcos
 ====
diff --git a/scilab/modules/elementary_functions/help/en_US/IsAScalar.xml b/scilab/modules/elementary_functions/help/en_US/IsAScalar.xml
new file mode 100644 (file)
index 0000000..d8acf98
--- /dev/null
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2013 - Scilab Enterprises
+ * 
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="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="IsAScalar" xml:lang="en">
+    <refnamediv>
+        <refname>IsAScalar</refname>
+        <refpurpose>
+            check if a variable is a scalar. <emphasis role="bold">This function is obsolete.</emphasis> 
+        </refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Calling Sequence</title>
+        <synopsis>t=IsAScalar(x)</synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>x</term>
+                <listitem>
+                    <para>vector or matrix</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>t</term>
+                <listitem>
+                    <para>a boolean</para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            <literal>IsAScalar(<varname>x</varname>)</literal> returns true if <varname>x</varname>
+            is a scalar (if size(<varname>x</varname>) is 1 and type(<varname>x</varname>,1) is 1 too).
+            <warning>This function is obsolete.</warning>
+            It is better to use <link linkend="isscalar">isscalar</link> instead of <code>IsAScalar</code>.
+        </para>
+    </refsection>
+    <refsection>
+        <title>Examples</title>
+        <programlisting role="example"><![CDATA[ 
+IsAScalar(ones(10,10))
+IsAScalar(1)
+IsAScalar("s")
+ ]]></programlisting>
+    </refsection>
+    <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revdescription>
+                    Function tagged as obsolete. Will be removed in 5.5.1. Please use <link linkend="isscalar">isscalar</link> instead.
+                </revdescription>
+            </revision>
+        </revhistory>
+    </refsection>
+</refentry>
diff --git a/scilab/modules/elementary_functions/help/en_US/iscolumn.xml b/scilab/modules/elementary_functions/help/en_US/iscolumn.xml
new file mode 100644 (file)
index 0000000..eb29491
--- /dev/null
@@ -0,0 +1,104 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2013 - Scilab Enterprises
+ * 
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="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="iscolumn" xml:lang="en">
+    <refnamediv>
+        <refname>iscolumn</refname>
+        <refpurpose>check if a variable is a column</refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Calling Sequence</title>
+        <synopsis>t=iscolumn(x)</synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>x</term>
+                <listitem>
+                    <para>scalar,vector, matrix, hypermatrix, list, array of structures or cells</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>t</term>
+                <listitem>
+                    <para>a boolean</para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            <literal>iscolumn(<varname>x</varname>)</literal> returns true if <varname>x</varname>
+            is a column vector. Scalars are considered as columns. Note that <literal>iscolumn([])</literal>
+            returns false.
+        </para>
+    </refsection>
+    <refsection>
+        <title>Examples</title>
+        <programlisting role="example"><![CDATA[
+iscolumn(ones(10,1))
+iscolumn(1)
+iscolumn(["s"; "t"; "u"])
+iscolumn(rand(3,1,1))
+iscolumn(rand(1,1,3))
+s = struct();
+iscolumn(s) // Empty structure
+clear s
+s.a = %z;
+s.b = 2;
+iscolumn(s) // Scalar array of structures
+clear s
+s(2,1).a = "w"; 
+s(3,1).b = %t;  
+iscolumn(s) // Column array of structures
+clear s
+s(1,2).a = -2;
+s(3,1).b = %pi;
+iscolumn(s) // 2D array of structures
+clear s
+s(1,1,2).a = 3; 
+s(1,1,3).b = "test";
+iscolumn(s) // 3D array of structures (with 2 singleton dims)
+ ]]></programlisting>
+    </refsection>
+    <refsection role="see also">
+        <title>See also</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="isscalar">isscalar</link>
+            </member>
+            <member>
+                <link linkend="isrow">isrow</link>
+            </member>
+            <member>
+                <link linkend="ismatrix">ismatrix</link>
+            </member>
+            <member>
+                <link linkend="issquare">issquare</link>
+            </member>
+            <member>
+                <link linkend="isempty">isempty</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Function iscolumn introduced.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
+</refentry>
diff --git a/scilab/modules/elementary_functions/help/en_US/ismatrix.xml b/scilab/modules/elementary_functions/help/en_US/ismatrix.xml
new file mode 100644 (file)
index 0000000..3f85271
--- /dev/null
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2013 - Scilab Enterprises
+ * 
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="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="ismatrix" xml:lang="en">
+    <refnamediv>
+        <refname>ismatrix</refname>
+        <refpurpose>check if a variable is a matrix</refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Calling Sequence</title>
+        <synopsis>t=ismatrix(x)</synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>x</term>
+                <listitem>
+                    <para>scalar,vector, matrix, hypermatrix, list, array of structures or cells</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>t</term>
+                <listitem>
+                    <para>a boolean</para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            <literal>ismatrix(<varname>x</varname>)</literal> returns true if <varname>x</varname>
+            is a matrix. Scalars and vectors are considered as matrix, and it is the same for
+            hypermatrix only if one of its three dimensions equals to 1. Note that <literal>matrix([])</literal>
+            returns false.
+        </para>
+    </refsection>
+    <refsection>
+        <title>Examples</title>
+        <programlisting role="example"><![CDATA[ 
+ismatrix(ones(10,5))
+ismatrix(1)
+ismatrix(["s" "t" "u"; "t" "s" "u"])
+ismatrix(rand(2,1,3)) //because of singleton
+ismatrix(rand(2,2,3)) //hypermatrix
+s = struct();
+ismatrix(s) // Empty structure
+clear s
+s(1,2).a = 3;
+s(1,3).b = %z;
+ismatrix(s) // Row array of structures
+clear s
+s(2,1).a = "w"; 
+s(3,1).b = %t;  
+iscolumn(s) // Column array of structures
+clear s
+s(1,2).a = -2;
+s(3,1).b = %pi;
+ismatrix(s) // 2D not-square array of structures
+clear s
+s(2,1,2).a = 3;
+s(1,1,2).b = "test";
+ismatrix(s) // 3D array of structures (with a singleton dim)
+clear s
+s(1,1,2).a = 3;
+s(1,1,3).b = "test";
+ismatrix(s) // 3D array of structures (with 2 singleton dims)
+clear s
+s(2,2,2).a = %f; 
+s(1,2,1).b = list(%e, %s);
+ismatrix(s) // 3D (cubic) array of structures
+ ]]></programlisting>
+    </refsection>
+    <refsection role="see also">
+        <title>See also</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="isscalar">isscalar</link>
+            </member>
+            <member>
+                <link linkend="isrow">isrow</link>
+            </member>
+            <member>
+                <link linkend="iscolumn">iscolumn</link>
+            </member>
+            <member>
+                <link linkend="issquare">issquare</link>
+            </member>
+            <member>
+                <link linkend="isempty">isempty</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Function ismatrix introduced.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
+</refentry>
diff --git a/scilab/modules/elementary_functions/help/en_US/isrow.xml b/scilab/modules/elementary_functions/help/en_US/isrow.xml
new file mode 100644 (file)
index 0000000..ac5145b
--- /dev/null
@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2013 - Scilab Enterprises
+ * 
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="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="isrow" xml:lang="en">
+    <refnamediv>
+        <refname>isrow</refname>
+        <refpurpose>check if a variable is a row</refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Calling Sequence</title>
+        <synopsis>t=isrow(x)</synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>x</term>
+                <listitem>
+                    <para>scalar,vector, matrix, hypermatrix, list, array of structures or cells</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>t</term>
+                <listitem>
+                    <para>a boolean</para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            <literal>isrow(<varname>x</varname>)</literal> returns true if <varname>x</varname>
+            is a row. Scalars are considered as rows, and hypermatrix can be considered as rows only if
+            all of its dimensions, except the last one, are equal to 1. Note that <literal>isrow([])</literal>
+            returns false.
+        </para>
+    </refsection>
+    <refsection>
+        <title>Examples</title>
+        <programlisting role="example"><![CDATA[ 
+isrow(ones(1,10))
+isrow(1)
+isrow(["s" "t" "u"])
+isrow(rand(1,1,3))
+isrow(rand(2,1,1))
+s = struct();
+isrow(s) // Empty structure
+clear s
+s.a = %z;
+s.b = 2;
+isrow(s) // Scalar array of structures
+clear s
+s(1,2).a = 3;
+s(1,3).b = %z;
+isrow(s) // Row array of structures
+clear s
+s(1,2).a = -2; 
+s(3,1).b = %pi;
+isrow(s) // 2D array of structures
+clear s
+s(1,1,2).a = 3;
+s(1,1,3).b = "test";
+isrow(s) // 3D array of structures (with 2 singleton dims)
+ ]]></programlisting>
+    </refsection>
+    <refsection role="see also">
+        <title>See also</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="isscalar">isscalar</link>
+            </member>
+            <member>
+                <link linkend="iscolumn">iscolumn</link>
+            </member>
+            <member>
+                <link linkend="ismatrix">ismatrix</link>
+            </member>
+            <member>
+                <link linkend="issquare">issquare</link>
+            </member>
+            <member>
+                <link linkend="isempty">isempty</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Function isrow introduced.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
+</refentry>
diff --git a/scilab/modules/elementary_functions/help/en_US/isscalar.xml b/scilab/modules/elementary_functions/help/en_US/isscalar.xml
new file mode 100644 (file)
index 0000000..3437fcf
--- /dev/null
@@ -0,0 +1,100 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2013 - Scilab Enterprises
+ * 
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="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="isscalar" xml:lang="en">
+    <refnamediv>
+        <refname>isscalar</refname>
+        <refpurpose>
+            check if a variable is a scalar.
+        </refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Calling Sequence</title>
+        <synopsis>t=isscalar(x)</synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>x</term>
+                <listitem>
+                    <para>scalar,vector, matrix, hypermatrix, list, array of structures or cells</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>t</term>
+                <listitem>
+                    <para>a boolean</para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            <literal>isscalar(<varname>x</varname>)</literal> returns true if <varname>x</varname>
+            is a scalar (if size(<varname>x</varname>) is 1). Note that <literal>isscalar([])</literal>
+            returns false.
+        </para>
+    </refsection>
+    <refsection>
+        <title>Examples</title>
+        <programlisting role="example"><![CDATA[ 
+isscalar(ones(10,10))
+isscalar(1)
+isscalar("s")
+s = struct();
+isscalar(s) // Empty structure
+clear s
+s.a = %z;
+s.b = 2;
+isscalar(s) // Scalar structure
+clear s
+s(1,2).a = 3;
+s(1,3).b = %z;
+isscalar(s) // Row array of structures
+clear s
+s(2,1).a = "w"; 
+s(3,1).b = %t;  
+isscalar(s) // Column array of structures
+ ]]></programlisting>
+    </refsection>
+    <refsection role= "see also">
+        <title>See also</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="ismatrix">ismatrix</link>
+            </member>
+            <member>
+                <link linkend="isrow">isrow</link>
+            </member>
+            <member>
+                <link linkend="iscolumn">iscolumn</link>
+            </member>
+            <member>
+                <link linkend="issquare">issquare</link>
+            </member>
+            <member>
+                <link linkend="isempty">isempty</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Function isscalar introduced.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
+</refentry>
diff --git a/scilab/modules/elementary_functions/help/en_US/issquare.xml b/scilab/modules/elementary_functions/help/en_US/issquare.xml
new file mode 100644 (file)
index 0000000..d259f4d
--- /dev/null
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2013 - Scilab Enterprises
+ * 
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="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="issquare" xml:lang="en">
+    <refnamediv>
+        <refname>issquare</refname>
+        <refpurpose>check if a variable is a square matrix</refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Calling Sequence</title>
+        <synopsis>t=issquare(x)</synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>x</term>
+                <listitem>
+                    <para>scalar,vector, matrix, hypermatrix, list, array of structures or cells</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>t</term>
+                <listitem>
+                    <para>a boolean</para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            <literal>issquare(<varname>x</varname>)</literal> returns true if <varname>x</varname>
+            is a square matrix (all dimensions of <varname>x</varname> are the same, with eventually singletons
+            if <varname>x</varname> is an hpermatrix). Note that <literal>issquare([])</literal>
+            returns false.
+        </para>
+    </refsection>
+    <refsection>
+        <title>Examples</title>
+        <programlisting role="example"><![CDATA[
+issquare(ones(10,10))
+issquare(1)
+issquare(["s" "t"; "t" "s"])
+issquare(rand(2,1,2))
+issquare(rand(2,2,3))
+s = struct();
+issquare(s) // Enmpty structure
+clear s
+s.a = %z;
+s.b = 2;
+issquare(s); // Scalar structure
+clear s
+s(1,2).a = 3;
+s(1,3).b = %z;
+issquare(s) // Row array of structures
+clear s
+s(2,1).a = "w"; 
+s(3,1).b = %t;  
+issquare(s) // Column array of structures
+clear s
+s(1,2).a = -2;
+s(3,1).b = %pi;
+issquare(s) // 2D not-square array of structures
+clear s
+s(2,2,2).a = %f; 
+s(1,2,1).b = list(%e, %s);
+issquare(s) // 3D (cubic) array of structures
+clear s
+s(2,1,2).a = 3;
+s(1,1,2).b = "test";
+issquare(s) // 3D array of structures (with a singleton dim)
+ ]]></programlisting>
+    </refsection>
+    <refsection role="see also">
+        <title>See also</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="isscalar">isscalar</link>
+            </member>
+            <member>
+                <link linkend="isrow">isrow</link>
+            </member>
+            <member>
+                <link linkend="iscolumn">iscolumn</link>
+            </member>
+            <member>
+                <link linkend="ismatrix">ismatrix</link>
+            </member>
+            <member>
+                <link linkend="isempty">isempty</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Function issquare introduced.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
+</refentry>
index 41b4bfb..bd291f2 100644 (file)
 
 function bOK = IsAScalar(VarInput)
 
-  rhs = argn(2);
-  if rhs <> 1 then
-    error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"IsAScalar", 1));
-  end
+    warnobsolete("isscalar", "5.5.1");
+    rhs = argn(2);
+    if rhs <> 1 then
+        error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"IsAScalar", 1));
+    end
 
-  bOK = %F;
-  if ( (length(VarInput)==1) & (type(VarInput)==1) ) then
-    bOK = %T;
-  end
+    bOK = %F;
+    if ( (length(VarInput)==1) & (type(VarInput)==1) ) then
+        bOK = %T;
+    end
 endfunction
 
diff --git a/scilab/modules/elementary_functions/macros/iscolumn.sci b/scilab/modules/elementary_functions/macros/iscolumn.sci
new file mode 100644 (file)
index 0000000..71badb6
--- /dev/null
@@ -0,0 +1,18 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Samuel Gougeon
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r = iscolumn(v)
+    rhs=argn(2);
+    if rhs<>1 then
+        error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"iscolumn", 1));
+    end
+    
+    s = size(v)
+    r = s(1)>=1 & length(find(s(2:$)>1))==0
+endfunction
diff --git a/scilab/modules/elementary_functions/macros/ismatrix.sci b/scilab/modules/elementary_functions/macros/ismatrix.sci
new file mode 100644 (file)
index 0000000..f67c556
--- /dev/null
@@ -0,0 +1,24 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Samuel Gougeon
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r = ismatrix(A)
+    rhs=argn(2);
+    if rhs<>1 then
+        error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"ismatrix", 1));
+    end
+    if type(A) == 15 then
+        r = size(A) <> 0;
+        return;
+    end
+    
+    s = size(squeeze(A))
+    s = length(s(s>0))
+    r = s>0 & s<3;
+    
+endfunction
diff --git a/scilab/modules/elementary_functions/macros/isrow.sci b/scilab/modules/elementary_functions/macros/isrow.sci
new file mode 100644 (file)
index 0000000..6ea1796
--- /dev/null
@@ -0,0 +1,19 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Samuel Gougeon
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r = isrow(v)
+    rhs=argn(2);
+    if rhs<>1 then
+        error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"isrow", 1));
+    end
+    
+    s = size(v)
+    s2 = s(find(s(2:$)>=1))
+    r = s(1)==1 & (length(s2)==1 | prod(s2)==1)
+endfunction
diff --git a/scilab/modules/elementary_functions/macros/isscalar.sci b/scilab/modules/elementary_functions/macros/isscalar.sci
new file mode 100644 (file)
index 0000000..76342f4
--- /dev/null
@@ -0,0 +1,22 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2005 - INRIA - Allan CORNET
+// Copyright (C) DIGITEO - 2011 - Allan CORNET
+// 
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function bOK = isscalar(VarInput)
+
+  rhs = argn(2);
+  if rhs <> 1 then
+    error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"isscalar", 1));
+  end
+
+  bOK = %F;
+  if size(VarInput)==1 then
+    bOK = %T;
+  end
+endfunction
diff --git a/scilab/modules/elementary_functions/macros/issquare.sci b/scilab/modules/elementary_functions/macros/issquare.sci
new file mode 100644 (file)
index 0000000..29472d7
--- /dev/null
@@ -0,0 +1,24 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Samuel Gougeon
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r = issquare(v)
+    rhs=argn(2);
+    if rhs<>1 then
+        error(msprintf(gettext("%s: Wrong number of input argument(s): %d expected.\n"),"issquare", 1));
+    end
+    if type(v) == 15 then
+        r = size(v) == 1;
+        return;
+    end
+
+    s = size(squeeze(v))
+    s = s(s>0)   // to reject [ ]
+    r = length(unique(s))==1;
+    
+endfunction
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/IsAScalar.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/IsAScalar.dia.ref
new file mode 100644 (file)
index 0000000..f304409
--- /dev/null
@@ -0,0 +1,68 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for IsAScalar function
+// =============================================================================
+// Constants
+assert_checkequal(IsAScalar([1 2 3]), %f);
+AVERTISSEMENT : La fonctionnalité IsAScalar est obsolète.
+AVERTISSEMENT : Veuillez utiliser isscalar à la place.
+AVERTISSEMENT : Cette fonctionnalité va être définitivement supprimée dans Scilab 5.5.1
+
+assert_checkequal(IsAScalar([1 2 3]'), %f);
+AVERTISSEMENT : La fonctionnalité IsAScalar est obsolète.
+AVERTISSEMENT : Veuillez utiliser isscalar à la place.
+AVERTISSEMENT : Cette fonctionnalité va être définitivement supprimée dans Scilab 5.5.1
+
+assert_checkequal(IsAScalar([1 2; 1 2]), %f);
+AVERTISSEMENT : La fonctionnalité IsAScalar est obsolète.
+AVERTISSEMENT : Veuillez utiliser isscalar à la place.
+AVERTISSEMENT : Cette fonctionnalité va être définitivement supprimée dans Scilab 5.5.1
+
+assert_checkequal(IsAScalar(1), %t);
+AVERTISSEMENT : La fonctionnalité IsAScalar est obsolète.
+AVERTISSEMENT : Veuillez utiliser isscalar à la place.
+AVERTISSEMENT : Cette fonctionnalité va être définitivement supprimée dans Scilab 5.5.1
+
+// Strings
+assert_checkequal(IsAScalar("s"), %f);
+AVERTISSEMENT : La fonctionnalité IsAScalar est obsolète.
+AVERTISSEMENT : Veuillez utiliser isscalar à la place.
+AVERTISSEMENT : Cette fonctionnalité va être définitivement supprimée dans Scilab 5.5.1
+
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(IsAScalar(1+s), %f);
+AVERTISSEMENT : La fonctionnalité IsAScalar est obsolète.
+AVERTISSEMENT : Veuillez utiliser isscalar à la place.
+AVERTISSEMENT : Cette fonctionnalité va être définitivement supprimée dans Scilab 5.5.1
+
+// Booleans
+assert_checkequal(IsAScalar(%t), %f);
+AVERTISSEMENT : La fonctionnalité IsAScalar est obsolète.
+AVERTISSEMENT : Veuillez utiliser isscalar à la place.
+AVERTISSEMENT : Cette fonctionnalité va être définitivement supprimée dans Scilab 5.5.1
+
+// Sparses
+assert_checkequal(IsAScalar(sparse(0)), %f);
+AVERTISSEMENT : La fonctionnalité IsAScalar est obsolète.
+AVERTISSEMENT : Veuillez utiliser isscalar à la place.
+AVERTISSEMENT : Cette fonctionnalité va être définitivement supprimée dans Scilab 5.5.1
+
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"IsAScalar", 1);
+assert_checkerror("IsAScalar()", errmsg1);
+AVERTISSEMENT : La fonctionnalité IsAScalar est obsolète.
+AVERTISSEMENT : Veuillez utiliser isscalar à la place.
+AVERTISSEMENT : Cette fonctionnalité va être définitivement supprimée dans Scilab 5.5.1
+
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("IsAScalar(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=IsAScalar([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/IsAScalar.tst b/scilab/modules/elementary_functions/tests/unit_tests/IsAScalar.tst
new file mode 100644 (file)
index 0000000..3aedf98
--- /dev/null
@@ -0,0 +1,38 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for IsAScalar function
+// =============================================================================
+
+// Constants
+assert_checkequal(IsAScalar([1 2 3]), %f);
+assert_checkequal(IsAScalar([1 2 3]'), %f);
+assert_checkequal(IsAScalar([1 2; 1 2]), %f);
+assert_checkequal(IsAScalar(1), %t);
+
+// Strings
+assert_checkequal(IsAScalar("s"), %f);
+
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(IsAScalar(1+s), %f);
+
+// Booleans
+assert_checkequal(IsAScalar(%t), %f);
+
+// Sparses
+assert_checkequal(IsAScalar(sparse(0)), %f);
+
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"IsAScalar", 1);
+assert_checkerror("IsAScalar()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("IsAScalar(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=IsAScalar([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/iscolumn.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/iscolumn.dia.ref
new file mode 100644 (file)
index 0000000..2d31050
--- /dev/null
@@ -0,0 +1,139 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for iscolumn function
+// =============================================================================
+// Constants
+assert_checkequal(iscolumn([1; 2; 3]), %t);
+assert_checkequal(iscolumn([1; 2; 3]'), %f);
+assert_checkequal(iscolumn([1 2 3; 1 2 3]), %f);
+assert_checkequal(iscolumn(1), %t);
+assert_checkequal(iscolumn(rand(3,1,1)), %t);
+assert_checkequal(iscolumn(rand(1,1,3)), %f);
+assert_checkequal(iscolumn([]), %f);
+// Strings
+assert_checkequal(iscolumn(["s"; "t"; "u"]), %t);
+assert_checkequal(iscolumn(["s"; "t"; "u"]'), %f);
+assert_checkequal(iscolumn(["s" "t" "u";"s" "t" "u"]), %f);
+assert_checkequal(iscolumn("s"), %t);
+assert_checkequal(iscolumn(hypermat([3,1,1],["s";"s";"s"])), %t);
+assert_checkequal(iscolumn(hypermat([1,1,3],["s";"s";"s"])), %f);
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(iscolumn([1+s; 2+s]), %t);
+assert_checkequal(iscolumn([1+s; 2+s]'), %f);
+assert_checkequal(iscolumn([1+s 2+s; 3+s 4+s]), %f);
+assert_checkequal(iscolumn(1+s), %t);
+assert_checkequal(iscolumn(hypermat([3,1,1],[s;s;s])), %t);
+assert_checkequal(iscolumn(hypermat([1,1,3],[s;s;s])), %f);
+// Booleans
+assert_checkequal(iscolumn([%t; %f]), %t);
+assert_checkequal(iscolumn([%t; %f]'), %f);
+assert_checkequal(iscolumn([%t %f; %f %t]), %f);
+assert_checkequal(iscolumn(%t), %t);
+assert_checkequal(iscolumn(hypermat([3,1,1],[%t;%t;%t])), %t);
+assert_checkequal(iscolumn(hypermat([1,1,3],[%t;%t;%t])), %f);
+// Sparses
+assert_checkequal(iscolumn(sparse([1; 0; 2])), %t);
+assert_checkequal(iscolumn(sparse([1; 0; 2])'), %f);
+assert_checkequal(iscolumn(sparse([1 0 2; 0 1 3])), %f);
+assert_checkequal(iscolumn(sparse(0)), %t);
+// Structures
+clear s;
+assert_checkequal(iscolumn(struct()), %f); // Empty structure
+s.a = "test";
+assert_checkequal(iscolumn(s), %t); // Scalar structure
+clear s;
+s(3,1).a = %pi;
+assert_checkequal(iscolumn(s), %t); // Column structure
+clear s;
+s(3,1,1).a = %pi;
+assert_checkequal(iscolumn(s), %t); // Column structure
+clear s;
+s(1,3).a = %e;
+assert_checkequal(iscolumn(s), %f); // Row structure
+clear s;
+s(3,2).a = %z;
+assert_checkequal(iscolumn(s), %f); // 2D structure array (not square)
+clear s;
+s(2,2,2).a = %s;
+assert_checkequal(iscolumn(s), %f); // 3D structure array (cube)
+clear s;
+s(2,1,2).a = %s;
+assert_checkequal(iscolumn(s), %f); // 3D structure array with singleton (square)
+// Cells
+assert_checkequal(iscolumn(cell()), %f); // Empty cell
+a = cell(1);
+a(1).entries = 1;
+assert_checkequal(iscolumn(a), %t); // Scalar case
+clear a;
+a = cell(1,3);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(iscolumn(a), %f); // Row case
+clear a;
+a = cell(3,1);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(iscolumn(a), %t); // Column case
+clear a;
+a = cell(3,2);
+a(1,1).entries = 1:3;
+a(1,2).entries = 1:3;
+a(2,1).entries = 1:3;
+a(2,2).entries = 1:3;
+a(3,2).entries = 1:3;
+a(3,1).entries = 1:3;
+assert_checkequal(iscolumn(a), %f); // Matrix case
+clear a;
+a = cell(2,2,2);
+a(1,1,1).entries =1:3;
+a(1,2,1).entries =1:3;
+a(2,1,1).entries =1:3;
+a(2,2,1).entries =1:3;
+a(1,1,2).entries =1:3;
+a(1,2,2).entries =1:3;
+a(2,1,2).entries =1:3;
+a(2,2,2).entries =1:3;
+assert_checkequal(iscolumn(a), %f); // Cubic case
+a = cell(2,1,2);
+a(1,1,1).entries=1:3;
+a(2,1,1).entries=1:3
+ a  =
+(:,:,1)
+![1,2,3]  !
+!         !
+![1,2,3]  !
+(:,:,2)
+!{}  !
+!    !
+!{}  !
+a(1,1,2).entries=1:3;
+a(2,1,2).entries=1:3;
+assert_checkequal(iscolumn(a), %f); // Hypermatrix with singleton (square)
+// Lists
+assert_checkequal(iscolumn(list()), %f); // Empty list
+l=list(1);
+assert_checkequal(iscolumn(l), %t); // Scalar case
+clear l;
+l=list(1,"test");
+assert_checkequal(iscolumn(l), %t); // Column case
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"iscolumn", 1);
+assert_checkerror("iscolumn()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("iscolumn(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=iscolumn([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/iscolumn.tst b/scilab/modules/elementary_functions/tests/unit_tests/iscolumn.tst
new file mode 100644 (file)
index 0000000..09f5de8
--- /dev/null
@@ -0,0 +1,135 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for iscolumn function
+// =============================================================================
+
+// Constants
+assert_checkequal(iscolumn([1; 2; 3]), %t);
+assert_checkequal(iscolumn([1; 2; 3]'), %f);
+assert_checkequal(iscolumn([1 2 3; 1 2 3]), %f);
+assert_checkequal(iscolumn(1), %t);
+assert_checkequal(iscolumn(rand(3,1,1)), %t);
+assert_checkequal(iscolumn(rand(1,1,3)), %f);
+assert_checkequal(iscolumn([]), %f);
+
+// Strings
+assert_checkequal(iscolumn(["s"; "t"; "u"]), %t);
+assert_checkequal(iscolumn(["s"; "t"; "u"]'), %f);
+assert_checkequal(iscolumn(["s" "t" "u";"s" "t" "u"]), %f);
+assert_checkequal(iscolumn("s"), %t);
+assert_checkequal(iscolumn(hypermat([3,1,1],["s";"s";"s"])), %t);
+assert_checkequal(iscolumn(hypermat([1,1,3],["s";"s";"s"])), %f);
+
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(iscolumn([1+s; 2+s]), %t);
+assert_checkequal(iscolumn([1+s; 2+s]'), %f);
+assert_checkequal(iscolumn([1+s 2+s; 3+s 4+s]), %f);
+assert_checkequal(iscolumn(1+s), %t);
+assert_checkequal(iscolumn(hypermat([3,1,1],[s;s;s])), %t);
+assert_checkequal(iscolumn(hypermat([1,1,3],[s;s;s])), %f);
+
+// Booleans
+assert_checkequal(iscolumn([%t; %f]), %t);
+assert_checkequal(iscolumn([%t; %f]'), %f);
+assert_checkequal(iscolumn([%t %f; %f %t]), %f);
+assert_checkequal(iscolumn(%t), %t);
+assert_checkequal(iscolumn(hypermat([3,1,1],[%t;%t;%t])), %t);
+assert_checkequal(iscolumn(hypermat([1,1,3],[%t;%t;%t])), %f);
+
+// Sparses
+assert_checkequal(iscolumn(sparse([1; 0; 2])), %t);
+assert_checkequal(iscolumn(sparse([1; 0; 2])'), %f);
+assert_checkequal(iscolumn(sparse([1 0 2; 0 1 3])), %f);
+assert_checkequal(iscolumn(sparse(0)), %t);
+
+// Structures
+clear s;
+assert_checkequal(iscolumn(struct()), %f); // Empty structure
+s.a = "test";
+assert_checkequal(iscolumn(s), %t); // Scalar structure
+clear s;
+s(3,1).a = %pi;
+assert_checkequal(iscolumn(s), %t); // Column structure
+clear s;
+s(3,1,1).a = %pi;
+assert_checkequal(iscolumn(s), %t); // Column structure
+clear s;
+s(1,3).a = %e;
+assert_checkequal(iscolumn(s), %f); // Row structure
+clear s;
+s(3,2).a = %z;
+assert_checkequal(iscolumn(s), %f); // 2D structure array (not square)
+clear s;
+s(2,2,2).a = %s;
+assert_checkequal(iscolumn(s), %f); // 3D structure array (cube)
+clear s;
+s(2,1,2).a = %s;
+assert_checkequal(iscolumn(s), %f); // 3D structure array with singleton (square)
+
+// Cells
+assert_checkequal(iscolumn(cell()), %f); // Empty cell
+a = cell(1);
+a(1).entries = 1;
+assert_checkequal(iscolumn(a), %t); // Scalar case
+clear a;
+a = cell(1,3);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(iscolumn(a), %f); // Row case
+clear a;
+a = cell(3,1);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(iscolumn(a), %t); // Column case
+clear a;
+a = cell(3,2);
+a(1,1).entries = 1:3;
+a(1,2).entries = 1:3;
+a(2,1).entries = 1:3;
+a(2,2).entries = 1:3;
+a(3,2).entries = 1:3;
+a(3,1).entries = 1:3;
+assert_checkequal(iscolumn(a), %f); // Matrix case
+clear a;
+a = cell(2,2,2);
+a(1,1,1).entries =1:3;
+a(1,2,1).entries =1:3;
+a(2,1,1).entries =1:3;
+a(2,2,1).entries =1:3;
+a(1,1,2).entries =1:3;
+a(1,2,2).entries =1:3;
+a(2,1,2).entries =1:3;
+a(2,2,2).entries =1:3;
+assert_checkequal(iscolumn(a), %f); // Cubic case
+a = cell(2,1,2);
+a(1,1,1).entries=1:3;
+a(2,1,1).entries=1:3
+a(1,1,2).entries=1:3;
+a(2,1,2).entries=1:3;
+assert_checkequal(iscolumn(a), %f); // Hypermatrix with singleton (square)
+
+// Lists
+assert_checkequal(iscolumn(list()), %f); // Empty list
+l=list(1);
+assert_checkequal(iscolumn(l), %t); // Scalar case
+clear l;
+l=list(1,"test");
+assert_checkequal(iscolumn(l), %t); // Column case
+
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"iscolumn", 1);
+assert_checkerror("iscolumn()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("iscolumn(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=iscolumn([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/ismatrix.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/ismatrix.dia.ref
new file mode 100644 (file)
index 0000000..88616c2
--- /dev/null
@@ -0,0 +1,139 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for ismatrix function
+// =============================================================================
+// Constants
+assert_checkequal(ismatrix([1 2 3]), %t);
+assert_checkequal(ismatrix([1 2 3]'), %t);
+assert_checkequal(ismatrix([1 2 3; 1 2 3]), %t);
+assert_checkequal(ismatrix(1), %t);
+assert_checkequal(ismatrix(rand(2,3,2)), %f);
+assert_checkequal(ismatrix(rand(2,1,3)), %t);
+assert_checkequal(ismatrix([]), %f);
+// Strings
+assert_checkequal(ismatrix(["s" "t" "u"]), %t);
+assert_checkequal(ismatrix(["s" "t" "u"]'), %t);
+assert_checkequal(ismatrix(["s" "t" "u";"s" "t" "u"]), %t);
+assert_checkequal(ismatrix("s"), %t);
+assert_checkequal(ismatrix(hypermat([2,2,2],["s";"s";"s";"s";"s";"s";"s";"s"])), %f);
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(ismatrix([1+s 2+s]), %t);
+assert_checkequal(ismatrix([1+s 2+s]'), %t);
+assert_checkequal(ismatrix([1+s 2+s 3+s; 3+s 4+s 5+s]), %t);
+assert_checkequal(ismatrix(1+s), %t);
+assert_checkequal(ismatrix(hypermat([2,2,2],[s;s;s;s;s;s;s;s;])), %f);
+// Booleans
+assert_checkequal(ismatrix([%t %f]), %t);
+assert_checkequal(ismatrix([%t %f]'), %t);
+assert_checkequal(ismatrix([%t %f %t; %f %t %f]), %t);
+assert_checkequal(ismatrix(%t), %t);
+assert_checkequal(ismatrix(hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t])), %f);
+// Sparses
+assert_checkequal(ismatrix(sparse([1 0 2])), %t);
+assert_checkequal(ismatrix(sparse([1 0 2])'), %t);
+assert_checkequal(ismatrix(sparse([1 0 3; 2 0 1])), %t);
+assert_checkequal(ismatrix(sparse(0)), %t);
+// Structures
+clear s;
+assert_checkequal(ismatrix(struct()), %f); // Empty structure
+s.a = "test";
+assert_checkequal(ismatrix(s), %t); // Scalar structure
+clear s;
+s(3,1).a = %pi;
+assert_checkequal(ismatrix(s), %t); // Column structure
+clear s;
+s(3,1,1).a = %pi;
+assert_checkequal(ismatrix(s), %t); // Column structure
+clear s;
+s(1,3).a = %e;
+assert_checkequal(ismatrix(s), %t); // Row structure
+clear s;
+s(1,1,3).a = %e;
+assert_checkequal(ismatrix(s), %t); // Row structure
+clear s;
+s(3,2).a = %z;
+assert_checkequal(ismatrix(s), %t); // 2D structure array (not square)
+clear s;
+s(2,2,2).a = %s;
+assert_checkequal(ismatrix(s), %f); // 3D structure array (cube)
+clear s;
+s(2,1,2).a = %s;
+assert_checkequal(ismatrix(s), %t); // 3D structure array with singleton
+// Cells
+assert_checkequal(ismatrix(cell()), %f); // Empty cell
+a = cell(1);
+a(1).entries = 1;
+assert_checkequal(ismatrix(a), %t); // Scalar case
+clear a;
+a = cell(1,3);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(ismatrix(a), %t); // Row case
+clear a;
+a = cell(3,1);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(ismatrix(a), %t); // Column case
+clear a;
+a = cell(3,2);
+a(1,1).entries = 1:3;
+a(1,2).entries = 1:3;
+a(2,1).entries = 1:3;
+a(2,2).entries = 1:3;
+a(3,2).entries = 1:3;
+a(3,1).entries = 1:3;
+assert_checkequal(ismatrix(a), %t); // Matrix case
+clear a;
+a = cell(2,2,2);
+a(1,1,1).entries =1:3;
+a(1,2,1).entries =1:3;
+a(2,1,1).entries =1:3;
+a(2,2,1).entries =1:3;
+a(1,1,2).entries =1:3;
+a(1,2,2).entries =1:3;
+a(2,1,2).entries =1:3;
+a(2,2,2).entries =1:3;
+assert_checkequal(ismatrix(a), %f); // Cubic case
+a = cell(2,1,2);
+a(1,1,1).entries=1:3;
+a(2,1,1).entries=1:3
+ a  =
+(:,:,1)
+![1,2,3]  !
+!         !
+![1,2,3]  !
+(:,:,2)
+!{}  !
+!    !
+!{}  !
+a(1,1,2).entries=1:3;
+a(2,1,2).entries=1:3;
+assert_checkequal(ismatrix(a), %t); // Hypermatrix with singleton (square)
+// Lists
+assert_checkequal(ismatrix(list()), %f); // Empty list
+l=list(1);
+assert_checkequal(ismatrix(l), %t); // Scalar case
+clear l;
+l=list(1,"test");
+assert_checkequal(ismatrix(l), %t); // Column case
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"ismatrix", 1);
+assert_checkerror("ismatrix()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("ismatrix(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=ismatrix([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/ismatrix.tst b/scilab/modules/elementary_functions/tests/unit_tests/ismatrix.tst
new file mode 100644 (file)
index 0000000..b9a3e2a
--- /dev/null
@@ -0,0 +1,135 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for ismatrix function
+// =============================================================================
+
+// Constants
+assert_checkequal(ismatrix([1 2 3]), %t);
+assert_checkequal(ismatrix([1 2 3]'), %t);
+assert_checkequal(ismatrix([1 2 3; 1 2 3]), %t);
+assert_checkequal(ismatrix(1), %t);
+assert_checkequal(ismatrix(rand(2,3,2)), %f);
+assert_checkequal(ismatrix(rand(2,1,3)), %t);
+assert_checkequal(ismatrix([]), %f);
+
+// Strings
+assert_checkequal(ismatrix(["s" "t" "u"]), %t);
+assert_checkequal(ismatrix(["s" "t" "u"]'), %t);
+assert_checkequal(ismatrix(["s" "t" "u";"s" "t" "u"]), %t);
+assert_checkequal(ismatrix("s"), %t);
+assert_checkequal(ismatrix(hypermat([2,2,2],["s";"s";"s";"s";"s";"s";"s";"s"])), %f);
+
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(ismatrix([1+s 2+s]), %t);
+assert_checkequal(ismatrix([1+s 2+s]'), %t);
+assert_checkequal(ismatrix([1+s 2+s 3+s; 3+s 4+s 5+s]), %t);
+assert_checkequal(ismatrix(1+s), %t);
+assert_checkequal(ismatrix(hypermat([2,2,2],[s;s;s;s;s;s;s;s;])), %f);
+
+// Booleans
+assert_checkequal(ismatrix([%t %f]), %t);
+assert_checkequal(ismatrix([%t %f]'), %t);
+assert_checkequal(ismatrix([%t %f %t; %f %t %f]), %t);
+assert_checkequal(ismatrix(%t), %t);
+assert_checkequal(ismatrix(hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t])), %f);
+
+// Sparses
+assert_checkequal(ismatrix(sparse([1 0 2])), %t);
+assert_checkequal(ismatrix(sparse([1 0 2])'), %t);
+assert_checkequal(ismatrix(sparse([1 0 3; 2 0 1])), %t);
+assert_checkequal(ismatrix(sparse(0)), %t);
+
+// Structures
+clear s;
+assert_checkequal(ismatrix(struct()), %f); // Empty structure
+s.a = "test";
+assert_checkequal(ismatrix(s), %t); // Scalar structure
+clear s;
+s(3,1).a = %pi;
+assert_checkequal(ismatrix(s), %t); // Column structure
+clear s;
+s(3,1,1).a = %pi;
+assert_checkequal(ismatrix(s), %t); // Column structure
+clear s;
+s(1,3).a = %e;
+assert_checkequal(ismatrix(s), %t); // Row structure
+clear s;
+s(1,1,3).a = %e;
+assert_checkequal(ismatrix(s), %t); // Row structure
+clear s;
+s(3,2).a = %z;
+assert_checkequal(ismatrix(s), %t); // 2D structure array (not square)
+clear s;
+s(2,2,2).a = %s;
+assert_checkequal(ismatrix(s), %f); // 3D structure array (cube)
+clear s;
+s(2,1,2).a = %s;
+assert_checkequal(ismatrix(s), %t); // 3D structure array with singleton
+
+// Cells
+assert_checkequal(ismatrix(cell()), %f); // Empty cell
+a = cell(1);
+a(1).entries = 1;
+assert_checkequal(ismatrix(a), %t); // Scalar case
+clear a;
+a = cell(1,3);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(ismatrix(a), %t); // Row case
+clear a;
+a = cell(3,1);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(ismatrix(a), %t); // Column case
+clear a;
+a = cell(3,2);
+a(1,1).entries = 1:3;
+a(1,2).entries = 1:3;
+a(2,1).entries = 1:3;
+a(2,2).entries = 1:3;
+a(3,2).entries = 1:3;
+a(3,1).entries = 1:3;
+assert_checkequal(ismatrix(a), %t); // Matrix case
+clear a;
+a = cell(2,2,2);
+a(1,1,1).entries =1:3;
+a(1,2,1).entries =1:3;
+a(2,1,1).entries =1:3;
+a(2,2,1).entries =1:3;
+a(1,1,2).entries =1:3;
+a(1,2,2).entries =1:3;
+a(2,1,2).entries =1:3;
+a(2,2,2).entries =1:3;
+assert_checkequal(ismatrix(a), %f); // Cubic case
+a = cell(2,1,2);
+a(1,1,1).entries=1:3;
+a(2,1,1).entries=1:3
+a(1,1,2).entries=1:3;
+a(2,1,2).entries=1:3;
+assert_checkequal(ismatrix(a), %t); // Hypermatrix with singleton (square)
+
+// Lists
+assert_checkequal(ismatrix(list()), %f); // Empty list
+l=list(1);
+assert_checkequal(ismatrix(l), %t); // Scalar case
+clear l;
+l=list(1,"test");
+assert_checkequal(ismatrix(l), %t); // Column case
+
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"ismatrix", 1);
+assert_checkerror("ismatrix()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("ismatrix(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=ismatrix([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/isrow.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/isrow.dia.ref
new file mode 100644 (file)
index 0000000..dbe1b1d
--- /dev/null
@@ -0,0 +1,139 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for isrow function
+// =============================================================================
+// Constants
+assert_checkequal(isrow([1 2 3]), %t);
+assert_checkequal(isrow([1 2 3]'), %f);
+assert_checkequal(isrow([1 2 3; 1 2 3]), %f);
+assert_checkequal(isrow(1), %t);
+assert_checkequal(isrow(rand(1,1,3)), %t);
+assert_checkequal(isrow(rand(2,1,1)), %f);
+assert_checkequal(isrow([]), %f);
+// Strings
+assert_checkequal(isrow(["s" "t" "u"]), %t);
+assert_checkequal(isrow(["s" "t" "u"]'), %f);
+assert_checkequal(isrow(["s" "t" "u";"s" "t" "u"]), %f);
+assert_checkequal(isrow("s"), %t);
+assert_checkequal(isrow(hypermat([1,1,3],["s";"s";"s"])), %t);
+assert_checkequal(isrow(hypermat([2,1,1],["s";"s"])), %f);
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(isrow([1+s 2+s]), %t);
+assert_checkequal(isrow([1+s 2+s]'), %f);
+assert_checkequal(isrow([1+s 2+s; 3+s 4+s]), %f);
+assert_checkequal(isrow(1+s), %t);
+assert_checkequal(isrow(hypermat([1,1,3],[s;s;s])), %t);
+assert_checkequal(isrow(hypermat([2,1,1],[s;s])), %f);
+// Booleans
+assert_checkequal(isrow([%t %f]), %t);
+assert_checkequal(isrow([%t %f]'), %f);
+assert_checkequal(isrow([%t %f; %f %t]), %f);
+assert_checkequal(isrow(%t), %t);
+assert_checkequal(isrow(hypermat([1,1,3],[%t;%t;%t])), %t);
+assert_checkequal(isrow(hypermat([2,1,1],[%t;%t])), %f);
+// Sparses
+assert_checkequal(isrow(sparse([1 0 2])), %t);
+assert_checkequal(isrow(sparse([1 0 2])'), %f);
+assert_checkequal(isrow(sparse([1 0 2; 0 1 3])), %f);
+assert_checkequal(isrow(sparse(0)), %t);
+// Structures
+clear s;
+assert_checkequal(isrow(struct()), %f); // Empty structure
+s.a = "test";
+assert_checkequal(isrow(s), %t); // Scalar structure
+clear s;
+s(3,1).a = %pi;
+assert_checkequal(isrow(s), %f); // Column structure
+clear s;
+s(1,3).a = %e;
+assert_checkequal(isrow(s), %t); // Row structure
+clear s;
+s(1,1,3).a = %pi;
+assert_checkequal(issquare(s), %f); // Row structure
+clear s;
+s(3,2).a = %z;
+assert_checkequal(isrow(s), %f); // 2D structure array (not square)
+clear s;
+s(2,2,2).a = %s;
+assert_checkequal(isrow(s), %f); // 3D structure array (cube)
+clear s;
+s(2,1,2).a = %s;
+assert_checkequal(isrow(s), %f); // 3D structure array with singleton (square)
+// Cells
+assert_checkequal(isrow(cell()), %f); // Empty cell
+a = cell(1);
+a(1).entries = 1;
+assert_checkequal(isrow(a), %t); // Scalar case
+clear a;
+a = cell(1,3);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(isrow(a), %t); // Row case
+clear a;
+a = cell(3,1);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(isrow(a), %f); // Column case
+clear a;
+a = cell(3,2);
+a(1,1).entries = 1:3;
+a(1,2).entries = 1:3;
+a(2,1).entries = 1:3;
+a(2,2).entries = 1:3;
+a(3,2).entries = 1:3;
+a(3,1).entries = 1:3;
+assert_checkequal(isrow(a), %f); // Matrix case
+clear a;
+a = cell(2,2,2);
+a(1,1,1).entries =1:3;
+a(1,2,1).entries =1:3;
+a(2,1,1).entries =1:3;
+a(2,2,1).entries =1:3;
+a(1,1,2).entries =1:3;
+a(1,2,2).entries =1:3;
+a(2,1,2).entries =1:3;
+a(2,2,2).entries =1:3;
+assert_checkequal(isrow(a), %f); // Cubic case
+a = cell(2,1,2);
+a(1,1,1).entries=1:3;
+a(2,1,1).entries=1:3
+ a  =
+(:,:,1)
+![1,2,3]  !
+!         !
+![1,2,3]  !
+(:,:,2)
+!{}  !
+!    !
+!{}  !
+a(1,1,2).entries=1:3;
+a(2,1,2).entries=1:3;
+assert_checkequal(isrow(a), %f); // Hypermatrix with singleton (square)
+// Lists
+assert_checkequal(isrow(list()), %f); // Empty list
+l=list(1);
+assert_checkequal(isrow(l), %t); // Scalar case
+clear l;
+l=list(1,"test");
+assert_checkequal(isrow(l), %f); // Column case
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"isrow", 1);
+assert_checkerror("isrow()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("isrow(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=isrow([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/isrow.tst b/scilab/modules/elementary_functions/tests/unit_tests/isrow.tst
new file mode 100644 (file)
index 0000000..aebabc5
--- /dev/null
@@ -0,0 +1,135 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for isrow function
+// =============================================================================
+
+// Constants
+assert_checkequal(isrow([1 2 3]), %t);
+assert_checkequal(isrow([1 2 3]'), %f);
+assert_checkequal(isrow([1 2 3; 1 2 3]), %f);
+assert_checkequal(isrow(1), %t);
+assert_checkequal(isrow(rand(1,1,3)), %t);
+assert_checkequal(isrow(rand(2,1,1)), %f);
+assert_checkequal(isrow([]), %f);
+
+// Strings
+assert_checkequal(isrow(["s" "t" "u"]), %t);
+assert_checkequal(isrow(["s" "t" "u"]'), %f);
+assert_checkequal(isrow(["s" "t" "u";"s" "t" "u"]), %f);
+assert_checkequal(isrow("s"), %t);
+assert_checkequal(isrow(hypermat([1,1,3],["s";"s";"s"])), %t);
+assert_checkequal(isrow(hypermat([2,1,1],["s";"s"])), %f);
+
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(isrow([1+s 2+s]), %t);
+assert_checkequal(isrow([1+s 2+s]'), %f);
+assert_checkequal(isrow([1+s 2+s; 3+s 4+s]), %f);
+assert_checkequal(isrow(1+s), %t);
+assert_checkequal(isrow(hypermat([1,1,3],[s;s;s])), %t);
+assert_checkequal(isrow(hypermat([2,1,1],[s;s])), %f);
+
+// Booleans
+assert_checkequal(isrow([%t %f]), %t);
+assert_checkequal(isrow([%t %f]'), %f);
+assert_checkequal(isrow([%t %f; %f %t]), %f);
+assert_checkequal(isrow(%t), %t);
+assert_checkequal(isrow(hypermat([1,1,3],[%t;%t;%t])), %t);
+assert_checkequal(isrow(hypermat([2,1,1],[%t;%t])), %f);
+
+// Sparses
+assert_checkequal(isrow(sparse([1 0 2])), %t);
+assert_checkequal(isrow(sparse([1 0 2])'), %f);
+assert_checkequal(isrow(sparse([1 0 2; 0 1 3])), %f);
+assert_checkequal(isrow(sparse(0)), %t);
+
+// Structures
+clear s;
+assert_checkequal(isrow(struct()), %f); // Empty structure
+s.a = "test";
+assert_checkequal(isrow(s), %t); // Scalar structure
+clear s;
+s(3,1).a = %pi;
+assert_checkequal(isrow(s), %f); // Column structure
+clear s;
+s(1,3).a = %e;
+assert_checkequal(isrow(s), %t); // Row structure
+clear s;
+s(1,1,3).a = %pi;
+assert_checkequal(issquare(s), %f); // Row structure
+clear s;
+s(3,2).a = %z;
+assert_checkequal(isrow(s), %f); // 2D structure array (not square)
+clear s;
+s(2,2,2).a = %s;
+assert_checkequal(isrow(s), %f); // 3D structure array (cube)
+clear s;
+s(2,1,2).a = %s;
+assert_checkequal(isrow(s), %f); // 3D structure array with singleton (square)
+
+// Cells
+assert_checkequal(isrow(cell()), %f); // Empty cell
+a = cell(1);
+a(1).entries = 1;
+assert_checkequal(isrow(a), %t); // Scalar case
+clear a;
+a = cell(1,3);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(isrow(a), %t); // Row case
+clear a;
+a = cell(3,1);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(isrow(a), %f); // Column case
+clear a;
+a = cell(3,2);
+a(1,1).entries = 1:3;
+a(1,2).entries = 1:3;
+a(2,1).entries = 1:3;
+a(2,2).entries = 1:3;
+a(3,2).entries = 1:3;
+a(3,1).entries = 1:3;
+assert_checkequal(isrow(a), %f); // Matrix case
+clear a;
+a = cell(2,2,2);
+a(1,1,1).entries =1:3;
+a(1,2,1).entries =1:3;
+a(2,1,1).entries =1:3;
+a(2,2,1).entries =1:3;
+a(1,1,2).entries =1:3;
+a(1,2,2).entries =1:3;
+a(2,1,2).entries =1:3;
+a(2,2,2).entries =1:3;
+assert_checkequal(isrow(a), %f); // Cubic case
+a = cell(2,1,2);
+a(1,1,1).entries=1:3;
+a(2,1,1).entries=1:3
+a(1,1,2).entries=1:3;
+a(2,1,2).entries=1:3;
+assert_checkequal(isrow(a), %f); // Hypermatrix with singleton (square)
+
+// Lists
+assert_checkequal(isrow(list()), %f); // Empty list
+l=list(1);
+assert_checkequal(isrow(l), %t); // Scalar case
+clear l;
+l=list(1,"test");
+assert_checkequal(isrow(l), %f); // Column case
+
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"isrow", 1);
+assert_checkerror("isrow()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("isrow(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=isrow([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/isscalar.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/isscalar.dia.ref
new file mode 100644 (file)
index 0000000..fd5ef1f
--- /dev/null
@@ -0,0 +1,107 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for isscalar function
+// =============================================================================
+// Constants
+assert_checkequal(isscalar([1 2 3]), %f);
+assert_checkequal(isscalar([1 2 3]'), %f);
+assert_checkequal(isscalar([1 2; 1 2]), %f);
+assert_checkequal(isscalar(1), %t);
+assert_checkequal(isscalar([]), %f);
+// Strings
+assert_checkequal(isscalar(["s" "s"; "s" "s"]), %f);
+assert_checkequal(isscalar("s"), %t);
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(isscalar([s s; s s]), %f);
+assert_checkequal(isscalar(1+s), %t);
+// Booleans
+assert_checkequal(isscalar([%t %t; %t %t]), %f);
+assert_checkequal(isscalar(%t), %t);
+// Sparses
+assert_checkequal(isscalar(sparse([1 2; 1 2])), %f);
+assert_checkequal(isscalar(sparse(0)), %t);
+// Structures
+clear s;
+assert_checkequal(isscalar(struct()), %f); // Empty structure
+s(1,1).a = "test";
+assert_checkequal(isscalar(s), %t); // Scalar structure
+clear s;
+s(3,1).a = %pi;
+assert_checkequal(isscalar(s), %f); // Column structure
+clear s;
+s(1,3).a = %e;
+assert_checkequal(isscalar(s), %f); // Row structure
+clear s;
+s(3,2).a = %z;
+assert_checkequal(isscalar(s), %f); // 2D structure array (not square)
+clear s;
+s(2,2,2).a = %s;
+assert_checkequal(isscalar(s), %f); // 3D structure array (cube)
+clear s;
+s(2,1,2).a = %s;
+assert_checkequal(isscalar(s), %f); // 3D structure array with singleton (square)
+// Cells
+assert_checkequal(isscalar(cell()), %f); // Empty cell
+a = cell(1);
+a(1).entries = 1;
+assert_checkequal(isscalar(a), %t); // Scalar case
+clear a;
+a = cell(1,3);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(isscalar(a), %f); // Row case
+clear a;
+a = cell(3,1);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(isscalar(a), %f); // Column case
+clear a;
+a = cell(3,2);
+a(1,1).entries = 1:3;
+a(1,2).entries = 1:3;
+a(2,1).entries = 1:3;
+a(2,2).entries = 1:3;
+a(3,2).entries = 1:3;
+a(3,1).entries = 1:3;
+assert_checkequal(isscalar(a), %f); // Matrix case
+clear a;
+a = cell(2,2,2);
+a(1,1,1).entries =1:3;
+a(1,2,1).entries =1:3;
+a(2,1,1).entries =1:3;
+a(2,2,1).entries =1:3;
+a(1,1,2).entries =1:3;
+a(1,2,2).entries =1:3;
+a(2,1,2).entries =1:3;
+a(2,2,2).entries =1:3;
+assert_checkequal(isscalar(a), %f); // Cubic case
+a = cell(2,1,2);
+a(1,1,1).entries=1:3;
+a(2,1,1).entries=1:3;
+a(1,1,2).entries=1:3;
+a(2,1,2).entries=1:3;
+assert_checkequal(isscalar(a), %f); // Hypermatrix with singleton (square)
+// Lists
+assert_checkequal(isscalar(list()), %f); // Empty list
+l=list(1);
+assert_checkequal(isscalar(l), %t); // Scalar case
+clear l;
+l=list(1,"test");
+assert_checkequal(isscalar(l), %f); // Column case
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"isscalar", 1);
+assert_checkerror("isscalar()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("isscalar(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=isscalar([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/isscalar.tst b/scilab/modules/elementary_functions/tests/unit_tests/isscalar.tst
new file mode 100644 (file)
index 0000000..4c358cd
--- /dev/null
@@ -0,0 +1,116 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for isscalar function
+// =============================================================================
+
+// Constants
+assert_checkequal(isscalar([1 2 3]), %f);
+assert_checkequal(isscalar([1 2 3]'), %f);
+assert_checkequal(isscalar([1 2; 1 2]), %f);
+assert_checkequal(isscalar(1), %t);
+assert_checkequal(isscalar([]), %f);
+
+// Strings
+assert_checkequal(isscalar(["s" "s"; "s" "s"]), %f);
+assert_checkequal(isscalar("s"), %t);
+
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(isscalar([s s; s s]), %f);
+assert_checkequal(isscalar(1+s), %t);
+
+// Booleans
+assert_checkequal(isscalar([%t %t; %t %t]), %f);
+assert_checkequal(isscalar(%t), %t);
+
+// Sparses
+assert_checkequal(isscalar(sparse([1 2; 1 2])), %f);
+assert_checkequal(isscalar(sparse(0)), %t);
+
+// Structures
+clear s;
+assert_checkequal(isscalar(struct()), %f); // Empty structure
+s(1,1).a = "test";
+assert_checkequal(isscalar(s), %t); // Scalar structure
+clear s;
+s(3,1).a = %pi;
+assert_checkequal(isscalar(s), %f); // Column structure
+clear s;
+s(1,3).a = %e;
+assert_checkequal(isscalar(s), %f); // Row structure
+clear s;
+s(3,2).a = %z;
+assert_checkequal(isscalar(s), %f); // 2D structure array (not square)
+clear s;
+s(2,2,2).a = %s;
+assert_checkequal(isscalar(s), %f); // 3D structure array (cube)
+clear s;
+s(2,1,2).a = %s;
+assert_checkequal(isscalar(s), %f); // 3D structure array with singleton (square)
+
+// Cells
+assert_checkequal(isscalar(cell()), %f); // Empty cell
+a = cell(1);
+a(1).entries = 1;
+assert_checkequal(isscalar(a), %t); // Scalar case
+clear a;
+a = cell(1,3);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(isscalar(a), %f); // Row case
+clear a;
+a = cell(3,1);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(isscalar(a), %f); // Column case
+clear a;
+a = cell(3,2);
+a(1,1).entries = 1:3;
+a(1,2).entries = 1:3;
+a(2,1).entries = 1:3;
+a(2,2).entries = 1:3;
+a(3,2).entries = 1:3;
+a(3,1).entries = 1:3;
+assert_checkequal(isscalar(a), %f); // Matrix case
+clear a;
+a = cell(2,2,2);
+a(1,1,1).entries =1:3;
+a(1,2,1).entries =1:3;
+a(2,1,1).entries =1:3;
+a(2,2,1).entries =1:3;
+a(1,1,2).entries =1:3;
+a(1,2,2).entries =1:3;
+a(2,1,2).entries =1:3;
+a(2,2,2).entries =1:3;
+assert_checkequal(isscalar(a), %f); // Cubic case
+a = cell(2,1,2);
+a(1,1,1).entries=1:3;
+a(2,1,1).entries=1:3;
+a(1,1,2).entries=1:3;
+a(2,1,2).entries=1:3;
+assert_checkequal(isscalar(a), %f); // Hypermatrix with singleton (square)
+
+// Lists
+assert_checkequal(isscalar(list()), %f); // Empty list
+l=list(1);
+assert_checkequal(isscalar(l), %t); // Scalar case
+clear l;
+l=list(1,"test");
+assert_checkequal(isscalar(l), %f); // Column case
+
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"isscalar", 1);
+assert_checkerror("isscalar()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("isscalar(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=isscalar([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/issquare.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/issquare.dia.ref
new file mode 100644 (file)
index 0000000..3a46c61
--- /dev/null
@@ -0,0 +1,139 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for issquare function
+// =============================================================================
+// Constants
+assert_checkequal(issquare([1 2 3]), %f);
+assert_checkequal(issquare([1 2 3]'), %f);
+assert_checkequal(issquare([1 2; 1 2]), %t);
+assert_checkequal(issquare(1), %t);
+assert_checkequal(issquare(rand(2,1,2)), %t);
+assert_checkequal(issquare(rand(2,2,3)), %f);
+assert_checkequal(issquare([]), %f);
+// Strings
+assert_checkequal(issquare(["s" "t" "u"]), %f);
+assert_checkequal(issquare(["s" "t" "u"]'), %f);
+assert_checkequal(issquare(["s" "t";"s" "t"]), %t);
+assert_checkequal(issquare("s"), %t);
+assert_checkequal(issquare(hypermat([2,1,2],["s";"s";"s";"s"])), %t);
+assert_checkequal(issquare(hypermat([2,2,3],["t";"t";"t";"t";"t";"t";"t";"t";"t";"t";"t";"t"])), %f);
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(issquare([1+s 2+s]), %f);
+assert_checkequal(issquare([1+s 2+s]'), %f);
+assert_checkequal(issquare([1+s 2+s; 3+s 4+s]), %t);
+assert_checkequal(issquare(1+s), %t);
+assert_checkequal(issquare(hypermat([2,1,2],[s;s;s;s])), %t);
+assert_checkequal(issquare(hypermat([2,2,3],[s;s;s;s;s;s;s;s;s;s;s;s])), %f);
+// Booleans
+assert_checkequal(issquare([%t %f]), %f);
+assert_checkequal(issquare([%t %f]'), %f);
+assert_checkequal(issquare([%t %f; %f %t]), %t);
+assert_checkequal(issquare(%t), %t);
+assert_checkequal(issquare(hypermat([2,1,2],[%t;%t;%t;%t])), %t);
+assert_checkequal(issquare(hypermat([2,2,3],[%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t])), %f)
+ ans  =
+  T  
+// Sparses
+assert_checkequal(issquare(sparse([1 0 2])), %f);
+assert_checkequal(issquare(sparse([1 0 2])'), %f);
+assert_checkequal(issquare(sparse([1 0; 0 1])), %t);
+assert_checkequal(issquare(sparse(0)), %t);
+// Structures
+clear s;
+assert_checkequal(issquare(struct()), %f); // Empty structure
+s.a = "test";
+assert_checkequal(issquare(s), %t); // Scalar structure
+clear s;
+s(3,1).a = %pi;
+assert_checkequal(issquare(s), %f); // Column structure
+clear s;
+s(1,3).a = %pi;
+assert_checkequal(issquare(s), %f); // Row structure
+clear s;
+s(3,2).a = %z;
+assert_checkequal(issquare(s), %f); // 2D structure array (not square)
+clear s;
+s(2,2,2).a = %s;
+assert_checkequal(issquare(s), %t); // 3D structure array (cube)
+clear s;
+s(2,1,2).a = %s;
+assert_checkequal(issquare(s), %t); // 3D structure array with singleton (square)
+// Cells
+assert_checkequal(issquare(cell()), %f); // Empty cell
+a = cell(1);
+a(1).entries = 1;
+assert_checkequal(issquare(a), %t); // Scalar case
+clear a;
+a = cell(1,3);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(issquare(a), %f); // Row case
+clear a;
+a = cell(3,1);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(issquare(a), %f); // Column case
+clear a;
+a = cell(3,2);
+a(1,1).entries = 1:3;
+a(1,2).entries = 1:3;
+a(2,1).entries = 1:3;
+a(2,2).entries = 1:3;
+a(3,2).entries = 1:3;
+a(3,1).entries = 1:3;
+assert_checkequal(issquare(a), %f); // Matrix case
+clear a;
+a = cell(2,2,2);
+a(1,1,1).entries =1:3;
+a(1,2,1).entries =1:3;
+a(2,1,1).entries =1:3;
+a(2,2,1).entries =1:3;
+a(1,1,2).entries =1:3;
+a(1,2,2).entries =1:3;
+a(2,1,2).entries =1:3;
+a(2,2,2).entries =1:3;
+assert_checkequal(issquare(a), %t); // Cubic case
+a = cell(2,1,2);
+a(1,1,1).entries=1:3;
+a(2,1,1).entries=1:3
+ a  =
+(:,:,1)
+![1,2,3]  !
+!         !
+![1,2,3]  !
+(:,:,2)
+!{}  !
+!    !
+!{}  !
+a(1,1,2).entries=1:3;
+a(2,1,2).entries=1:3;
+assert_checkequal(issquare(a), %t); // Hypermatrix with singleton (square)
+// Lists
+assert_checkequal(issquare(list()), %f); // Empty list
+l=list(1);
+assert_checkequal(issquare(l), %t); // Scalar case
+clear l;
+l=list(1,"test");
+assert_checkequal(issquare(l), %f); // Column case
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"issquare", 1);
+assert_checkerror("issquare()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("issquare(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=issquare([1 2 3]);", errmsg3);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/issquare.tst b/scilab/modules/elementary_functions/tests/unit_tests/issquare.tst
new file mode 100644 (file)
index 0000000..e1e1d9e
--- /dev/null
@@ -0,0 +1,132 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// unit tests for issquare function
+// =============================================================================
+
+// Constants
+assert_checkequal(issquare([1 2 3]), %f);
+assert_checkequal(issquare([1 2 3]'), %f);
+assert_checkequal(issquare([1 2; 1 2]), %t);
+assert_checkequal(issquare(1), %t);
+assert_checkequal(issquare(rand(2,1,2)), %t);
+assert_checkequal(issquare(rand(2,2,3)), %f);
+assert_checkequal(issquare([]), %f);
+
+// Strings
+assert_checkequal(issquare(["s" "t" "u"]), %f);
+assert_checkequal(issquare(["s" "t" "u"]'), %f);
+assert_checkequal(issquare(["s" "t";"s" "t"]), %t);
+assert_checkequal(issquare("s"), %t);
+assert_checkequal(issquare(hypermat([2,1,2],["s";"s";"s";"s"])), %t);
+assert_checkequal(issquare(hypermat([2,2,3],["t";"t";"t";"t";"t";"t";"t";"t";"t";"t";"t";"t"])), %f);
+
+// Polynomials
+s=poly(0,"s");
+assert_checkequal(issquare([1+s 2+s]), %f);
+assert_checkequal(issquare([1+s 2+s]'), %f);
+assert_checkequal(issquare([1+s 2+s; 3+s 4+s]), %t);
+assert_checkequal(issquare(1+s), %t);
+assert_checkequal(issquare(hypermat([2,1,2],[s;s;s;s])), %t);
+assert_checkequal(issquare(hypermat([2,2,3],[s;s;s;s;s;s;s;s;s;s;s;s])), %f);
+
+// Booleans
+assert_checkequal(issquare([%t %f]), %f);
+assert_checkequal(issquare([%t %f]'), %f);
+assert_checkequal(issquare([%t %f; %f %t]), %t);
+assert_checkequal(issquare(%t), %t);
+assert_checkequal(issquare(hypermat([2,1,2],[%t;%t;%t;%t])), %t);
+assert_checkequal(issquare(hypermat([2,2,3],[%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t;%t])), %f)
+
+// Sparses
+assert_checkequal(issquare(sparse([1 0 2])), %f);
+assert_checkequal(issquare(sparse([1 0 2])'), %f);
+assert_checkequal(issquare(sparse([1 0; 0 1])), %t);
+assert_checkequal(issquare(sparse(0)), %t);
+
+// Structures
+clear s;
+assert_checkequal(issquare(struct()), %f); // Empty structure
+s.a = "test";
+assert_checkequal(issquare(s), %t); // Scalar structure
+clear s;
+s(3,1).a = %pi;
+assert_checkequal(issquare(s), %f); // Column structure
+clear s;
+s(1,3).a = %pi;
+assert_checkequal(issquare(s), %f); // Row structure
+clear s;
+s(3,2).a = %z;
+assert_checkequal(issquare(s), %f); // 2D structure array (not square)
+clear s;
+s(2,2,2).a = %s;
+assert_checkequal(issquare(s), %t); // 3D structure array (cube)
+clear s;
+s(2,1,2).a = %s;
+assert_checkequal(issquare(s), %t); // 3D structure array with singleton (square)
+
+// Cells
+assert_checkequal(issquare(cell()), %f); // Empty cell
+a = cell(1);
+a(1).entries = 1;
+assert_checkequal(issquare(a), %t); // Scalar case
+clear a;
+a = cell(1,3);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(issquare(a), %f); // Row case
+clear a;
+a = cell(3,1);
+a(1).entries = 1:3;
+a(2).entries = 1:3;
+a(3).entries = 1:3;
+assert_checkequal(issquare(a), %f); // Column case
+clear a;
+a = cell(3,2);
+a(1,1).entries = 1:3;
+a(1,2).entries = 1:3;
+a(2,1).entries = 1:3;
+a(2,2).entries = 1:3;
+a(3,2).entries = 1:3;
+a(3,1).entries = 1:3;
+assert_checkequal(issquare(a), %f); // Matrix case
+clear a;
+a = cell(2,2,2);
+a(1,1,1).entries =1:3;
+a(1,2,1).entries =1:3;
+a(2,1,1).entries =1:3;
+a(2,2,1).entries =1:3;
+a(1,1,2).entries =1:3;
+a(1,2,2).entries =1:3;
+a(2,1,2).entries =1:3;
+a(2,2,2).entries =1:3;
+assert_checkequal(issquare(a), %t); // Cubic case
+a = cell(2,1,2);
+a(1,1,1).entries=1:3;
+a(2,1,1).entries=1:3
+a(1,1,2).entries=1:3;
+a(2,1,2).entries=1:3;
+assert_checkequal(issquare(a), %t); // Hypermatrix with singleton (square)
+
+// Lists
+assert_checkequal(issquare(list()), %f); // Empty list
+l=list(1);
+assert_checkequal(issquare(l), %t); // Scalar case
+clear l;
+l=list(1,"test");
+assert_checkequal(issquare(l), %f); // Column case
+
+// Error messages
+errmsg1 = msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"issquare", 1);
+assert_checkerror("issquare()", errmsg1);
+errmsg2 = msprintf(_("Wrong number of input arguments."));
+assert_checkerror("issquare(1,2)", errmsg2);
+errmsg3 = msprintf(_("Wrong number of output arguments.\n"));
+assert_checkerror("[r,b]=issquare([1 2 3]);", errmsg3);