* Bug #6824 fixed - resize_matrix now handles hypermatrices 61/12561/12
Samuel Gougeon [Tue, 17 Sep 2013 08:49:01 +0000 (10:49 +0200)]
Used a new optional input argument to specify to size of the returned hypermatrix.

Change-Id: I6a254a0cd2d0bc595d3bffecab29a90083c7b78d

12 files changed:
SEP/INDEX
SEP/SEP_113_resize_matrix_hypermatrices.odt [new file with mode: 0644]
scilab/CHANGES_5.5.X
scilab/modules/elementary_functions/help/en_US/matrixmanipulation/resize_matrix.xml
scilab/modules/elementary_functions/help/fr_FR/matrixmanipulation/resize_matrix.xml
scilab/modules/elementary_functions/macros/resize_matrix.sci
scilab/modules/elementary_functions/tests/nonreg_tests/bug_10836.dia.ref
scilab/modules/elementary_functions/tests/nonreg_tests/bug_10836.tst
scilab/modules/elementary_functions/tests/nonreg_tests/bug_6824.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/nonreg_tests/bug_6824.tst [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/resize_matrix.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/resize_matrix.tst

index 299b034..d018488 100644 (file)
--- a/SEP/INDEX
+++ b/SEP/INDEX
@@ -108,3 +108,4 @@ SEP #109: New input argument for neldermead_search(), to control warnings.
 SEP #110: /* RESERVED */
 SEP #111: /* RESERVED */
 SEP #112: variance and variancef can now return the mean of the input in a new output argument.
+SEP #113: resize_matrix hypermatrices support.
diff --git a/SEP/SEP_113_resize_matrix_hypermatrices.odt b/SEP/SEP_113_resize_matrix_hypermatrices.odt
new file mode 100644 (file)
index 0000000..327f336
Binary files /dev/null and b/SEP/SEP_113_resize_matrix_hypermatrices.odt differ
index 1bccb2b..55f09d2 100644 (file)
@@ -13,6 +13,8 @@ Scilab Bug Fixes
 * Bug #6689 & #6690 fixed - grand now works with complexes, polynomials, booleans, integers, sparses and strings,
                             and can take row vectors, matrices and hypermatrices of thoses types.
 
+* Bug #6824 fixed - resize_matrix did not manage hypermatrices.
+
 * Bug #7047 fixed - milk_drop is now obsolete. It will be removed in Scilab 5.5.1, but will be kept as a demo.
 
 * Bug #7570 fixed - The switch criterion on x and y is now explicited in beta() help page.
index c2b2c60..565fd64 100644 (file)
@@ -2,22 +2,34 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA - Jean-Baptiste SILVY
- * 
+ * Copyright (C) 2013 - Samuel GOUGEON (5.5.0)
+ *
  * 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    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-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="resize_matrix" xml:lang="en">
     <refnamediv>
         <refname>resize_matrix</refname>
-        <refpurpose>create a new matrix with a different size</refpurpose>
+        <refpurpose>trim or/and extend (and cast) a matrix or hypermatrix</refpurpose>
     </refnamediv>
     <refsynopsisdiv>
         <title>Calling Sequence</title>
-        <synopsis>resMat = resize_matrix(mat,nbRow,nbCol,[typeOfMat])</synopsis>
+        <synopsis>
+            resMat = resize_matrix(mat, nbRows, nbCols)
+            
+            resMat = resize_matrix(mat, nbRows, nbCols, resType)
+            resMat = resize_matrix(mat, nbRows, nbCols, resType, padding)
+            resMat = resize_matrix(mat, nbRows, nbCols,    ""  , padding)
+            
+            resMat = resize_matrix(mat, newSizes)
+            resMat = resize_matrix(mat, newSizes, resType)
+            resMat = resize_matrix(mat, newSizes, resType, padding)
+            resMat = resize_matrix(mat, newSizes,    ""  , padding)
+        </synopsis>
     </refsynopsisdiv>
     <refsection>
         <title>Arguments</title>
             <varlistentry>
                 <term>mat</term>
                 <listitem>
-                    <para>input matrix from which the resized matrix will be
-                        created.
+                    <para>input matrix or hypermatrix. booleans, encoded integers, decimals (real or complexes), polynomials, or text are supported.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>nbRow</term>
+                <term>nbRows</term>
                 <listitem>
-                    <para>number of row of the resized matrix.</para>
+                    <para>new number of rows of the resized matrix. Exceeding rows are trimmed. Missing rows are padded</para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>nbCol</term>
+                <term>nbCols</term>
                 <listitem>
-                    <para>number of column of the resized matrix.</para>
+                    <para>new number of columns of the resized matrix. Exceeding columns are trimmed. Missing columns are padded</para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>typeOfMat</term>
+                <term>newSizes</term>
                 <listitem>
-                    <para>caracter string, type name of the resized matrix.</para>
+                    <para>
+                        vector specifying the new sizes along each dimension of <varname>mat</varname>.
+                    </para>
+                    <para>
+                        If it is shorter than <literal>size(mat)</literal>, it is padded with ones. Example: if <varname>mat</varname> with <literal>size(mat)==[ 4 3 3 2]</literal> is provided and <literal>newSizes=[6 2]</literal> is specified, <literal>newSizes = [6 2 1 1]</literal> is considered.
+                    </para>
+                    <para>
+                        If <varname>newSizes</varname> is longer than <literal>size(mat)</literal>, new dimensions are added to <varname>mat</varname> and padded. Example: if <varname>mat</varname> such that <literal>size(mat)==[ 4 3 ]</literal> is provided and <literal>newSizes=[6 2 2]</literal> is specified, the result will be an hypermatrix with 2 pages, the second one being fully padded.
+                    </para>
+                    <para>
+                        <literal>newSizes = [nbRows, nbCols]</literal> may be used for a matrix.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>padding</term>
+                <listitem>
+                    <para>
+                        optional scalar of same type as <varname>mat</varname>, specifying the content to set in elements created when the size along a dimension is increased. The default padding is done with <literal>0</literal> (real or complex decimals, encoded integers, polynomials), or <literal>""</literal> (text), or <literal>%F</literal> (booleans).
+                    </para>
+                    <para>
+                        When <varname>mat</varname> and <varname>padding</varname> types do not match, scilab tries to convert the <varname>padding</varname>'s one
+                    </para>
+                    <para>
+                        For polynomials, the varname of the padding is forced to the <varname>mat</varname>'s one.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>resType</term>
+                <listitem>
+                    <para>optional text word specifying the data type into which the resized matrix must be converted. "boolean", "constant", "string", "int8", "uint8", "int16", "uint16", "int32", and "uint32" are supported.</para>
+                    <para>Type conversion is supported neither for Polynomials nor for hypermatrix of text.</para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>resMat</term>
                 <listitem>
-                    <para>resized matrix.</para>
+                    <para>resized (and converted) matrix or hypermatrix</para>
                 </listitem>
             </varlistentry>
         </variablelist>
     <refsection>
         <title>Description</title>
         <para>
-            Create a matrix of size <literal>nbRow</literal> x
-            <literal>nbCol</literal> and whose elements <literal>(i,j)</literal> are
-            <literal>mat(i,j)</literal> if <literal>(i,j)</literal> is in the range of
-            the input matrix. Otherwise elements <literal>(i,j)</literal> are
-            <literal>0</literal> for real or integer matrices, <literal>%f</literal>
-            for boolean matrices and an empty string for string matrices.
-        </para>
-        <para>The type of the output matrix may be modified by specifying the
-            <literal>typeOfMat</literal> argument. In this case, be sure that the
-            input matrix type is compatible with this one.
+            Creates a matrix of sizes <literal>[nbRows, nbCols]</literal> or <literal>newSizes</literal>, or an hypermatrix of sizes <literal>newSizes</literal>.
+            If for a dimension the new size is smaller than the initial one, the matrix is cropped. If the size is increased, the matrix/hypermatrix is padded.
+            The number of dimensions can be increased. Respectively, Scilab automatically squeezes highest dimensions with size kept or set to 1 (singletons).
         </para>
-        <para>For now, only real, integer matrices, boolean and character string
-            matrices are supported. This means that <literal>typeOfMat</literal> must
-            be chosen within: 'constant', 'boolean', 'string' or any integer type
-            ('int8', 'int16',...).
+        <para>
+            The type of the result may be changed by specifying the <literal>resType</literal> argument, with restrictions given above.
         </para>
     </refsection>
     <refsection>
         <title>Examples</title>
-        <programlisting role="example"><![CDATA[ 
-// number matrix
-myMat = 5 * rand( 3, 4 )
-myMat = resize_matrix( myMat, 3, 3 ) // reduce the matrix size
-myMatInteger = resize_matrix( myMat, 4, 4, 'int32' ) // create an integer matrix
-myMatBoolean = resize_matrix( myMat, 2, 2, 'boolean' )
-myMatBoolean = resize_matrix( myMatBoolean, 3, 5 )
+        <programlisting role="example"><![CDATA[
+// Embedded examples, including with polynomials:
+resize_matrix
+
+// Numerical matrix:
+M = grand(4, 3, "uin", -9, 9)
+resize_matrix(M, 3, 4)
+resize_matrix(M, [3 4 2])
+resize_matrix(M, [3 4 2], "", %i)
+resize_matrix(M, [3 4 2], "string", %i)
 
-// string matrix
-myMatString = ["Scilab","the";"Open Source","Scientific";"Software","Package"]
-myMatString = resize_matrix( myMatString, 3, 1 )
+// Matrix of text:
+myMatString = ["Scilab", "the"; "Open Source", "Scientific"; "Software", "Package"]
+resize_matrix( myMatString, 5, 3 )
+// Equivalent syntax for new sizes:
+resize_matrix( myMatString, [5 3], "", "$" )    // With custom padding
+
+// Crops, pads and casts an hypermatrix:
+h = rand(2, 3, 2)*200
+resize_matrix(h, [3 2 3], "int8")
+resize_matrix(h, [3 2 3], "int8", -1)    // Custom padding
+r = resize_matrix(h, [3 2 ] , "" , -1)   // Custom padding without type conversion
+size(r)  // The last dimension has been squeezed
+
+// With Polynomials:
+x = poly(0, "x");
+P = (1-x)^grand(4, 2, "uin", 0, 3)
+resize_matrix(P, 3, 3)
+resize_matrix(P, [3 3 2])
+resize_matrix(P, [3 3 2], "", %z)
+//  => The padding's unknown is forced to the P's one
+//  => Polynomials can't be converted
  ]]></programlisting>
     </refsection>
     <refsection role="see also">
@@ -103,6 +158,28 @@ myMatString = resize_matrix( myMatString, 3, 1 )
             <member>
                 <link linkend="typeof">typeof</link>
             </member>
+            <member>
+                <link linkend="double">double</link>
+            </member>
+            <member>
+                <link linkend="strtod">strtod</link>
+            </member>
+            <member>
+                <link linkend="strtod">string</link>
+            </member>
         </simplelist>
     </refsection>
+    <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Polynomials and Hypermatrices are now accepted.
+                    Custom padding can now be provided.
+                    New sizes can be specified in a vector.
+                    resize_matrix with no parameters displays examples (demo).
+                </revremark>
+            </revision>
+        </revhistory>
+    </refsection>
 </refentry>
index a5d20bd..431846a 100644 (file)
@@ -1,12 +1,35 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2008 - INRIA - Jean-Baptiste SILVY
+ * Copyright (C) 2013 - Samuel GOUGEON (5.5.0)
+ *
+ * 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.1-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="resize_matrix" xml:lang="fr">
     <refnamediv>
         <refname>resize_matrix</refname>
-        <refpurpose>redimensionne une matrice</refpurpose>
+        <refpurpose>élague et/ou étend (et convertit) une matrice ou une hypermatrice</refpurpose>
     </refnamediv>
     <refsynopsisdiv>
         <title>Séquence d'appel</title>
-        <synopsis>resMat = resize_matrix(mat,nbRow,nbCol,[typeOfMat])</synopsis>
+        <synopsis>
+            resMat = resize_matrix(mat, nbRows, nbCols)
+            
+            resMat = resize_matrix(mat, nbRows, nbCols, resType)
+            resMat = resize_matrix(mat, nbRows, nbCols, resType, padding)
+            resMat = resize_matrix(mat, nbRows, nbCols,    ""  , padding)
+            
+            resMat = resize_matrix(mat, newSizes)
+            resMat = resize_matrix(mat, newSizes, resType)
+            resMat = resize_matrix(mat, newSizes, resType, padding)
+            resMat = resize_matrix(mat, newSizes,    ""  , padding)
+        </synopsis>
     </refsynopsisdiv>
     <refsection>
         <title>Paramètres</title>
             <varlistentry>
                 <term>mat</term>
                 <listitem>
-                    <para>matrice d'entrée à  partir de laquelle la matrice
-                        redimensionnée sera créée.
+                    <para>Matrice à retailler, de type booléens, entiers encodés, décimaux (réels ou complexes), polynômes, ou texte
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>nbRow</term>
+                <term>nbRows</term>
                 <listitem>
-                    <para>nombre de lignes de la matrice redimensionnée.</para>
+                    <para>nouveau nombre de lignes de la matrice retaillée. Les lignes en trop sont supprimées. Les lignes manquantes sont créées.</para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>nbCol</term>
+                <term>nbCols</term>
                 <listitem>
-                    <para>nombre de colonnes de la matrice redimensionnée.</para>
+                    <para>nouveau nombre de colonnes de la matrice retaillée. Les colonnes en trop sont supprimées. Les colonnes manquantes sont créées.</para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>typeOfMat</term>
+                <term>newSizes</term>
                 <listitem>
-                    <para>chaîne de caractères spécifiant le type de la matrice
-                        redimensionnée.
+                    <para>
+                        vecteur spécifiant la nouvelle taille de <literal>mat</literal> selon chacune de ses dimensions.
+                    </para>
+                    <para>
+                        S'il est plus court que <literal>size(mat)</literal>, il est complété avec des 1. Exemple: si <varname>mat</varname> telle que <literal>size(mat)==[ 4 3 3 2]</literal> est fournie, et <literal>newSizes=[6 2]</literal> est spécifié, <literal>newSizes = [6 2 1 1]</literal> sera utilisé.
+                    </para>
+                    <para>
+                        Si <varname>newSizes</varname> est plus long que <literal>size(mat)</literal> avec <literal>newSizes($)>1</literal>, une ou plusieurs dimensions sont ajoutées à <varname>mat</varname>. Exemple: si <varname>mat</varname> telle que <literal>size(mat)==[ 4 3 ]</literal> est fournie avec <literal>newSizes=[6 2 2]</literal>, le résultat sera une hypermatrice de 2 pages, la seconde étant complètement initialisée.
+                    </para>
+                    <para>
+                        <literal>newSizes = [nbRows, nbCols]</literal> peut être utilisé pour une matrice.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>resType</term>
+                <listitem>
+                    <para>option indiquant le type en lequel la matrice/hypermatrice retaillée doit être convertie. resType peut être "boolean", "constant", "string", "int8", "uint8", "int16", "uint16", "int32", and "uint32".</para>
+                    <para>Aucune conversion n'est admise pour une matrice ou hypermatrice de polynômes, ni pour une hypermatrice de texte.</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>padding</term>
+                <listitem>
+                    <para>
+                        option de même type que <varname>mat</varname>, spécifiant le contenu scalaire à affecter aux éléments ajoutés à <varname>mat</varname> lorsque sa taille selon une dimension est augmentée. La valeur utilisée par défaut est <literal>0</literal> (réels, complexes, entiers encodés, polynômes), ou <literal>""</literal> (texte), ou <literal>%F</literal> (booléens).
+                    </para>
+                    <para>
+                        Lorsque les types de <varname>mat</varname> et <varname>padding</varname> sont distincts, Scilab tente de convertir le type de <varname>padding</varname>.
+                    </para>
+                    <para>
+                        Pour les polynômes, le nom de l'inconnue du polynôme <varname>padding</varname> est forcé à celui de <varname>mat</varname>.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>resMat</term>
                 <listitem>
-                    <para>matrice redimensionnée.</para>
+                    <para>matrice ou hypermatrice retaillée (et convertie)</para>
                 </listitem>
             </varlistentry>
         </variablelist>
     <refsection>
         <title>Description</title>
         <para>
-            Crée une matrice de taille <literal>nbRow</literal> x<literal>
-                nbCol
-            </literal>
-            dont les éléments <literal>(i,j)</literal> sont
-            <literal>mat(i,j)</literal> si <literal>(i,j)</literal> est inférieur à 
-            la taille de la matrice. Sinon les éléments <literal>(i,j)</literal> sont
-            <literal>0</literal> pour les matrices de réels ou d'entier,
-            <literal>%f</literal> pour les matrices de booléens et une chaîne vide
-            pour les matrices de chaînes de caractères.
-        </para>
-        <para>Le type de la matrice de sortie peut être spécifié par l'argument
-            <literal>typeOfMat</literal>. Dans ce cas, le type doit être compatible
-            avec celui de la matrice d'entrée.
+            Crée une matrice de taille <literal>[nbRows, nbCols]</literal> ou <literal>newSizes</literal>, ou une hypermatrice de taille <literal>newSizes</literal>.
+            Si, pour une certaine dimension, la nouvelle taille est plus petite que l'initiale, la matrice est élaguée. Si la taille est agrandie, alors de nouveaux éléments valant <literal>padding</literal> sont ajoutés à la matrice/hypermatrice.
+            Le nombre de dimensions peut être augmenté.
         </para>
-        <para>Pour l'instant, seules les matrices de réels, d'entiers, de booléens
-            et de chaînes de caractères sont supportées. Ainsi, l'argument
-            <literal>typeOfMat</literal> doit prendre une valeur parmis : 'constant',
-            'boolean', 'string' ou un type entier ('int8', 'int16',...).
+        <para>
+            Le type du retour peut être modifié en spécifiant l'argument <literal>resType</literal>, avec les restrictions mentionnées ci-dessus.
         </para>
     </refsection>
     <refsection>
         <title>Exemples</title>
-        <programlisting role="example"><![CDATA[ 
-// matrice de chiffres
-myMat = 5 * rand( 3, 4 )
-myMat = resize_matrix( myMat, 3, 3 ) // réduction de la taille de la matrice
+        <programlisting role="example"><![CDATA[
+// Exemples de démonstration, dont avec des polynômes :
+resize_matrix
+
+// Matrice numérique
+M = grand(4, 3, "uin", -9, 9)
+resize_matrix(M, 3, 4)
+resize_matrix(M, [3 4 2])
+resize_matrix(M, [3 4 2], "", %i)
+resize_matrix(M, [3 4 2], "string", %i)
 
-// création d'une matrice d'entiers
-myMatInteger = resize_matrix( myMat, 4, 4, 'int32' )
-myMatBoolean = resize_matrix( myMat, 2, 2, 'boolean' )
-myMatBoolean = resize_matrix( myMatBoolean, 3, 5 )
+// Matrice de texte
+myMatString = ["Scilab", "the" ; "Open Source", "Scientific" ; "Software", "Package"]
+resize_matrix( myMatString, 5, 3 )
+// Equivalent syntax for new sizes:
+resize_matrix( myMatString, [5 3], "", "$" ) // Contenu d'extension à façon
 
-// matrice de chaînes de caractères
-myMatString = ["Scilab","the";"Open Source","Scientific";"Software","Package"]
-myMatString = resize_matrix( myMatString, 3, 1 )
+// Elagage, extension et conversion d'une hypermatrice donnée
+h = rand(2, 3, 2)*200
+resize_matrix(h, [3 2 3], "int8")
+resize_matrix(h, [3 2 3], "int8", -1)   // Extension avec des -1 et conversion en int8
+r = resize_matrix(h, [3 2 ] ,"" , -1)   // Extension à façon, sans conversion
+size(r)  // La dernière dimension réduite à un singleton a automatiquement été simplifiée
+
+// Matrice de polynômes
+x = poly(0, "x");
+P = (1-x)^grand(4, 2, "uin", 0, 3)
+resize_matrix(P, 3, 3)
+resize_matrix(P, [3 3 2])
+resize_matrix(P, [3 3 2], "", %z)
+//  => L'inconnue de %z est forcée à celle de P => x
+//  => La matrice de polynômes résultante n'est pas convertible
  ]]></programlisting>
     </refsection>
     <refsection role="see also">
@@ -99,6 +158,28 @@ myMatString = resize_matrix( myMatString, 3, 1 )
             <member>
                 <link linkend="typeof">typeof</link>
             </member>
+            <member>
+                <link linkend="double">double</link>
+            </member>
+            <member>
+                <link linkend="strtod">strtod</link>
+            </member>
+            <member>
+                <link linkend="strtod">string</link>
+            </member>
         </simplelist>
     </refsection>
+    <refsection>
+        <title>Historique</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Les polynômes et les hypermatrices sont désormais acceptés.
+                    La valeur affectée aux éléments d'extension peut être spécifiée.
+                    Les nouvelles tailles peuvent être spécifiées dans un vecteur.
+                    resize_matrix appelée sans paramètres affiche des exemples de démonstration.
+                </revremark>
+            </revision>
+        </revhistory>
+    </refsection>
 </refentry>
index e1fcdd0..690e303 100644 (file)
@@ -1,6 +1,8 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) INRIA - 2007 - Jean-Baptiste SILVY
-// Copyright (C) DIGITEO - 2011-2012 - Allan CORNET
+// Copyright (C) 2013 - Samuel GOUGEON : resize_matrix rewritten.
+//                                       Hypermatrix, polynomials and
+//                                       custom padding are now supported.
+//                                       Inline examples added.
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
 
-function resMat = resize_matrix(mat, nbRow, nbCol, typeOfMat)
 
-    // Author Jean-Baptiste Silvy
-    // Create a matrix of size nbRow x nbCol whose elements (i,j) are mat(i,j)
-    // if (i,j) is in the range of the matrix. Otherwise elements (i,j) are 0 for real
-    // or integer matrix, %f for boolean matrix and an empty string for string matrix.
-    // The type of the matrix may be modified by specifying the typeOfMat variable
+function mat = resize_matrix(mat, varargin)
 
-    [lhs, rhs] = argn(0);
-    if rhs <> 3 & rhs <> 4 then
-        error(msprintf(gettext("%s: Wrong number of input argument(s): %d to %d expected.\n"),"resize_matrix", 3, 4));
-    end
+    // Calling Sequence:
+    //     resize_matrix(M, nRows, nCols )
+    //     resize_matrix(M, [nRows nCols] )
+    //     resize_matrix(M, newSizes )
+    //     resize_matrix(M, .. , resType )
+    //     resize_matrix(M, .. , resType, padding )
+    //     resize_matrix(M, .. ,   ""   , padding )
+
+    [lhs, rhs] = argn(0)
+
+    // EXAMPLES
+    // --------
+    if rhs == 0 then
+        M = grand(4, 3, "uin", -9, 9)
+        disp(_("RESIZING a matrix of DECIMALS:"))
+        disp("M = ")
+        disp(M)
+        com = [ "resize_matrix(M, 3, 4)"
+        "resize_matrix(M, [3 4 2])"
+        "resize_matrix(M, [3 4 2], """", %i)"
+        "resize_matrix(M, [3 4 2], ""string"", %i)"
+        ]
+        for c = com'
+            disp(c)
+            execstr("disp("+c+")")
+        end
+
+        halt(ascii(10)+_("TYPE <Enter> to see an example with POLYNOMIALS:"))
+        x = poly(0, "x")
+        P = (1-x)^grand(4, 2, "uin", 0, 3)
+        disp("P = ")
+        disp(P)
+        com = [ "resize_matrix(P, 3, 3)"
+        "resize_matrix(P, [3 3 2])"
+        "resize_matrix(P, [3 3 2],"""", %z)"
+        ]
+        for c = com'
+            disp(c)
+            execstr("disp("+c+")")
+        end
+        disp(_("The padding''s unknown is forced to the P''s one"))
+        disp(_("Polynomials can''t be converted"))
+
+        halt(ascii(10)+_("TYPE <Enter> to see an example with TEXT:"))
+        T = string(grand(4, 3, 2, "unf", 0, 1)*100)
+        disp("T = ")
+        disp(T)
+        com = [ "resize_matrix(T, 2, 5)"
+        "resize_matrix(T, [2 5], ""constant"")"
+        "resize_matrix(T, [2 5], """", ""abc"")"
+        "resize_matrix(T, [2 5], ""int16"", ""-1e4"")"
+        ]
+        for c = com'
+            disp(c)
+            execstr("disp("+c+")")
+        end
+        disp(_("NOTE: Hypermatrix of text can''t be converted"))
 
-    if ((nbRow <= 0) | (nbCol <= 0)) then
-        resMat = [];
+        mat = []
         return
     end
 
-    matSize = size(mat) ;
-    minRow = min(nbRow, matSize(1));
-    minCol = min(nbCol, matSize(2));
+    // INITIALIZATIONS
+    // ---------------
+    // if needed, default padding will be defined later:
+    padding = []
+    // Default type of the result:
+    resType = typeof(mat)
+    if resType=="hypermat" then
+        resType = typeof(mat(1))
+    end
+
+    // ARGUMENTS ANALYSIS & CHECKING
+    // -----------------------------
+    if rhs==1 | rhs > 5 then
+        msg = _("%s: Wrong number of input argument(s): %d to %d expected.\n")
+        error(msprintf(msg, "resize_matrix", 2, 5))
+    end
 
-    [lhs,rhs] = argn(0) ;
-    if (rhs < 4) then
-        typeOfMat = typeof(mat) ;
+    if ~((typeof(mat)=="hypermat" | or(type(mat)~=[15 16 17])) ..
+        & or(type(mat(:))==[1 2 4 5 6 8 10]))
+        msg = _("%s: Wrong type of input argument #%d: ""%s"" not supported.\n")
+        error(msprintf(msg, "resize_matrix", 1, typeof(mat(:))))
+        // typeof(hypermat(rational)): "rational" overrides "hypermat"...
     end
 
-    z = zeros(nbRow, nbCol);
-
-    select typeOfMat
-    case "constant" then
-        // real matrix
-        resMat = z;
-    case "boolean" then
-        // boolean matrix
-        // intialized it to false
-        resMat = (z == 1);
-        if typeof(mat) == "boolean" then
-            resMat(1:minRow, 1:minCol) = (mat(1:minRow, 1:minCol) == %t);
+    arg = varargin(1)
+    nextvarg = 2
+    if ~isscalar(arg) then
+        newsizes = arg
+    else
+        if rhs>2 then
+            varg2 = varargin(2)
+            if type(varg2)~=1 | ~isscalar(varg2) then
+                msg = _("%s: Wrong input argument #%d: scalar decimal integer expected.\n")
+                error(msprintf(msg, "resize_matrix", 2))
+            end
+            nextvarg = 3
         else
-            resMat(1:minRow, 1:minCol) = (mat(1:minRow, 1:minCol) == 1);
+            varg2 = 1
         end
+        newsizes = [ arg varg2 ]
+    end
 
-        return
-    case "int8" then
-        mat = int8(mat);
-        resMat = int8(z);
-    case "int16" then
-        mat = int16(mat);
-        resMat = int16(z);
-    case "int32" then
-        mat = int32(mat);
-        resMat = int32(z);
-    case "uint8" then
-        mat = uint8(mat);
-        resMat = uint8(z);
-    case "uint16" then
-        mat = uint16(mat);
-        resMat = uint16(z);
-    case "uint32" then
-        mat = uint32(mat);
-        resMat = uint32(z);
-    case "string" then
-        // string matrix
-        mat = string(mat);
-        resMat = emptystr(nbRow, nbCol);
-    else
-        error(msprintf(gettext("%s: Wrong value for input argument #%d.\n"), "resize_matrix", 1));
+    if or(type(mat) == [15 16]) & size(size(newsizes), "*") <> 1  then
+        msg = _("%s: Wrong sizes requested, cannot convert list to matrix.\n")
+        error(msprintf(msg, "resize_matrix"))
     end
 
-    resMat(1:minRow, 1:minCol) = mat(1:minRow, 1:minCol);
 
+    if  size(varargin)>=nextvarg then
+        // Type of output
+        resType = varargin(nextvarg)
+        if typeof(resType)~="string"
+            resType = typeof(mat(:))
+        elseif resType=="" then
+            resType = typeof(mat(:))
+            nextvarg = nextvarg + 1
+        else
+            nextvarg = nextvarg + 1
+        end
+        // Padding pattern
+        if size(varargin)>=nextvarg then
+            padding = varargin(nextvarg)
+            err = %f
+            tpad = type(padding)
+            if tpad~=type(mat(:)) then  // TRYING to CONVERT the given PADDING
+                if or(type(mat(:))==[1 5 8]) then    // numbers
+                    if or(tpad==[4 6])      // boolean
+                        padding = bool2s(tpad)
+                    elseif tpad==10         // string
+                        padding = strtod(padding)
+                        err = isnan(padding)
+                    elseif or(tpad==[2 9]) | tpad>10
+                        err = %t
+                    end
+                elseif type(mat(:))==2  // polynomials
+                    if or(tpad==[1 5 8]) then   // decimals or encoded integers
+                        padding = double(padding)
+                    elseif or(tpad==[4 6])      // booleans
+                        padding = bool2s(padding)
+                    else
+                        err = %t
+                    end
+                elseif or(type(mat(:))==[4 6])  // booleans
+                    if or(tpad==[1 5 8]) then       // numbers
+                        padding = (padding~=0)
+                    elseif tpad==10
+                        padding = (padding~="")     // string
+                    else
+                        err = %t
+                    end
+                else
+                    err = %t
+                end
+                if err then
+                    msg = _("%s: Wrong type for input argument #%d: can''t convert the padding to the input matrix type.\n")
+                    error(msprintf(msg, "resize_matrix", nextvarg+1))
+                end
+            else
+                padding = varargin(nextvarg)
+                if type(padding)==2 then
+                    // the padding's unknown is forced to the mat's one
+                    padding = varn(padding, varn(mat(1)))
+                end
+            end
+        end
+    end
+
+    // FORMATTING SIZES VECTORS
+    // ------------------------
+    // if the vector of new sizes is shorter than ndims(mat), it is padded with ones
+    oldsizes = size(mat)
+    newsizes = int(real(newsizes(:)'))
+    newsizes = [ newsizes  ones(1, length(oldsizes)-length(newsizes)) ]
+    oldsizes = [ oldsizes  ones(1, length(newsizes)-length(oldsizes)) ]
+    imax = length(newsizes)
+
+    // TRIMMING
+    // --------
+    k = (newsizes>0 & newsizes<oldsizes)
+    if or(k) then
+        strcommand = ""
+        for i=1:imax
+            if k(i) then
+                strcommand = strcommand + msprintf("1:%d",newsizes(i))
+            else
+                strcommand = strcommand + ":"
+            end
+            if i<imax then
+                strcommand = strcommand + ","
+            end
+        end
+        execstr("mat = mat("+strcommand+")")
+    end
+
+    // PADDING
+    // -------
+    k = (newsizes>0 & newsizes>oldsizes)
+    if or(k) then
+        if padding==[] then
+            // Padding with default: needs just to set the upper bounds
+            // setting defaults
+            if or(type(mat(:))==[1 2 5 8]) // decimals, polynomials, decimal sparse, encoded integers
+                padding = "0"
+            elseif or(type(mat(:))==[4 6]) // booleans, boolean sparse
+                padding = "%f"
+            elseif type(mat(:))==10        // text
+                padding = """"""
+            end
+            // padding:
+            strcommand = ""
+            for i=1:imax
+                if k(i) then
+                    strcommand = strcommand + msprintf("%d",newsizes(i))
+                else
+                    strcommand = strcommand + "1"
+                end
+                if i<imax then
+                    strcommand = strcommand + ","
+                end
+            end
+            execstr("mat("+strcommand+")="+padding)
+        else    // Explicit padding
+            Pad = padding
+            padding = "Pad"
+            for i=1:imax
+                if k(i) then
+                    s = zeros(1,imax)
+                    s(i) = i
+                    s = strcat(string(s),",")
+                    s = strsubst(s,"0",":")
+                    padRange = string(oldsizes(i)+1)+":"+string(newsizes(i))
+                    s = strsubst(s, string(i), padRange)
+                    execstr("mat("+s+") = "+padding)
+                end
+            end
+        end
+    end
+
+    // CASTING : converting the type of the result
+    // -------
+    type_0 = typeof(mat(:))
+    if resType~=type_0
+        if type_0=="polynomial"
+            msg = _("%s: conversion of polynomials is not supported\n")
+            error(msprintf(msg, "resize_matrix"))
+        elseif resType=="string"
+            mat = string(mat)
+        elseif or(resType==["int8" "int16" "int32" "uint8" "uint16" "uint32"])
+            if type_0=="string"
+                mat = strtod(mat)       // strings => decimals
+            end
+            // encoded integers, reals, complexes, booleans  => #int#
+            if type(mat(:))==1 & ~isreal(mat)
+                mat = abs(mat)  // taking the module of complexes
+            end
+            execstr("mat = "+resType+"(mat)")
+        elseif resType=="constant"
+            if type_0=="string" then
+                mat = strtod(mat)
+            else // encoded integers, booleans => decimals
+                mat = double(mat)
+            end
+        elseif resType=="boolean"
+            if type_0=="string" then
+                mat = (mat~="")
+            else
+                mat = (mat~=0)
+            end
+        else
+            msg = _("%s: conversion into ""%s"" is not supported\n")
+            error(msprintf(msg, "resize_matrix", resType))
+        end
+    end
 endfunction
index da0dc40..d43e981 100644 (file)
 // <-- Short Description -->
 // resize_matrix with boolean failed.
 myMat = 5 * rand(3, 4);
-myMatBoolean = resize_matrix( myMat, 2, 2, 'boolean');
-ref = (zeros(2,2) == 1);
+myMatBoolean = resize_matrix( myMat, 2, 2, "boolean");
+ref = (zeros(2,2) <> 1);
 assert_checkequal(myMatBoolean, ref);
-myMat(1, 1) = 1;
-myMat(3, 4) = 1;
-ref = (zeros(2, 2) == 1);
-ref(1, 1) = %t;
-myMatBoolean = resize_matrix( myMat, 2, 2, 'boolean');
+myMat(1, 1) = 0;
+myMat(3, 4) = 0;
+ref = (zeros(2, 2) <> 1);
+ref(1, 1) = %f;
+myMatBoolean = resize_matrix( myMat, 2, 2, "boolean");
 assert_checkequal(myMatBoolean, ref);
-myMat(1, 1) = 1;
-myMat(3, 4) = 1;
 ref = (zeros(10, 10) == 1);
-ref(1, 1) = %t;
-ref(3, 4) = %t;
-myMatBoolean = resize_matrix( myMat, 10, 10, 'boolean');
+ref(1:3, 1:4) = %t;
+ref(1, 1) = %f;
+ref(3, 4) = %f;
+myMatBoolean = resize_matrix( myMat, 10, 10, "boolean");
 assert_checkequal(myMatBoolean, ref);
-myMat = ['Scilab' '5'; ..
-         'Test'   'bug_10836'];
-myMatBoolean = resize_matrix( myMat, 2, 2, 'boolean');
-ref = (zeros(2,2) == 1);
+myMat = ["Scilab" "5"; ..
+         "Test"   "bug_10836"];
+myMatBoolean = resize_matrix( myMat, 2, 2, "boolean");
+ref = (zeros(2,2) <> 1);
 assert_checkequal(myMatBoolean, ref);
-myMat = 5 * rand(3, 4);
-msgerr = msprintf(gettext("%s: Wrong value for input argument #%d.\n"), "resize_matrix", 1);
-assert_checkerror("myMatBoolean = resize_matrix( myMat, 2, 2, 999)", msgerr);
+myMat = zeros(5, 5);
+myMatPadded = resize_matrix( myMat, 10, 10, 0);
+ref = zeros(10, 10);
+assert_checkequal(myMatPadded, ref);
 myMat = ones(3, 4);
 ref = string(ones(2, 2));
-myNewMat = resize_matrix( myMat, 2, 2, 'string');
+myNewMat = resize_matrix( myMat, 2, 2, "string");
 assert_checkequal(myNewMat, ref);
index 569855c..6752c6a 100644 (file)
 // resize_matrix with boolean failed.
 
 myMat = 5 * rand(3, 4);
-myMatBoolean = resize_matrix( myMat, 2, 2, 'boolean');
-ref = (zeros(2,2) == 1);
+myMatBoolean = resize_matrix( myMat, 2, 2, "boolean");
+ref = (zeros(2,2) <> 1);
 assert_checkequal(myMatBoolean, ref);
 
-myMat(1, 1) = 1;
-myMat(3, 4) = 1;
-ref = (zeros(2, 2) == 1);
-ref(1, 1) = %t;
-myMatBoolean = resize_matrix( myMat, 2, 2, 'boolean');
+myMat(1, 1) = 0;
+myMat(3, 4) = 0;
+ref = (zeros(2, 2) <> 1);
+ref(1, 1) = %f;
+myMatBoolean = resize_matrix( myMat, 2, 2, "boolean");
 assert_checkequal(myMatBoolean, ref);
 
-myMat(1, 1) = 1;
-myMat(3, 4) = 1;
 ref = (zeros(10, 10) == 1);
-ref(1, 1) = %t;
-ref(3, 4) = %t;
-myMatBoolean = resize_matrix( myMat, 10, 10, 'boolean');
+ref(1:3, 1:4) = %t;
+ref(1, 1) = %f;
+ref(3, 4) = %f;
+myMatBoolean = resize_matrix( myMat, 10, 10, "boolean");
 assert_checkequal(myMatBoolean, ref);
 
-myMat = ['Scilab' '5'; ..
-         'Test'   'bug_10836'];
-myMatBoolean = resize_matrix( myMat, 2, 2, 'boolean');
-ref = (zeros(2,2) == 1);
+myMat = ["Scilab" "5"; ..
+"Test"   "bug_10836"];
+myMatBoolean = resize_matrix( myMat, 2, 2, "boolean");
+ref = (zeros(2,2) <> 1);
 assert_checkequal(myMatBoolean, ref);
 
-myMat = 5 * rand(3, 4);
-msgerr = msprintf(gettext("%s: Wrong value for input argument #%d.\n"), "resize_matrix", 1);
-assert_checkerror("myMatBoolean = resize_matrix( myMat, 2, 2, 999)", msgerr);
+myMat = zeros(5, 5);
+myMatPadded = resize_matrix( myMat, 10, 10, 0);
+ref = zeros(10, 10);
+assert_checkequal(myMatPadded, ref);
 
 myMat = ones(3, 4);
 ref = string(ones(2, 2));
-myNewMat = resize_matrix( myMat, 2, 2, 'string');
-assert_checkequal(myNewMat, ref);
\ No newline at end of file
+myNewMat = resize_matrix( myMat, 2, 2, "string");
+assert_checkequal(myNewMat, ref);
diff --git a/scilab/modules/elementary_functions/tests/nonreg_tests/bug_6824.dia.ref b/scilab/modules/elementary_functions/tests/nonreg_tests/bug_6824.dia.ref
new file mode 100644 (file)
index 0000000..518e687
--- /dev/null
@@ -0,0 +1,97 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// <-- Non-regression test for bug 6824 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=6824
+//
+// <-- Short Description -->
+// resize_matrix did not handle hypermatrices
+myMat = [
+0.6029980    4.2470508    3.2442814    3.7427533
+1.4276821    2.6285304    4.9615955    2.0520295
+4.3037573    4.9656049    0.2502099    3.0422632 ];
+refMat = [
+0.602998   4.2470508  3.2442814
+1.4276821  2.6285304  4.9615955
+4.3037573  4.9656049  0.2502099 ];
+// resize_matrix(m, x, y, 1) should yield the same result as resize_matrix(m, x, y)
+resMat = resize_matrix( myMat, [3 3 1]); // reduce the matrix size
+assert_checkequal(size(resMat), size(refMat));
+assert_checkequal(resMat, refMat);
+// resize_matrix(m, x, y, z) with m matrix should resize m to (x*y) and overlay (x*y) null matrices z times.
+// So here, with z = 2, one layer of zeros is added to m.
+refMat2 = refMat; refMat2(:, :, 2) = zeros(refMat);
+resMat = resize_matrix( myMat, [3 3 2]);
+assert_checkequal(size(resMat), size(refMat2));
+assert_checkequal(resMat, refMat2);
+// Resizing a hypermatrix into a matrix
+myMat2 = myMat; myMat2(:, :, 2) = myMat;
+resMat = resize_matrix( myMat2, 3, 3);
+assert_checkequal(size(resMat), size(refMat));
+assert_checkequal(resMat, refMat);
+// Resizing a hypermatrix into another smaller hypermatrix (smaller base matrix)
+refMat2 = refMat; refMat2(:, :, 2) = refMat;
+resMat = resize_matrix( myMat2, [3 3 2]);
+assert_checkequal(size(resMat), size(refMat2));
+assert_checkequal(resMat, refMat2);
+// Resizing a hypermatrix into another bigger hypermatrix (more layers)
+myMat2 = myMat; myMat2(:, :, 2) = myMat;
+refMat2 = refMat; refMat2(:, :, 2) = refMat; refMat2(:, :, 3) = zeros(refMat);
+resMat = resize_matrix( myMat2, [3 3 3]);
+assert_checkequal(size(resMat), size(refMat2));
+assert_checkequal(resMat, refMat2);
+// Resizing a hypermatrix into another smaller hypermatrix (fewer layers)
+myMat2 = myMat; myMat2(:, :, 2) = myMat; myMat2(:, :, 3) = myMat;
+refMat2 = refMat; refMat2(:, :, 2) = refMat;
+resMat = resize_matrix( myMat2, [3 3 2]);
+assert_checkequal(size(resMat), size(refMat2));
+assert_checkequal(resMat, refMat2);
+// With five input arguments
+refMat3 = string(refMat2);
+resMat = resize_matrix( myMat2, [3 3 2], "string");
+assert_checkequal(size(resMat), size(refMat3));
+assert_checkequal(resMat, refMat3);
+refMat3 = int16(refMat2);
+resMat = resize_matrix( myMat2, [3 3 2], "int16");
+assert_checkequal(size(resMat), size(refMat3));
+assert_checkequal(resMat, refMat3);
+refMat3 = (refMat2(:, :, :) <> 0);
+myMat2(3, 3, 1) = 1;
+resMat = resize_matrix( myMat2, [3 3 2], "boolean");
+assert_checkequal(size(resMat), size(refMat3));
+assert_checkequal(resMat, refMat3);
+// Original bug, augmented with a complex number
+m = [
+0.6912788    0.0143259    0.7876622
+0.7656859    0.8191490    0.1262083
+0.3572650    0.1304993    0.7883861
+0.7693400    0.9682004    0.3453042
+0.5477634    0.6561381    0.2659857
+0.0962289    0.2445539    0.9709819
+0.9561172    0.5283124    0.8875248
+0.2207409    0.8468926    0.2066753 ]*%i;
+refM = [
+0.6912788    0.0143259    0.7876622    0
+0.7656859    0.819149     0.1262083    0
+0.357265     0.1304993    0.7883861    0
+0.76934      0.9682004    0.3453042    0
+0.5477634    0.6561381    0.2659857    0
+0.0962289    0.2445539    0.9709819    0
+0.9561172    0.5283124    0.8875248    0
+0.2207409    0.8468926    0.2066753    0
+0            0            0            0
+0            0            0            0 ]*%i;
+m = resize_matrix(m, 10, 4);
+assert_checkequal(size(m), size(refM));
+assert_checkequal(m, refM);
+// Error checks
+refMsg = msprintf(_("%s: Wrong sizes requested, cannot convert list to matrix.\n"), "resize_matrix");
+assert_checkerror("resize_matrix(list(1), 3, 3);", refMsg);
diff --git a/scilab/modules/elementary_functions/tests/nonreg_tests/bug_6824.tst b/scilab/modules/elementary_functions/tests/nonreg_tests/bug_6824.tst
new file mode 100644 (file)
index 0000000..a0b1485
--- /dev/null
@@ -0,0 +1,128 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// <-- Non-regression test for bug 6824 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=6824
+//
+// <-- Short Description -->
+// resize_matrix did not handle hypermatrices
+
+myMat = [
+0.6029980    4.2470508    3.2442814    3.7427533
+1.4276821    2.6285304    4.9615955    2.0520295
+4.3037573    4.9656049    0.2502099    3.0422632 ];
+refMat = [
+0.602998   4.2470508  3.2442814
+1.4276821  2.6285304  4.9615955
+4.3037573  4.9656049  0.2502099 ];
+
+// resize_matrix(m, x, y, 1) should yield the same result as resize_matrix(m, x, y)
+resMat = resize_matrix( myMat, [3 3 1]); // reduce the matrix size
+
+assert_checkequal(size(resMat), size(refMat));
+assert_checkequal(resMat, refMat);
+
+// resize_matrix(m, x, y, z) with m matrix should resize m to (x*y) and overlay (x*y) null matrices z times.
+// So here, with z = 2, one layer of zeros is added to m.
+refMat2 = refMat; refMat2(:, :, 2) = zeros(refMat);
+
+resMat = resize_matrix( myMat, [3 3 2]);
+
+assert_checkequal(size(resMat), size(refMat2));
+assert_checkequal(resMat, refMat2);
+
+// Resizing a hypermatrix into a matrix
+myMat2 = myMat; myMat2(:, :, 2) = myMat;
+resMat = resize_matrix( myMat2, 3, 3);
+
+assert_checkequal(size(resMat), size(refMat));
+assert_checkequal(resMat, refMat);
+
+// Resizing a hypermatrix into another smaller hypermatrix (smaller base matrix)
+refMat2 = refMat; refMat2(:, :, 2) = refMat;
+
+resMat = resize_matrix( myMat2, [3 3 2]);
+
+assert_checkequal(size(resMat), size(refMat2));
+assert_checkequal(resMat, refMat2);
+
+// Resizing a hypermatrix into another bigger hypermatrix (more layers)
+myMat2 = myMat; myMat2(:, :, 2) = myMat;
+refMat2 = refMat; refMat2(:, :, 2) = refMat; refMat2(:, :, 3) = zeros(refMat);
+
+resMat = resize_matrix( myMat2, [3 3 3]);
+
+assert_checkequal(size(resMat), size(refMat2));
+assert_checkequal(resMat, refMat2);
+
+// Resizing a hypermatrix into another smaller hypermatrix (fewer layers)
+myMat2 = myMat; myMat2(:, :, 2) = myMat; myMat2(:, :, 3) = myMat;
+refMat2 = refMat; refMat2(:, :, 2) = refMat;
+
+resMat = resize_matrix( myMat2, [3 3 2]);
+
+assert_checkequal(size(resMat), size(refMat2));
+assert_checkequal(resMat, refMat2);
+
+// With five input arguments
+refMat3 = string(refMat2);
+
+resMat = resize_matrix( myMat2, [3 3 2], "string");
+
+assert_checkequal(size(resMat), size(refMat3));
+assert_checkequal(resMat, refMat3);
+
+refMat3 = int16(refMat2);
+
+resMat = resize_matrix( myMat2, [3 3 2], "int16");
+
+assert_checkequal(size(resMat), size(refMat3));
+assert_checkequal(resMat, refMat3);
+
+refMat3 = (refMat2(:, :, :) <> 0);
+myMat2(3, 3, 1) = 1;
+
+resMat = resize_matrix( myMat2, [3 3 2], "boolean");
+
+assert_checkequal(size(resMat), size(refMat3));
+assert_checkequal(resMat, refMat3);
+
+// Original bug, augmented with a complex number
+m = [
+0.6912788    0.0143259    0.7876622
+0.7656859    0.8191490    0.1262083
+0.3572650    0.1304993    0.7883861
+0.7693400    0.9682004    0.3453042
+0.5477634    0.6561381    0.2659857
+0.0962289    0.2445539    0.9709819
+0.9561172    0.5283124    0.8875248
+0.2207409    0.8468926    0.2066753 ]*%i;
+refM = [
+0.6912788    0.0143259    0.7876622    0
+0.7656859    0.819149     0.1262083    0
+0.357265     0.1304993    0.7883861    0
+0.76934      0.9682004    0.3453042    0
+0.5477634    0.6561381    0.2659857    0
+0.0962289    0.2445539    0.9709819    0
+0.9561172    0.5283124    0.8875248    0
+0.2207409    0.8468926    0.2066753    0
+0            0            0            0
+0            0            0            0 ]*%i;
+
+m = resize_matrix(m, 10, 4);
+
+assert_checkequal(size(m), size(refM));
+assert_checkequal(m, refM);
+
+
+// Error checks
+refMsg = msprintf(_("%s: Wrong sizes requested, cannot convert list to matrix.\n"), "resize_matrix");
+assert_checkerror("resize_matrix(list(1), 3, 3);", refMsg);
index 7883ba3..df18d04 100644 (file)
@@ -5,8 +5,8 @@
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 myMat =[     0.6029980    4.2470508    3.2442814    3.7427533
-    1.4276821    2.6285304    4.9615955    2.0520295
-    4.3037573    4.9656049    0.2502099    3.0422632  ];
+1.4276821    2.6285304    4.9615955    2.0520295
+4.3037573    4.9656049    0.2502099    3.0422632  ];
 myMat = resize_matrix( myMat, 3, 3 ) // reduce the matrix size
  myMat  =
  
@@ -22,7 +22,7 @@ refMat=int32([0,4,3,0;
 1,2,4,0;
 4,4,0,0;
 0,0,0,0]);
-myMatInteger = resize_matrix( myMat, 4, 4, 'int32' ) // create an integer matrix
+myMatInteger = resize_matrix( myMat, 4, 4, "int32" ) // create an integer matrix
  myMatInteger  =
  
   0  4  3  0  
@@ -31,16 +31,16 @@ myMatInteger = resize_matrix( myMat, 4, 4, 'int32' ) // create an integer matrix
   0  0  0  0  
 assert_checkequal(myMatInteger, refMat);
 booleanMat=resize_matrix( refMat, 3, 5 , "boolean");
-assert_checkequal(booleanMat, [%f,%f,%f,%f,%f;%t,%f,%f,%f,%f;%f,%f,%f,%f,%f]);
-myMatBoolean = resize_matrix( myMat, 2, 2, 'boolean' );
-assert_checkequal(myMatBoolean, [%f,%f;%f,%f] );
+assert_checkequal(booleanMat, [%f %t %t %f %f; %t %t %t %f %f; %t %t %f %f %f]);
+myMatBoolean = resize_matrix( myMat, 2, 2, "boolean" );
+assert_checkequal(myMatBoolean, [%t %t; %t %t] );
 assert_checkequal(size(myMatBoolean), [2, 2]);
 myMatBoolean = resize_matrix( myMatBoolean, 3, 5 );
-assert_checkequal(myMatBoolean, [%f,%f,%f,%f,%f;%f,%f,%f,%f,%f;%f,%f,%f,%f,%f]);
+assert_checkequal(myMatBoolean, [%t %t %f %f %f; %t %t %f %f %f; %f %f %f %f %f]);
 assert_checkequal(size(myMatBoolean), [3, 5]);
 myMatBoolean(1:4:9) = %t;
 myMatBoolean = resize_matrix(myMatBoolean, 3, 3);
-assert_checkequal(myMatBoolean, [%t %f %f; %f %t %f; %f %f %t]);
+assert_checkequal(myMatBoolean, [%t %t %f; %t %t %f; %f %f %t]);
 // string matrix
 myMatString = ["Scilab","the";"Open Source","Scientific";"Software","Package"];
 myMatString = resize_matrix( myMatString, 3, 1 );
index 2f12204..df1d781 100644 (file)
@@ -6,8 +6,8 @@
 // =============================================================================
 
 myMat =[     0.6029980    4.2470508    3.2442814    3.7427533
-    1.4276821    2.6285304    4.9615955    2.0520295
-    4.3037573    4.9656049    0.2502099    3.0422632  ];
+1.4276821    2.6285304    4.9615955    2.0520295
+4.3037573    4.9656049    0.2502099    3.0422632  ];
 
 myMat = resize_matrix( myMat, 3, 3 ) // reduce the matrix size
 refMat=[0.602998,4.2470508,3.2442814;
@@ -23,25 +23,24 @@ refMat=int32([0,4,3,0;
 4,4,0,0;
 0,0,0,0]);
 
-myMatInteger = resize_matrix( myMat, 4, 4, 'int32' ) // create an integer matrix
+myMatInteger = resize_matrix( myMat, 4, 4, "int32" ) // create an integer matrix
 assert_checkequal(myMatInteger, refMat);
 booleanMat=resize_matrix( refMat, 3, 5 , "boolean");
-assert_checkequal(booleanMat, [%f,%f,%f,%f,%f;%t,%f,%f,%f,%f;%f,%f,%f,%f,%f]);
+assert_checkequal(booleanMat, [%f %t %t %f %f; %t %t %t %f %f; %t %t %f %f %f]);
 
-myMatBoolean = resize_matrix( myMat, 2, 2, 'boolean' );
-assert_checkequal(myMatBoolean, [%f,%f;%f,%f] );
+myMatBoolean = resize_matrix( myMat, 2, 2, "boolean" );
+assert_checkequal(myMatBoolean, [%t %t; %t %t] );
 assert_checkequal(size(myMatBoolean), [2, 2]);
 myMatBoolean = resize_matrix( myMatBoolean, 3, 5 );
-assert_checkequal(myMatBoolean, [%f,%f,%f,%f,%f;%f,%f,%f,%f,%f;%f,%f,%f,%f,%f]);
+assert_checkequal(myMatBoolean, [%t %t %f %f %f; %t %t %f %f %f; %f %f %f %f %f]);
 assert_checkequal(size(myMatBoolean), [3, 5]);
 
 myMatBoolean(1:4:9) = %t;
 myMatBoolean = resize_matrix(myMatBoolean, 3, 3);
-assert_checkequal(myMatBoolean, [%t %f %f; %f %t %f; %f %f %t]);
+assert_checkequal(myMatBoolean, [%t %t %f; %t %t %f; %f %f %t]);
 
 // string matrix
 myMatString = ["Scilab","the";"Open Source","Scientific";"Software","Package"];
 myMatString = resize_matrix( myMatString, 3, 1 );
 
 assert_checkequal(myMatString, ["Scilab";"Open Source";"Software"]);
-