* Bug #6689 6690 fixed - grand extension, new function grand_perm 66/12866/6
Paul BIGNIER [Wed, 9 Oct 2013 12:34:29 +0000 (14:34 +0200)]
grand now works with complexes, polynomials, booleans, integers, strings and sparses.

Also, it can take row vectors, matrices and hypermatrices of these types.

grand is overloaded to call the new internal function %grand_perm.

Change-Id: Ifa2cb794bec98f83a54bb2fe121bf3f74286b30a

17 files changed:
scilab/CHANGES_5.5.X
scilab/modules/randlib/etc/randlib.start
scilab/modules/randlib/help/en_US/grand.xml
scilab/modules/randlib/help/fr_FR/grand.xml
scilab/modules/randlib/macros/%b_grand.sci [new file with mode: 0644]
scilab/modules/randlib/macros/%c_grand.sci [new file with mode: 0644]
scilab/modules/randlib/macros/%grand_perm.sci [new file with mode: 0644]
scilab/modules/randlib/macros/%hm_grand.sci [new file with mode: 0644]
scilab/modules/randlib/macros/%i_grand.sci [new file with mode: 0644]
scilab/modules/randlib/macros/%p_grand.sci [new file with mode: 0644]
scilab/modules/randlib/macros/%s_grand.sci [new file with mode: 0644]
scilab/modules/randlib/macros/%sp_grand.sci [new file with mode: 0644]
scilab/modules/randlib/macros/buildmacros.sce
scilab/modules/randlib/randlib.iss
scilab/modules/randlib/sci_gateway/c/sci_grand.c
scilab/modules/randlib/tests/nonreg_tests/bug_6690.dia.ref [new file with mode: 0644]
scilab/modules/randlib/tests/nonreg_tests/bug_6690.tst [new file with mode: 0644]

index 69a29c6..9709d24 100644 (file)
@@ -6,6 +6,9 @@ Scilab Bug Fixes
 
 * Bug #5016 fixed - condestsp could return different results when repeated calls were performed.
 
+* 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 #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 422ebcd..a9e3a7b 100644 (file)
@@ -7,3 +7,7 @@
 // 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
+
+//Load  functions libraries
+// =============================================================================
+  load('SCI/modules/randlib/macros/lib');
index 3d75d4e..fbf9242 100644 (file)
@@ -8,7 +8,7 @@
  * 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
  *
  -->
@@ -87,7 +87,7 @@
                 <term>Y</term>
                 <listitem>
                     <para>
-                        depending on the input, a matrix or hypermatrix of doubles, with random entries.
+                        depending on the input, a matrix or hypermatrix, with random entries.
                     </para>
                 </listitem>
             </varlistentry>
         <programlisting role="no-scilab-exec"><![CDATA[
             S = grand("getgen")
             grand("setgen", gen)
-            
+
             S = grand("getsd")
             grand("setsd", S)
-            
+
             grand("setcgn", G)
             S = grand("getcgn")
-            
+
             grand("initgn", I)
-            
+
             grand("setall", s1, s2, s3, s4)
-            
+
             grand("advnst", K)
         ]]></programlisting>
         <para>
             <varlistentry>
                 <term>multivariate gaussian (multivariate normal)</term>
                 <listitem>
-                    <para>   
+                    <para>
                         <code>Y = grand(n, "mn", Mean, Cov)</code>
-                        generates multivariate normal random         
+                        generates multivariate normal random
                         variates; <varname>Mean</varname> must be a <literal>m x 1</literal>
                         column vector and <varname>Cov</varname> a <varname>m</varname>-by-<varname>m</varname>
                         symmetric positive definite matrix  (<varname>Y</varname> is then
                 <listitem>
                     <para>
                         <code>Y = grand(n, "prm", vect)</code> generates
-                        <varname>n</varname> random permutations of the column
-                        vector (<literal>m x 1</literal>)
-                        <varname>vect</varname>.
+                        <varname>n</varname> random permutations of <varname>vect</varname>.
+                        <varname>vect</varname> can be a column vector of reals, or a vector, matrix or hypermatrix of
+                        complexes, integers, booleans, polynomials or strings; full or sparse.
                         Due to the stack structure, <varname>vect</varname> should not and cannot be a row vector.
                         This feature covers Matlab's <code>randperm()</code> function,
                         because <code>randperm(n)</code> is equivalent to <code>grand(1,'prm',(1:n)')</code>
                     <variablelist>
                         <varlistentry>
                             <term>I = -1</term>
-                            <listitem>  
-                                <para>sets the state to its initial seed</para> 
+                            <listitem>
+                                <para>sets the state to its initial seed</para>
                             </listitem>
                         </varlistentry>
                         <varlistentry>
                             <term>I = 0</term>
                             <listitem>
-                                <para>sets the state to its last (previous) seed (i.e. to the beginning  of the current segment)</para> 
+                                <para>sets the state to its last (previous) seed (i.e. to the beginning  of the current segment)</para>
                             </listitem>
                         </varlistentry>
                         <varlistentry>
                             <term>I = 1</term>
-                            <listitem>  
-                                <para>     
-                                    sets the state to a new seed <literal>W</literal> values from its last seed (i.e. to the beginning          
-                                    of the next segment) and resets the current segment parameters.    
+                            <listitem>
+                                <para>
+                                    sets the state to a new seed <literal>W</literal> values from its last seed (i.e. to the beginning
+                                    of the next segment) and resets the current segment parameters.
                                 </para>
                             </listitem>
                         </varlistentry>
             In the following example, we generate random numbers from various distributions and
             plot the associated histograms.
         </para>
-        <programlisting role="example"><![CDATA[ 
-// Returns a 400-by-800 matrix of random doubles, 
+        <programlisting role="example"><![CDATA[
+// Returns a 400-by-800 matrix of random doubles,
 // with normal distribution and average 0 and standard deviation 1.
 R = grand(400,800,"nor",0,1);
 scf();
@@ -806,8 +806,8 @@ xtitle("Normal random numbers from grand","X","Frequency");
             xtitle("Normal random numbers from grand","X","Frequency");
         </scilab:image>
         
-        <programlisting role="example"><![CDATA[ 
-// Returns a 400-by-800 matrix of random doubles, 
+        <programlisting role="example"><![CDATA[
+// Returns a 400-by-800 matrix of random doubles,
 // uniform in [0,1).
 R = grand(400,800,"def");
 scf();
@@ -820,8 +820,8 @@ xtitle("Uniform random numbers from grand","X","Frequency");
             xtitle("Uniform random numbers from grand","X","Frequency");
         </scilab:image>
         
-        <programlisting role="example"><![CDATA[ 
-// Returns a 400-by-800 matrix of random doubles, 
+        <programlisting role="example"><![CDATA[
+// Returns a 400-by-800 matrix of random doubles,
 // with Poisson distribution and average equal to 5.
 R = grand(400,800,"poi",5);
 scf();
@@ -838,7 +838,7 @@ xtitle("Poisson random numbers from grand","X","Frequency");
             In the following example, we generate random numbers from the exponential distribution and
             then compare the empirical with the theoretical distribution.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 lambda=1.6;
 N=100000;
 X = grand(1,N,"exp",lambda);
@@ -867,11 +867,11 @@ xtitle("Exponential random numbers from grand","X","Frequency");
             In the following example, we generate random numbers from the gamma distribution and
             then compare the empirical with the theoretical distribution.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 N=10000;
 A=10;
 B=4;
-R=grand(1,N,"gam",A,B); 
+R=grand(1,N,"gam",A,B);
 XS=gsort(R,"g","i")';
 PS=(1:N)'/N;
 P=cdfgam("PQ",XS,A*ones(XS),B*ones(XS));
@@ -885,7 +885,7 @@ xtitle("Cumulative distribution function of Gamma random numbers","X","F");
             N=10000;
             A=10;
             B=4;
-            R=grand(1,N,"gam",A,B); 
+            R=grand(1,N,"gam",A,B);
             XS=gsort(R,"g","i")';
             PS=(1:N)'/N;
             P=cdfgam("PQ",XS,A*ones(XS),B*ones(XS));
@@ -898,14 +898,14 @@ xtitle("Cumulative distribution function of Gamma random numbers","X","F");
         <para>
             In the following example, we generate 10 random integers in the [1,365] interval.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 grand(10,1,"uin",1,365)
  ]]></programlisting>
         <para>
             In the following example, we generate 12 permutations of the [1,2,...,7] set.
             The 12 permutations are stored column-by-column.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 grand(12,"prm",(1:7)')
  ]]></programlisting>
         <para>
@@ -913,7 +913,7 @@ grand(12,"prm",(1:7)')
             hypermatrix of random numbers from the "normal" distribution and plot the associated histograms.
             Showing the first and last layers.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 // Returns a 400-by-800-by-10 hypermatrix of random doubles,
 // with normal distribution, average 0 and standard deviation 1.
 // Showing the first and last layers.
index 4049fd1..9444f5f 100644 (file)
                     <para>
                         <literal>Y = grand(n, "prm", vect)</literal> génère <literal>n</literal> permutations aléatoire du
                         vecteur colonne (<literal>m x 1</literal>) <literal>vect</literal>.
+                        <varname>vect</varname> peut être un scalaire, vecteur, matrices ou hypermatrice de réels,
+                        complexes, entiers, booléens, polynômes ou chaînes de caractères; plein ou creux.
                         A cause de la structure de la pile, <varname>vect</varname> ne doit pas et ne peut pas être un vecteur ligne.
                         Cette fonctionnalité couvre la fonction Matlab <code>randperm()</code>,
                         car <code>randperm(n)</code> est équivalent à <code>grand(1,'prm',(1:n)')</code>
diff --git a/scilab/modules/randlib/macros/%b_grand.sci b/scilab/modules/randlib/macros/%b_grand.sci
new file mode 100644 (file)
index 0000000..2aec692
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab\r
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier\r
+//\r
+// This file must be used under the terms of the CeCILL.\r
+// This source file is licensed as described in the file COPYING, which\r
+// you should have received as part of this distribution.  The terms\r
+// are also available at\r
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt\r
+\r
+function y = %b_grand(n, prm, vect)\r
+    // Overload to use grand on boolean input\r
+\r
+    y = %grand_perm(floor(n), vect);\r
+\r
+endfunction\r
diff --git a/scilab/modules/randlib/macros/%c_grand.sci b/scilab/modules/randlib/macros/%c_grand.sci
new file mode 100644 (file)
index 0000000..34aacb6
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab\r
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier\r
+//\r
+// This file must be used under the terms of the CeCILL.\r
+// This source file is licensed as described in the file COPYING, which\r
+// you should have received as part of this distribution.  The terms\r
+// are also available at\r
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt\r
+\r
+function y = %c_grand(n, prm, vect)\r
+    // Overload to use grand on string input\r
+\r
+    y = %grand_perm(floor(n), vect);\r
+\r
+endfunction\r
diff --git a/scilab/modules/randlib/macros/%grand_perm.sci b/scilab/modules/randlib/macros/%grand_perm.sci
new file mode 100644 (file)
index 0000000..fbd3db5
--- /dev/null
@@ -0,0 +1,58 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab\r
+// Copyright (C) 2013 - Samuel Gougeon <sgougeon@free.fr>\r
+//\r
+// This file must be used under the terms of the CeCILL.\r
+// This source file is licensed as described in the file COPYING, which\r
+// you should have received as part of this distribution.  The terms\r
+// are also available at\r
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt\r
+\r
+function rep = %grand_perm(N, V)\r
+    // Returns N random permutations of V's components.\r
+    // V may be a scalar, a row or column vector, a matrix, or an hypermatrix.\r
+    // All data types are supported: Integers, reals, complexes, strings, polynomes..\r
+    // if V is a row, permutations are returned as N rows\r
+    // if V is a column, permutations are returned as N columns\r
+    // if V is a matrix or a true hypermatrix, permutations are returned\r
+    // through an additional dimension of size N.\r
+\r
+    // Author : Samuel Gougeon - 2010\r
+    // Version: 1.2\r
+    // Software: Scilab and related\r
+    //\r
+    // Tests:\r
+    // with a row of reals:\r
+    // m = grand(1, 6, "uin", 0, 10)\r
+    // grand_perm(3, m)\r
+    // // with a column of reals:\r
+    // grand_perm(4, m')\r
+    // // with a matrix of reals:\r
+    // M = grand(2, 5, "uin", 0, 10)\r
+    // grand_perm(3, M)\r
+    // // with strings:\r
+    // grand_perm(5, ["a" "b" "c" "d"])\r
+    // // with polynomes:\r
+    // p = (m'-%z)^2\r
+    // grand_perm(3, p)\r
+\r
+    s = size(V);\r
+    L = prod(s);\r
+\r
+    if L == 1 then\r
+        rep = V(ones(1, N));\r
+    else\r
+        //[tmp, k] = gsort(rand(L, N), "r", "i");\r
+        k = grand(N, "prm", (1:L).'); // Faster for large L\r
+        if length(s) < 3 then\r
+            if s(1) == 1 then\r
+                rep = matrix(V(k), [s(2) N]).';\r
+            elseif s(2) == 1 then\r
+                rep = matrix(V(k),[s(1) N]);\r
+            else\r
+                rep = matrix(V(k), [s N]);\r
+            end\r
+        else\r
+        rep = matrix(V(k), [s N]); end\r
+    end\r
+\r
+endfunction\r
diff --git a/scilab/modules/randlib/macros/%hm_grand.sci b/scilab/modules/randlib/macros/%hm_grand.sci
new file mode 100644 (file)
index 0000000..956ece6
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab\r
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier\r
+//\r
+// This file must be used under the terms of the CeCILL.\r
+// This source file is licensed as described in the file COPYING, which\r
+// you should have received as part of this distribution.  The terms\r
+// are also available at\r
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt\r
+\r
+function y = %hm_grand(n, prm, vect)\r
+    // Overload to use grand on hypermatrix input\r
+\r
+    y = %grand_perm(floor(n), vect);\r
+\r
+endfunction\r
diff --git a/scilab/modules/randlib/macros/%i_grand.sci b/scilab/modules/randlib/macros/%i_grand.sci
new file mode 100644 (file)
index 0000000..b82922e
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab\r
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier\r
+//\r
+// This file must be used under the terms of the CeCILL.\r
+// This source file is licensed as described in the file COPYING, which\r
+// you should have received as part of this distribution.  The terms\r
+// are also available at\r
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt\r
+\r
+function y = %i_grand(n, prm, vect)\r
+    // Overload to use grand on integer input\r
+\r
+    y = %grand_perm(floor(n), vect);\r
+\r
+endfunction\r
diff --git a/scilab/modules/randlib/macros/%p_grand.sci b/scilab/modules/randlib/macros/%p_grand.sci
new file mode 100644 (file)
index 0000000..b2e2708
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab\r
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier\r
+//\r
+// This file must be used under the terms of the CeCILL.\r
+// This source file is licensed as described in the file COPYING, which\r
+// you should have received as part of this distribution.  The terms\r
+// are also available at\r
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt\r
+\r
+function y = %p_grand(n, prm, vect)\r
+    // Overload to use grand on polynomial input\r
+\r
+    y = %grand_perm(floor(n), vect);\r
+\r
+endfunction\r
diff --git a/scilab/modules/randlib/macros/%s_grand.sci b/scilab/modules/randlib/macros/%s_grand.sci
new file mode 100644 (file)
index 0000000..1e33bae
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab\r
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier\r
+//\r
+// This file must be used under the terms of the CeCILL.\r
+// This source file is licensed as described in the file COPYING, which\r
+// you should have received as part of this distribution.  The terms\r
+// are also available at\r
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt\r
+\r
+function y = %s_grand(n, prm, vect)\r
+    // Overload to use grand on complex input\r
+\r
+    y = %grand_perm(floor(n), vect);\r
+\r
+endfunction\r
diff --git a/scilab/modules/randlib/macros/%sp_grand.sci b/scilab/modules/randlib/macros/%sp_grand.sci
new file mode 100644 (file)
index 0000000..bb039ec
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab\r
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier\r
+//\r
+// This file must be used under the terms of the CeCILL.\r
+// This source file is licensed as described in the file COPYING, which\r
+// you should have received as part of this distribution.  The terms\r
+// are also available at\r
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt\r
+\r
+function y = %sp_grand(n, prm, vect)\r
+    // Overload to use grand on sparse input\r
+\r
+    y = %grand_perm(floor(n), vect);\r
+\r
+endfunction\r
index a202dd7..8f35390 100644 (file)
@@ -11,4 +11,4 @@ if (isdef("genlib") == %f) then
     exec(SCI+"/modules/functions/scripts/buildmacros/loadgenlib.sce");
 end
 
-//genlib("randliblib","SCI/modules/randlib/macros",%f,%t);
+genlib("randliblib","SCI/modules/randlib/macros",%f,%t);
index 8f6576b..513c904 100644 (file)
@@ -30,10 +30,10 @@ Source: modules\{#RANDLIB}\etc\{#RANDLIB}.start; DestDir: {app}\modules\{#RANDLI
 ;
 ;Source: modules\{#RANDLIB}\includes\*.h; DestDir: {app}\modules\{#RANDLIB}\includes; Components: {#COMPN_SCILAB}
 ;
-;Source: modules\{#RANDLIB}\macros\lib; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
-;Source: modules\{#RANDLIB}\macros\names; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
-;Source: modules\{#RANDLIB}\macros\*.bin; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
-;Source: modules\{#RANDLIB}\macros\*.sci; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
+Source: modules\{#RANDLIB}\macros\lib; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
+Source: modules\{#RANDLIB}\macros\names; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
+Source: modules\{#RANDLIB}\macros\*.bin; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
+Source: modules\{#RANDLIB}\macros\*.sci; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
 Source: modules\{#RANDLIB}\macros\buildmacros.sce; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
 Source: modules\{#RANDLIB}\macros\buildmacros.bat; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
 Source: modules\{#RANDLIB}\macros\cleanmacros.bat; DestDir: {app}\modules\{#RANDLIB}\macros; Flags: recursesubdirs; Components: {#COMPN_SCILAB}
index caeb74a..3c77f69 100644 (file)
@@ -1,5 +1,7 @@
 /*
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2013 - Scilab Enterprises - Paul Bignier: added support for complexes, polynomials,
+*                                                         integers, booleans, strings and sparses.
 * Copyright (C) ENPC
 *
 * This file must be used under the terms of the CeCILL.
@@ -1016,7 +1018,7 @@ int sci_Rand(char *fname, unsigned long fname_len)
     }
     else if ( strcmp(cstk(ls), "prm") == 0)
     {
-        int nn;
+        int nn, Cmplx, *header;
         if ( suite != 3 || ResL * ResC != 1)
         {
             Scierror(999, _("%s: Wrong value for input argument: Number of random simulation expected.\n"), fname);
@@ -1028,11 +1030,39 @@ int sci_Rand(char *fname, unsigned long fname_len)
             Scierror(999, _("Missing vect for random permutation\n"));
             return 0;
         }
-        GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( n1 != 1)
+        switch (GetType(suite))
         {
-            Scierror(999, _("%s: Wrong type for input argument: Column vector expected.\n"), fname);
-            return 0;
+            case 1:
+                header = (int *)GetData(suite);
+                Cmplx = header[3];
+                if (Cmplx == 0)
+                {
+                    GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+                    if ( n1 != 1)
+                    {
+                        OverLoad(suite);
+                        return 0;
+                    }
+                    break;
+                }
+                else
+                {
+                    OverLoad(suite); // Complex, call %s_grand
+                    return 0;
+                    break;
+                }
+            case 2:  // Polynomial, call %p_grand
+            case 4:  // Boolean,    call %b_grand
+            case 5:  // Sparse,     call %sp_grand
+            case 8:  // Integer,    call %i_grand
+            case 10: // String,     call %c_grand
+            case 17: // String,     call %c_grand
+                OverLoad(suite);
+                return 0;
+                break;
+            default:
+                Scierror(999, _("%s: Wrong type for input argument: Matrix (full or sparse) or Hypermatrix of Reals, Complexes, Integers, Booleans, Strings or Polynomials expected.\n"), fname);
+                return 0;
         }
         CreateVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &nn, &lr);
         for ( i = 0 ; i < nn ; i++)
diff --git a/scilab/modules/randlib/tests/nonreg_tests/bug_6690.dia.ref b/scilab/modules/randlib/tests/nonreg_tests/bug_6690.dia.ref
new file mode 100644 (file)
index 0000000..b5afacd
--- /dev/null
@@ -0,0 +1,178 @@
+// =============================================================================
+// 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 -->
+//
+// Set the seed to always get the same random numbers
+rand("seed", 0);
+grand("setsd", 0);
+//
+// 1. Permute some column vectors, and check that the output is basically correct.
+//
+// With Complexes.
+//
+X = (2:10)';
+P = grand(5,"prm",X*%i);
+assert_checkequal ( isreal(P) , %f );
+assert_checkequal ( typeof(P) , "constant" );
+assert_checkequal ( size(P) , [9 5] );
+assert_checkequal ( gsort(P,"r","i") , X*%i*ones(1,5) );
+//
+// With Integers.
+//
+P = grand(5,"prm",int8(X));
+assert_checkequal ( typeof(P) , "int8" );
+assert_checkequal ( size(P) , [9 5] );
+assert_checkequal ( gsort(P,"r","i") , int8(X)*ones(1,5) );
+//
+P = grand(5,"prm",int16(X));
+assert_checkequal ( typeof(P) , "int16" );
+assert_checkequal ( size(P) , [9 5] );
+assert_checkequal ( gsort(P,"r","i") , int16(X)*ones(1,5) );
+//
+P = grand(5,"prm",int32(X));
+assert_checkequal ( typeof(P) , "int32" );
+assert_checkequal ( size(P) , [9 5] );
+assert_checkequal ( gsort(P,"r","i") , int32(X)*ones(1,5) );
+//
+// With Strings.
+//
+X = string(X);
+P = grand(1,"prm",X);
+assert_checkequal ( typeof(P) , "string" );
+assert_checkequal ( size(P) , size(X) );
+assert_checkequal ( P , ["3" "9" "5" "7" "10" "6" "8" "2" "4"]');
+//
+// With Booleans.
+//
+X = [%f %t %t %t %t %f]';
+P = grand(1,"prm",X);
+assert_checkequal ( typeof(P) , "boolean" );
+assert_checkequal ( size(P) , size(X) );
+assert_checkequal ( P , [%t %f %t %t %f %t]' );
+//
+// With Polynomials.
+//
+s = poly(0,"s");
+X = [0 s 1+s 1+s^2 s^4]';
+P = grand(1,"prm",X);
+assert_checkequal ( typeof(P) , "polynomial" );
+assert_checkequal ( size(P) , size(X) );
+assert_checkequal ( P , [1+s^2 1+s s s^4 0]' );
+//
+// With Sparses.
+//
+X = sparse([1 2 3 0 0 0 0 5 6])';
+P = grand(1,"prm",X);
+assert_checkequal ( typeof(P) , "sparse" );
+assert_checkequal ( size(P) , size(X) );
+assert_checkequal ( P , sparse([0 0 0 3 5 6 2 1 0])' );
+//
+// 2. With row vectors / matrices.
+//
+X = 2:10;
+P = grand(1,"prm",X);
+assert_checkequal ( size(P) , size(X) );
+assert_checkequal ( gsort(P,"g","i") , X );
+X(2, :) = 12:20;
+P = grand(2,"prm",X*%i);
+refP = [
+13  9   20  3   10  2   4  5  15
+19  14  6   18  12  16  7  8  17 ];
+refP(:, :, 2) = [
+14  7  8  9   13  10  15  19  4
+12  5  2  17  6   16  18  3   20 ];
+assert_checkequal ( size(P) , [size(X) 2] );
+assert_checkequal ( P, refP*%i );
+//
+// With Integers.
+//
+X_int = int32(X);
+P = grand(2,"prm",X_int);
+refP = int32([
+5  17  20  7   15  10  2   13  4
+3  16  8   12  19  9   18  14  6 ]);
+refP(:, :, 2) = int32([
+16  13  6  2  20  19  18  14  7
+9   12  3  8  15  17  10  4   5 ]);
+assert_checkequal ( size(P) , [size(X_int) 2] );
+assert_checkequal ( P, refP );
+//
+// With Strings.
+//
+X_str = string(X);
+P = grand(2,"prm",X_str);
+refP = string([
+19  7   14  10  18  17  5  3  4
+9   15  2   20  13  12  6  8  16 ]);
+refP(:, :, 2) = string([
+13  20  9   6  8   14  3  4   16
+15  5   19  2  18  12  7  10  17 ]);
+assert_checkequal ( size(P) , [size(X_str) 2] );
+assert_checkequal ( P, refP );
+//
+// With Hypermatrices.
+//
+X(:, :, 2) = X+20;
+P = grand(2,"prm",X);
+assert_checkequal ( size(P) , [size(X) 2] );
+assert_checkequal ( members(P, 2:40), ones(P) );
+//
+// Of Complexes.
+//
+P = grand(2,"prm",X*%i);
+assert_checkequal ( size(P) , [size(X) 2] );
+assert_checkequal ( members(P, (2:40)*%i), ones(P) );
+//
+// Of Integers.
+//
+P = grand(2,"prm",int16(X));
+assert_checkequal ( size(P) , [size(X) 2] );
+assert_checkequal ( members(P, int16(2:40)), ones(P) );
+//
+// Of Strings.
+//
+Xs = string(X);
+Ps = grand(2,"prm",Xs);
+assert_checkequal ( size(Ps) , [size(Xs) 2] );
+assert_checkequal ( members(Ps, string(2:40)), ones(Ps) );
+//
+// Of Booleans.
+//
+Xb = floor(10*rand(2, 9, 2));
+Xb = Xb<5;
+Pb = grand(2,"prm",Xb);
+refPb = gsort(Pb+0,"g","i");
+assert_checkequal ( size(Pb) , [size(Xb) 2] );
+assert_checkequal ( refPb(1:36), zeros(36, 1) );
+assert_checkequal ( refPb(37:72), ones(36, 1) );
+//
+// Of Ploynomials.
+//
+Xp = matrix(X(:)+s, 2, 9, 2);
+Pp = grand(2,"prm",Xp);
+refPp = matrix(Pp(:)-s, 2, 9, 2, 2);
+refPp = gsort(coeff(refPp(:)),"g","i");
+assert_checkequal ( size(Pp) , [size(Xp) 2] );
+assert_checkequal ( members(2:40, refPp), 2*([ones(1,9) 0 ones(1,9) 0 ones(1,9) 0 ones(1,9)]) );
+//
+// Sparse hypermatrices do not exist yet.
+//
+//
+// Bug #6689
+//
+X = [%i 1-%i 2+3*%i].';
+P = grand(4, "prm", X);
+refP = [
+2+3*%i  %i      2+3*%i  1-%i
+%i      2+3*%i  %i      %i
+1-%i    1-%i    1-%i    2+3*%i ];
+assert_checkequal ( typeof(P) , "constant" );
+assert_checkequal ( size(P) , [3 4] );
+assert_checkequal ( P , refP );
+refMsg = msprintf(_("%s: Wrong type for input argument: Matrix (full or sparse) or Hypermatrix of Reals, Complexes, Integers, Booleans, Strings or Polynomials expected.\n"), "grand");
+assert_checkerror("grand(2, ""prm"", list())", refMsg);
diff --git a/scilab/modules/randlib/tests/nonreg_tests/bug_6690.tst b/scilab/modules/randlib/tests/nonreg_tests/bug_6690.tst
new file mode 100644 (file)
index 0000000..331fa85
--- /dev/null
@@ -0,0 +1,182 @@
+// =============================================================================
+// 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 -->
+//
+// Set the seed to always get the same random numbers
+rand("seed", 0);
+grand("setsd", 0);
+
+//
+// 1. Permute some column vectors, and check that the output is basically correct.
+//
+// With Complexes.
+//
+X = (2:10)';
+P = grand(5,"prm",X*%i);
+assert_checkequal ( isreal(P) , %f );
+assert_checkequal ( typeof(P) , "constant" );
+assert_checkequal ( size(P) , [9 5] );
+assert_checkequal ( gsort(P,"r","i") , X*%i*ones(1,5) );
+//
+// With Integers.
+//
+P = grand(5,"prm",int8(X));
+assert_checkequal ( typeof(P) , "int8" );
+assert_checkequal ( size(P) , [9 5] );
+assert_checkequal ( gsort(P,"r","i") , int8(X)*ones(1,5) );
+//
+P = grand(5,"prm",int16(X));
+assert_checkequal ( typeof(P) , "int16" );
+assert_checkequal ( size(P) , [9 5] );
+assert_checkequal ( gsort(P,"r","i") , int16(X)*ones(1,5) );
+//
+P = grand(5,"prm",int32(X));
+assert_checkequal ( typeof(P) , "int32" );
+assert_checkequal ( size(P) , [9 5] );
+assert_checkequal ( gsort(P,"r","i") , int32(X)*ones(1,5) );
+//
+// With Strings.
+//
+X = string(X);
+P = grand(1,"prm",X);
+assert_checkequal ( typeof(P) , "string" );
+assert_checkequal ( size(P) , size(X) );
+assert_checkequal ( P , ["3" "9" "5" "7" "10" "6" "8" "2" "4"]');
+//
+// With Booleans.
+//
+X = [%f %t %t %t %t %f]';
+P = grand(1,"prm",X);
+assert_checkequal ( typeof(P) , "boolean" );
+assert_checkequal ( size(P) , size(X) );
+assert_checkequal ( P , [%t %f %t %t %f %t]' );
+//
+// With Polynomials.
+//
+s = poly(0,"s");
+X = [0 s 1+s 1+s^2 s^4]';
+P = grand(1,"prm",X);
+assert_checkequal ( typeof(P) , "polynomial" );
+assert_checkequal ( size(P) , size(X) );
+assert_checkequal ( P , [1+s^2 1+s s s^4 0]' );
+//
+// With Sparses.
+//
+X = sparse([1 2 3 0 0 0 0 5 6])';
+P = grand(1,"prm",X);
+assert_checkequal ( typeof(P) , "sparse" );
+assert_checkequal ( size(P) , size(X) );
+assert_checkequal ( P , sparse([0 0 0 3 5 6 2 1 0])' );
+
+//
+// 2. With row vectors / matrices.
+//
+X = 2:10;
+P = grand(1,"prm",X);
+assert_checkequal ( size(P) , size(X) );
+assert_checkequal ( gsort(P,"g","i") , X );
+X(2, :) = 12:20;
+P = grand(2,"prm",X*%i);
+refP = [
+13  9   20  3   10  2   4  5  15
+19  14  6   18  12  16  7  8  17 ];
+refP(:, :, 2) = [
+14  7  8  9   13  10  15  19  4
+12  5  2  17  6   16  18  3   20 ];
+assert_checkequal ( size(P) , [size(X) 2] );
+assert_checkequal ( P, refP*%i );
+//
+// With Integers.
+//
+X_int = int32(X);
+P = grand(2,"prm",X_int);
+refP = int32([
+5  17  20  7   15  10  2   13  4
+3  16  8   12  19  9   18  14  6 ]);
+refP(:, :, 2) = int32([
+16  13  6  2  20  19  18  14  7
+9   12  3  8  15  17  10  4   5 ]);
+assert_checkequal ( size(P) , [size(X_int) 2] );
+assert_checkequal ( P, refP );
+//
+// With Strings.
+//
+X_str = string(X);
+P = grand(2,"prm",X_str);
+refP = string([
+19  7   14  10  18  17  5  3  4
+9   15  2   20  13  12  6  8  16 ]);
+refP(:, :, 2) = string([
+13  20  9   6  8   14  3  4   16
+15  5   19  2  18  12  7  10  17 ]);
+assert_checkequal ( size(P) , [size(X_str) 2] );
+assert_checkequal ( P, refP );
+//
+// With Hypermatrices.
+//
+X(:, :, 2) = X+20;
+P = grand(2,"prm",X);
+assert_checkequal ( size(P) , [size(X) 2] );
+assert_checkequal ( members(P, 2:40), ones(P) );
+//
+// Of Complexes.
+//
+P = grand(2,"prm",X*%i);
+assert_checkequal ( size(P) , [size(X) 2] );
+assert_checkequal ( members(P, (2:40)*%i), ones(P) );
+//
+// Of Integers.
+//
+P = grand(2,"prm",int16(X));
+assert_checkequal ( size(P) , [size(X) 2] );
+assert_checkequal ( members(P, int16(2:40)), ones(P) );
+//
+// Of Strings.
+//
+Xs = string(X);
+Ps = grand(2,"prm",Xs);
+assert_checkequal ( size(Ps) , [size(Xs) 2] );
+assert_checkequal ( members(Ps, string(2:40)), ones(Ps) );
+//
+// Of Booleans.
+//
+Xb = floor(10*rand(2, 9, 2));
+Xb = Xb<5;
+Pb = grand(2,"prm",Xb);
+refPb = gsort(Pb+0,"g","i");
+assert_checkequal ( size(Pb) , [size(Xb) 2] );
+assert_checkequal ( refPb(1:36), zeros(36, 1) );
+assert_checkequal ( refPb(37:72), ones(36, 1) );
+//
+// Of Ploynomials.
+//
+Xp = matrix(X(:)+s, 2, 9, 2);
+Pp = grand(2,"prm",Xp);
+refPp = matrix(Pp(:)-s, 2, 9, 2, 2);
+refPp = gsort(coeff(refPp(:)),"g","i");
+assert_checkequal ( size(Pp) , [size(Xp) 2] );
+assert_checkequal ( members(2:40, refPp), 2*([ones(1,9) 0 ones(1,9) 0 ones(1,9) 0 ones(1,9)]) );
+//
+// Sparse hypermatrices do not exist yet.
+//
+
+//
+// Bug #6689
+//
+X = [%i 1-%i 2+3*%i].';
+P = grand(4, "prm", X);
+refP = [
+2+3*%i  %i      2+3*%i  1-%i
+%i      2+3*%i  %i      %i
+1-%i    1-%i    1-%i    2+3*%i ];
+assert_checkequal ( typeof(P) , "constant" );
+assert_checkequal ( size(P) , [3 4] );
+assert_checkequal ( P , refP );
+
+refMsg = msprintf(_("%s: Wrong type for input argument: Matrix (full or sparse) or Hypermatrix of Reals, Complexes, Integers, Booleans, Strings or Polynomials expected.\n"), "grand");
+assert_checkerror("grand(2, ""prm"", list())", refMsg);