*Bug #5207 fixed - grand() can now return a hypermatrix 54/11454/22
Paul BIGNIER [Mon, 6 May 2013 14:35:07 +0000 (16:35 +0200)]
Allowed grand() to take multiple size arguments 'm, n, o,...'
or one hypermatrix 'X'

To do that easily, wrote two macros to reorientate grand()

Change-Id: Ie714faae29cb8663211a5079ebd3a2b1ed6697b8

15 files changed:
SEP/SEP_094_grand_n_dimensions.odt [new file with mode: 0644]
scilab/CHANGES_5.5.X
scilab/modules/api_scilab/includes/api_hypermat.h
scilab/modules/api_scilab/src/cpp/api_hypermat.cpp
scilab/modules/randlib/help/en_US/grand.xml
scilab/modules/randlib/help/fr_FR/grand.xml
scilab/modules/randlib/macros/buildmacros.sce
scilab/modules/randlib/sci_gateway/c/sci_grand.c
scilab/modules/randlib/sci_gateway/randlib_gateway.xml
scilab/modules/randlib/tests/nonreg_tests/bug_5207.dia.ref [new file with mode: 0644]
scilab/modules/randlib/tests/nonreg_tests/bug_5207.tst [new file with mode: 0644]
scilab/modules/randlib/tests/nonreg_tests/bug_9584.dia.ref
scilab/modules/randlib/tests/nonreg_tests/bug_9584.tst
scilab/modules/randlib/tests/unit_tests/grand_hypermat.dia.ref [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grand_hypermat.tst [new file with mode: 0644]

diff --git a/SEP/SEP_094_grand_n_dimensions.odt b/SEP/SEP_094_grand_n_dimensions.odt
new file mode 100644 (file)
index 0000000..fdba058
Binary files /dev/null and b/SEP/SEP_094_grand_n_dimensions.odt differ
index 1031506..63880da 100644 (file)
@@ -85,6 +85,8 @@ Bug fixes
 
 * Bug #4731 fixed - lqr() failed when time domain of input was a number.
 
+* Bug #5207 fixed - grand() can now return a hypermatrix.
+
 * Bug #5365 fixed - makecell help page was in the "compatibility functions" directory
                     instead of being in "data_structures".
 
index f399890..39a0dc2 100644 (file)
@@ -235,6 +235,7 @@ extern "C" {
      * @return if the operation succeeded ( 0 ) or not ( !0 )
      */
     SciErr createHypermatOfDouble(void* _pvCtx, int _iVar, int *_dims, int _ndims, const double* _pdblReal);
+    SciErr allocHypermatOfDouble(void *_pvCtx, int _iVar, int * _dims, int _ndims, double** _pdblReal);
 
     /**
      * Create a complex hypermatrix
index 85775fc..e240730 100644 (file)
@@ -518,13 +518,37 @@ SciErr createComplexHypermatOfPoly(void *_pvCtx, int _iVar, char* _pstVarName, i
     return sciErr;
 }
 
+SciErr allocHypermatOfDouble(void *_pvCtx, int _iVar, int * _dims, int _ndims, double** _pdblReal)
+{
+    int * _piAddress = NULL;
+    int iNbElements = 1;
+    SciErr sciErr;
+
+    sciErr = createEmptyHypermat(_pvCtx, _iVar, _dims, _ndims, &_piAddress);
+    if (sciErr.iErr)
+    {
+        return sciErr;
+    }
+
+    for (int i = 0; i < _ndims; i++)
+    {
+        iNbElements *= _dims[i];
+    }
+
+    sciErr = allocMatrixOfDoubleInList(_pvCtx, _iVar, _piAddress, 3, iNbElements, 1, _pdblReal);
+    if (sciErr.iErr)
+    {
+        return sciErr;
+    }
+
+    return sciErr;
+}
+
 SciErr createHypermatOfDouble(void *_pvCtx, int _iVar, int * _dims, int _ndims, const double * _pdblReal)
 {
     int * _piAddress = NULL;
     int iNbElements = 1;
     SciErr sciErr;
-    sciErr.iErr = 0;
-    sciErr.iMsgCount = 0;
 
     sciErr = createEmptyHypermat(_pvCtx, _iVar, _dims, _ndims, &_piAddress);
     if (sciErr.iErr)
index 4d0f51b..8870bd9 100644 (file)
@@ -3,7 +3,8 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) Jean-Philippe Chancelier and Bruno Pincon
  * Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
- * 
+ * Copyright (C) 2013 - Samuel GOUGEON : extension to hypermatrices
+ *
  * 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
@@ -27,7 +28,7 @@
             Y = grand(m, n, "exp", Av)
             Y = grand(m, n, "f", Dfn, Dfd)
             Y = grand(m, n, "nf", Dfn, Dfd, Xnon)
-            Y = grand(m, n, "gam", shape, rate)
+            Y = grand(m, n, "gam", shape, scale)
             Y = grand(m, n, "nor", Av, Sd)
             Y = grand(m, n, "geom", p)
             Y = grand(m, n, "poi", mu)
             Y = grand(m, n, "uin", Low, High)
             Y = grand(m, n, "lgi")
             
+            Y = grand(m, n, o,..,"..",...)
             Y = grand(X, ...)
             
-            Y = grand(n,  "mn", Mean, Cov)
-            Y = grand(n,  "markov", P, x0)
-            Y = grand(n,  "mul", nb, P)
-            Y = grand(n,  "prm", vect)
+            Y = grand(n, "mn", Mean, Cov)
+            Y = grand(n, "markov", P, x0)
+            Y = grand(n, "mul", nb, P)
+            Y = grand(n, "prm", vect)
             
             S = grand("getgen")
             grand("setgen", gen)
         <title>Arguments</title>
         <variablelist>
             <varlistentry>
-                <term>m, n</term>
+                <term>m, n, o</term>
                 <listitem>
                     <para>
-                        integers, size of the wanted matrix <varname>Y</varname>.
+                        integers, size of the wanted matrix / hypermatrix <varname>Y</varname>.
                     </para>
                 </listitem>
             </varlistentry>
@@ -76,7 +78,7 @@
                 <term>X</term>
                 <listitem>
                     <para>
-                        a matrix whom only the dimensions (say <varname>m</varname>-by-<varname>n</varname>)
+                        a matrix or hypermatrix whom only the dimensions (say <varname>m</varname>-by-<varname>n</varname>)
                         are used.
                     </para>
                 </listitem>
@@ -85,7 +87,7 @@
                 <term>Y</term>
                 <listitem>
                     <para>
-                        a <varname>m</varname>-by-<varname>n</varname> matrix of doubles, with random entries.
+                        depending on the input, a matrix or hypermatrix of doubles, with random entries.
                     </para>
                 </listitem>
             </varlistentry>
                 Y = grand(m, n, "exp", Av)
                 Y = grand(m, n, "f", Dfn, Dfd)
                 Y = grand(m, n, "nf", Dfn, Dfd, Xnon)
-                Y = grand(m, n, "gam", shape, rate)
+                Y = grand(m, n, "gam", shape, scale)
                 Y = grand(m, n, "nor", Av, Sd)
                 Y = grand(m, n, "geom", p)
                 Y = grand(m, n, "poi", mu)
              ]]></programlisting>
         </para>
         <para>
-            produce a <varname>m</varname>-by-<varname>n</varname> matrix
-            with random entries.
+            produce a <varname>m</varname>-by-<varname>n</varname> matrix with random entries.
+            
+            All these calling sequences can be extended to create a random hypermatrix with more than
+            2 dimensions specified as integers listed before the type of statistical distribution:
+        </para>
+        <para>
+            <programlisting role="no-scilab-exec"><![CDATA[
+                Y = grand(m, n, o, ..., "..", ...)
+            ]]></programlisting>
         </para>
         <para>
-            The calling sequence:
+            The sizes of the expected random vector, matrix or hypermatrix can alternatively be specified with
         </para>
         <para>
             <programlisting role="no-scilab-exec"><![CDATA[
             ]]></programlisting>
         </para>
         <para>
-            where <varname>X</varname> is a <varname>m</varname>-by-<varname>n</varname> matrix,
-            produce the same effect.
-            In this case, only the size of <varname>X</varname> is used.
+            where <literal>X</literal> of sizes <literal>m</literal>-by-<literal>n</literal>...
+            is a matrix or an hypermatrix only used as template.
         </para>
         <para>
             The calling sequences:
                 <term>gamma</term>
                 <listitem>
                     <para>
-                        <code>Y = grand(m, n, "gam", shape, rate)</code>
+                        <code>Y = grand(m, n, "gam", shape, scale)</code>
                         generates random variates from the gamma distribution with
                         parameters <varname>shape</varname> (<literal>real</literal> &gt; <literal>0</literal>) and
-                        <varname>rate</varname> (<literal>real</literal> &gt; <literal>0</literal>). The density of the
+                        <varname>scale</varname> (<literal>real</literal> &gt; <literal>0</literal>). The density of the
                         gamma distribution is :
                     </para>
                     <para>
                         <latex>
-                            \dfrac{ \textrm{rate}^{\textrm{shape}} x^{\textrm{shape}-1} e^{-\textrm{rate} x}}{\gamma(\textrm{shape}) }
+                            \dfrac{ \textrm{scale}^{\textrm{shape}} x^{\textrm{shape}-1} e^{-\textrm{scale} x}}{\gamma(\textrm{shape}) }
                         </latex>
                     </para>
                     <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
                         <varname>Low</varname> and <varname>High</varname>
                         (included). <varname>High</varname> and
                         <varname>Low</varname> must be integers such that
-                        <latex><![CDATA[(\textrm{High}-\textrm{Low}+1) < 2\,147\,483\,561]]></latex>.
+                        <literal>(High-Low+1) &lt; 2,147,483,561</literal>.
                     </para>
                 </listitem>
             </varlistentry>
                     <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>
@@ -895,6 +903,32 @@ grand(10,1,"uin",1,365)
         <programlisting role="example"><![CDATA[ 
 grand(12,"prm",(1:7)')
  ]]></programlisting>
+        <para>
+            In the following example, we generate a <varname>10</varname>-by-<varname>10</varname>-by-<varname>10</varname>
+            hypermatrix of random numbers from the "normal" distribution and plot the associated histograms.
+            Showing the first and last layers.
+        </para>
+        <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.
+R = grand(10,10,10,"nor",0,1);
+subplot(1,2,1)
+hist3d(R(:,:,1));
+xtitle("Layer 1");
+subplot(1,2,2)
+hist3d(R(:,:,10));
+xtitle("Layer 10");
+ ]]></programlisting>
+        <scilab:image localized="true">
+            R = grand(10,10,10,"nor",0,1);
+            subplot(1,2,1)
+            hist3d(R(:,:,1));
+            xtitle("Layer 1");
+            subplot(1,2,2)
+            hist3d(R(:,:,10));
+            xtitle("Layer 10");
+        </scilab:image>
     </refsection>
     <refsection>
         <title>Get predictible or less predictible numbers</title>
index d291a89..0181e7b 100644 (file)
@@ -3,7 +3,8 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) Jean-Philippe Chancelier and Bruno Pincon
  * Copyright (C) 2011 - DIGITEO - Michael Baudin
- * 
+ * Copyright (C) 2013 - Samuel GOUGEON : extension aux hypermatrices
+ *
  * 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
     <refsynopsisdiv>
         <title>Séquence d'appel</title>
         <synopsis>
-            Y=grand(m,n,"bet",A,B)
-            Y=grand(m,n,"bin",N,p)
-            Y=grand(m,n,"nbn",N,p)
-            Y=grand(m,n,"chi", Df)
-            Y=grand(m,n,"nch",Df,Xnon)
-            Y=grand(m,n,"exp",Av)
-            Y=grand(m,n,"f",Dfn,Dfd)
-            Y=grand(m,n,"nf",Dfn,Dfd,Xnon)
-            Y=grand(m,n,"gam",shape,scale)
-            Y=grand(m,n,"nor",Av,Sd)
-            Y=grand(m,n,"geom", p)
-            Y=grand(m,n,"poi",mu)
-            Y=grand(m,n,"def")
-            Y=grand(m,n,"unf",Low,High)
-            Y=grand(m,n,"uin",Low,High)
-            Y=grand(m,n,"lgi")
+            Y = grand(m, n, "bet", A, B)
+            Y = grand(m, n, "bin", N, p)
+            Y = grand(m, n, "nbn", N, p)
+            Y = grand(m, n, "chi", Df)
+            Y = grand(m, n, "nch", Df, Xnon)
+            Y = grand(m, n, "exp", Av)
+            Y = grand(m, n, "f", Dfn, Dfd)
+            Y = grand(m, n, "nf", Dfn, Dfd, Xnon)
+            Y = grand(m, n, "gam", shape, scale)
+            Y = grand(m, n, "nor", Av, Sd)
+            Y = grand(m, n, "geom", p)
+            Y = grand(m, n, "poi", mu)
+            Y = grand(m, n, "def")
+            Y = grand(m, n, "unf", Low, High)
+            Y = grand(m, n, "uin", Low, High)
+            Y = grand(m, n, "lgi")
             
-            Y=grand(X,...)
+            Y = grand(m, n, o,..,"..",...)
+            Y = grand(X,...)
             
-            Y=grand(n,"mn",Mean,Cov)
-            Y=grand(n,"markov",P,x0)
-            Y=grand(n,"mul",nb,P)
-            Y=grand(n,"prm",vect)
+            Y = grand(n, "mn", Mean, Cov)
+            Y = grand(n, "markov", P, x0)
+            Y = grand(n, "mul", nb, P)
+            Y = grand(n, "prm", vect)
             
-            S=grand("getgen")
-            grand("setgen",gen)
+            S = grand("getgen")
+            grand("setgen", gen)
             
-            S=grand("phr2sd",phrase)
+            S = grand("phr2sd", phrase)
             
-            S=grand("getsd")
-            grand("setsd",S)
+            S = grand("getsd")
+            grand("setsd", S)
             
-            grand("setcgn",G)
-            S=grand("getcgn")
+            grand("setcgn", G)
+            S = grand("getcgn")
             
-            grand("initgn",I)
+            grand("initgn", I)
             
-            grand("setall",s1,s2,s3,s4)
+            grand("setall", s1, s2, s3, s4)
             
-            grand("advnst",K)
+            grand("advnst", K)
         </synopsis>
     </refsynopsisdiv>
     <refsection>
         <title>Paramètres</title>
         <variablelist>
             <varlistentry>
-                <term>m, n</term>
+                <term>m, n, o</term>
                 <listitem>
                     <para>
                         entiers, dimensions de la matrice de nombres aléatoires à obtenir <literal>Y</literal>
@@ -76,7 +78,7 @@
                 <term>X </term>
                 <listitem>
                     <para>
-                        une matrice (ou un vecteur) dont seules les dimensions (<literal>m</literal>-par-<literal>n</literal>) sont utilisées
+                        un vecteur, une matrice ou une hypermatrice dont seules les dimensions (<literal>m</literal> x <literal>n</literal> x ...) sont utilisées
                     </para>
                 </listitem>
             </varlistentry>
@@ -84,7 +86,7 @@
                 <term>Y</term>
                 <listitem>
                     <para>
-                        une matrice de doubles de taille <literal>m</literal>-par-<literal>n</literal>, les nombres aléatoires
+                        Vecteur, matrice ou hypermatrice des nombres aléatoires générés, de taille <literal>m</literal> x <literal>n</literal> x ... (encodage décimal)
                     </para>
                 </listitem>
             </varlistentry>
             Les séquences d'appel :
         </para>
         <screen>
-            Y=grand(m,n,"bet",A,B)
-            Y=grand(m,n,"bin",N,p)
-            Y=grand(m,n,"nbn",N,p)
-            Y=grand(m,n,"chi", Df)
-            Y=grand(m,n,"nch",Df,Xnon)
-            Y=grand(m,n,"exp",Av)
-            Y=grand(m,n,"f",Dfn,Dfd)
-            Y=grand(m,n,"nf",Dfn,Dfd,Xnon)
-            Y=grand(m,n,"gam",shape,scale)
-            Y=grand(m,n,"nor",Av,Sd)
-            Y=grand(m,n,"geom", p)
-            Y=grand(m,n,"poi",mu)
-            Y=grand(m,n,"def")
-            Y=grand(m,n,"unf",Low,High)
-            Y=grand(m,n,"uin",Low,High)
-            Y=grand(m,n,"lgi")
+            Y = grand(m, n, "bet", A, B)
+            Y = grand(m, n, "bin", N, p)
+            Y = grand(m, n, "nbn", N, p)
+            Y = grand(m, n, "chi",  Df)
+            Y = grand(m, n, "nch", Df, Xnon)
+            Y = grand(m, n, "exp", Av)
+            Y = grand(m, n, "f", Dfn, Dfd)
+            Y = grand(m, n, "nf", Dfn, Dfd, Xnon)
+            Y = grand(m, n, "gam", shape, scale)
+            Y = grand(m, n, "nor", Av, Sd)
+            Y = grand(m, n, "geom", p)
+            Y = grand(m, n, "poi", mu)
+            Y = grand(m, n, "def")
+            Y = grand(m, n, "unf", Low, High)
+            Y = grand(m, n, "uin", Low, High)
+            Y = grand(m, n, "lgi")
         </screen>
         <para>
-            produisent une matrice de taille <literal>m</literal>-par-<literal>n</literal>
-            avec des entrées aléatoires.
+            produisent une matrice de taille <literal>m</literal>-par-<literal>n</literal> de nombres aléatoires.
+            
+            Toutes ces séquences peuvent être étendues pour créer une hypermatrice à plus de 2 dimensions, les 
+            tailles (m, n, o,...) étant spécifiées avant le mot ".." indiquant le type de distribution statistique
+            souhaitée :
         </para>
         <para>
-            La séquence d'appel :
+            <programlisting role="no-scilab-exec"><![CDATA[
+                Y = grand(m, n, o, ..., "..", ...)
+            ]]></programlisting>
+        </para>
+        <para>
+            Le format du vecteur ou matrice ou hypermatrice aléatoire attendue peut également être spécifié par
         </para>
-        <screen>
-            Y=grand(X,...)
-        </screen>
         <para>
-            où <literal>X</literal> est une matrice de taille <literal>m</literal>-par-<literal>n</literal>,
-            produit le même effet.
-            Dans ce cas, seule la taille de la matrice <literal>X</literal> est utilisée.
+            <programlisting role="no-scilab-exec"><![CDATA[
+                Y = grand(X, ...)
+            ]]></programlisting>
+        </para>
+        <para>
+            où <literal>X</literal> de taille <literal>m</literal>-par-<literal>n</literal>... est une matrice 
+            ou une hypermatrice dont seul le format est exploité et sert de modèle.
         </para>
         <para>
             Les séquences d'appel :
         </para>
         <screen>
-            Y=grand(n,"mn",Mean,Cov)
-            Y=grand(n,"markov",P,x0)
-            Y=grand(n,"mul",nb,P)
-            Y=grand(n,"prm",vect)
+            Y = grand(n, "mn", Mean, Cov)
+            Y = grand(n, "markov", P, x0)
+            Y = grand(n, "mul", nb, P)
+            Y = grand(n, "prm", vect)
         </screen>
         <para>
             produisent une matrice de taille <literal>m</literal>-par-<literal>n</literal>
             Les séquences d'appel :
         </para>
         <screen>
-            S=grand("getgen")
-            grand("setgen",gen)
+            S = grand("getgen")
+            grand("setgen", gen)
             
-            S=grand("getsd")
-            grand("setsd",S)
+            S = grand("getsd")
+            grand("setsd", S)
             
-            S=grand("phr2sd",phrase)
+            S = grand("phr2sd", phrase)
             
-            grand("setcgn",G)
-            S=grand("getcgn")
+            grand("setcgn", G)
+            S = grand("getcgn")
             
-            grand("initgn",I)
+            grand("initgn", I)
             
-            grand("setall",s1,s2,s3,s4)
+            grand("setall", s1, s2, s3, s4)
             
-            grand("advnst",K)
+            grand("advnst", K)
         </screen>
         <para>
             configurent ou interrogent les générateurs aléatoires.
                 <term>beta</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"bet",A,B)</literal> génère des nombres aléatoires suivant
+                        <literal>Y = grand(m, n, "bet", A, B)</literal> génère des nombres aléatoires suivant
                         la loi beta de paramètres <literal>A</literal> and <literal>B</literal>.
                         La densité de cette loi est <latex><![CDATA[(0 < x < 1)]]></latex> :
                     </para>
                 <term>binomiale</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"bin",N,p)</literal>      génère des nombres aléatoires suivant la loi
+                        <literal>Y = grand(m, n, "bin", N, p)</literal>        génère des nombres aléatoires suivant la loi
                         binomiale de paramètres <literal>N</literal> (entier str. positif) et <literal>p</literal>
                         (réel de [0,1]) : nombre de succès au cours de <literal>N</literal> épreuves de Bernouilli
                         de probabilité de succès <literal>p</literal>.
                 <term>binomiale négative</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"nbn",N,p)</literal> génère des nombres aléatoires suivant la loi binomiale
+                        <literal>Y = grand(m, n, "nbn", N, p)</literal> génère des nombres aléatoires suivant la loi binomiale
                         négative de paramètres <literal>N</literal> (entier str. positif) et <literal>p</literal> (réel
                         de ]0,1[) : nombre d'échecs avant d'obtenir <literal>N</literal> succès dans des épreuves
                         de Bernouilli de probabilité de succès <literal>p</literal>.
                 <term>chi 2</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"chi", Df)</literal> génère des nombres aléatoires suivant la loi du chi 2
+                        <literal>Y = grand(m, n, "chi", Df)</literal> génère des nombres aléatoires suivant la loi du chi 2
                         à <literal>Df</literal> (réel &gt; 0.0) degrés de liberté.
                         Fonction associée : <link linkend="cdfchi">cdfchi</link>.
                     </para>
                 <term>chi 2 non centrée</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"nch",Df,Xnon)</literal> génère des nombres aléatoires suivant la loi du chi 2
+                        <literal>Y = grand(m, n, "nch", Df, Xnon)</literal> génère des nombres aléatoires suivant la loi du chi 2
                         non centrée à <literal>Df</literal> degrés de liberté (réel &gt;= 1.0)
                         le paramètre de décentrage étant <literal>Xnonc</literal> (réel &gt;= 0.0).
                         Fonction associée : <link linkend="cdfchn">cdfchn</link>.
                 <term>exponentielle</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"exp",Av)</literal> génère des nombres aléatoires suivant la loi exponentielle
+                        <literal>Y = grand(m, n, "exp", Av)</literal> génère des nombres aléatoires suivant la loi exponentielle
                         de moyenne <literal>Av</literal> (réel &gt;= 0.0).
                     </para>
                 </listitem>
                 <term>F variance ratio</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"f",Dfn,Dfd)</literal> génère des nombres aléatoires suivant la loi F
+                        <literal>Y = grand(m, n, "f", Dfn, Dfd)</literal> génère des nombres aléatoires suivant la loi F
                         (variance ratio) à <literal>Dfn</literal> (réel &gt; 0.0) degrés de liberté au numérateur et
                         <literal>Dfd</literal> (réel &gt; 0.0) degrés de liberté au dénominateur.
                         Fonction associée : <link linkend="cdff">cdff</link>.
                 <term>non central F variance ratio</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"nf",Dfn,Dfd,Xnon)</literal> génère des nombres aléatoires suivant la loi
+                        <literal>Y = grand(m, n, "nf", Dfn, Dfd, Xnon)</literal> génère des nombres aléatoires suivant la loi
                         F (variance ratio) non centrée à <literal>Dfn</literal> (réel &gt;= 1) degrés de liberté
                         au numérateur, et <literal>Dfd</literal> (réel &gt; 0) degrés de liberté au dénominateur,
                         <literal>Xnonc</literal> (réel &gt;= 0) étant le paramètre de décentrage.
                 <term>gamma</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"gam",shape,scale)</literal> génère des nombres aléatoires suivant la loi
+                        <literal>Y = grand(m, n, "gam", shape, scale)</literal> génère des nombres aléatoires suivant la loi
                         gamma de paramètres <literal>shape</literal> (réel &gt; 0) et <literal>scale</literal>
                         (réel &gt; 0). La densité est :
                     </para>
                 <term>Gauss Laplace (normale)</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"nor",Av,Sd)</literal> génère des nombres aléatoires suivant la loi normale
+                        <literal>Y = grand(m, n, "nor", Av, Sd)</literal> génère des nombres aléatoires suivant la loi normale
                         de moyenne <literal>Av</literal> (réel) et d'écart type <literal>Sd</literal>
                         (réel &gt;= 0).
                         Fonctions associées : <link linkend="cdfnor">cdfnor</link>, <link linkend="erf">erf</link>.
                 <term>multi normale</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(n,"mn",Mean,Cov)</literal> génère <literal>n</literal> réalisations indépendantes de la
+                        <literal>Y = grand(n, "mn", Mean, Cov)</literal> génère <literal>n</literal> réalisations indépendantes de la
                         loi multi-normale ; <literal>Mean</literal> doit être un vecteur <literal>m</literal>-par-<literal>1</literal> et <literal>Cov</literal>
                         une matrice <literal>m</literal>-par-<literal>m</literal> symétrique et définie positive, (<literal>Y</literal> est alors une
                         matrice <literal>m</literal>-par-<literal>n</literal>).
                 <term>geometrique</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"geom", p)</literal>
+                        <literal>Y = grand(m, n, "geom", p)</literal>
                         génère des nombres aléatoires suivant la loi
                         geométrique de paramètre <literal>p</literal> : nombre
                         d'épreuves de Bernouilli (de probabilité de succès
                 <term>markov</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(n,"markov",P,x0)</literal> génère <literal>n</literal> états successifs d'une chaîne de
+                        <literal>Y = grand(n, "markov", P, x0)</literal> génère <literal>n</literal> états successifs d'une chaîne 
                         Markov décrite par la matrice de transition <literal>P</literal>. L'état initial est donné par
                         <literal>x0</literal>. Si <literal>x0</literal> est une matrice de taille
-                        <literal>m=size(x0,"*")</literal>
+                        <literal>m = size(x0, "*")</literal>
                         alors <literal>Y</literal> est une matrice de taille <literal>m x n</literal>. <literal>Y(i,:)</literal> étant le
                         chemin à partir de l'état initial <literal>x0(i)</literal>.
                     </para>
                 <term>multinomiale</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(n,"mul",nb,P)</literal> génère <literal>n</literal> réalisations indépendantes de la loi
+                        <literal>Y = grand(n, "mul", nb, P)</literal> génère <literal>n</literal> réalisations indépendantes de la loi
                         Multinomiale :  classer <literal>nb</literal> éventualités dans <literal>m</literal> catégories (mettre
                         <literal>nb</literal> "boules" dans <literal>m</literal> "boites"). <literal>P(i)</literal>
                         étant la probabilité qu'une éventualité soit de categorie i. <literal>P</literal> le vecteur des
                 <term>Poisson</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"poi",mu)</literal> génère des nombres aléatoires suivant la loi de Poisson
+                        <literal>Y = grand(m, n, "poi", mu)</literal> génère des nombres aléatoires suivant la loi de Poisson
                         de moyenne <literal>mu</literal> (réel &gt;= 0.0).
                         Fonction associée : <link linkend="cdfpoi">cdfpoi</link>.
                     </para>
                 <term>permutations aléatoires</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(n,"prm",vect)</literal> génère <literal>n</literal> permutations aléatoire du
+                        <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>.
                     </para>
                 </listitem>
                 <term>uniforme (def)</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"def")</literal> génère des nombres aléatoires suivant la loi uniforme
+                        <literal>Y = grand(m, n, "def")</literal> génère des nombres aléatoires suivant la loi uniforme
                         sur <literal>[0,1[</literal> (1 n'est jamais retourné).
                     </para>
                 </listitem>
                 <term>uniforme (unf)</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"unf",Low,High)</literal> génère des nombres aléatoires suivant la loi
+                        <literal>Y = grand(m, n, "unf", Low, High)</literal> génère des nombres aléatoires suivant la loi
                         uniforme sur <literal>[Low, High[</literal> (<literal>High</literal> is never return).
                     </para>
                 </listitem>
                 <term>uniforme (uin)</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"uin",Low,High)</literal> génère des entiers aléatoires suivant la loi uniforme
+                        <literal>Y = grand(m, n, "uin", Low, High)</literal> génère des entiers aléatoires suivant la loi uniforme
                         sur <literal>[Low, High]</literal>. <literal>High</literal>
-                        et <literal>Low</literal> doivent être des entiers tels que <latex><![CDATA[(\textrm{High}-\textrm{Low}+1) < 2\,147\,483\,561]]></latex>.
+                        et <literal>Low</literal> doivent être des entiers tels que <literal>
+                            (High-Low+1)
+                            &lt; 2147483561
+                        </literal>
+                        .
                     </para>
                 </listitem>
             </varlistentry>
                 <term>uniforme (lgi)</term>
                 <listitem>
                     <para>
-                        <literal>Y=grand(m,n,"lgi")</literal> retourne la sortie du générateur de base courant : des entiers
+                        <literal>Y = grand(m, n, "lgi")</literal> retourne la sortie du générateur de base courant : des entiers
                         aléatoires suivant une loi uniforme sur :
                     </para>
                     <itemizedlist>
         <title>Actions</title>
         <variablelist>
             <varlistentry>
-                <term>action= "getgen"</term>
+                <term>action = "getgen"</term>
                 <listitem>
                     <para>
-                        <literal>S=grand("getgen")</literal> retourne le nom du générateur de base actuel (<literal>S</literal> est
-                        l'une des chaînes de caractères "mt", "kiss", "clcg2", "clcg4", "urand",
-                        "fsultra").
+                        <literal>S = grand("getgen")</literal> retourne le nom du générateur de base actuel (<literal>S</literal> est
+                        l'une des chaînes de caractères "mt", "kiss", "clcg2", "clcg4", "urand", "fsultra").
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>action= "setgen"</term>
+                <term>action = "setgen"</term>
                 <listitem>
                     <para>
-                        <literal>grand("setgen",gen)</literal> permet de changer le générateur de base : <literal>gen</literal>
+                        <literal>grand("setgen", gen)</literal> permet de changer le générateur de base : <literal>gen</literal>
                         doit être l'une des chaînes de caractères "mt", "kiss", "clcg2", "clcg4", "urand", "fsultra".
                         En cas de succès la fonction retourne cette même chaîne.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>action= "getsd"</term>
+                <term>action = "getsd"</term>
                 <listitem>
                     <para>
-                        <literal>S=grand("getsd")</literal> retourne l'état interne actuel (les 'germes' dans l'ancienne
+                        <literal>S = grand("getsd")</literal> retourne l'état interne actuel (les 'germes' dans l'ancienne
                         appelation quoique ce terme désigne plutôt l'état initial) du générateur de base courant ;
                         <literal>S</literal> est un vecteur colonne (d'entiers) de dimension <literal>625</literal>
                         pour mt (la première composante étant un 'index' sur l'état, c-a-d un entier de l'intervalle
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>action= "setsd"</term>
+                <term>action = "setsd"</term>
                 <listitem>
                     <para>
-                        <literal>grand("setsd",S), grand("setsd",s1[,s2,s3,s4])</literal> impose l'état interne du générateur de
+                        <literal>grand("setsd", S), grand("setsd", s1[, s2, s3, s4])</literal> impose l'état interne du générateur de
                         base courant :
                     </para>
                     <variablelist>
                             <term>pour kiss</term>
                             <listitem>
                                 <para>
-                                    <literal>4</literal> entiers <literal>s1,s2, s3,s4</literal> dans <literal>[0,2^32[</literal> doivent être
+                                    <literal>4</literal> entiers <literal>s1, s2, s3, s4</literal> dans <literal>[0,2^32[</literal> doivent être
                                     fournis ;
                                 </para>
                             </listitem>
                             <term>pour clcg2</term>
                             <listitem>
                                 <para>
-                                    <literal>2</literal> entiers <literal>s1</literal> dans <literal>[1,2147483562]</literal> et <literal>s2</literal>
-                                    dans <literal>[1,2147483398]</literal> doivent être fournis ;
+                                    <literal>2</literal> entiers <literal>s1</literal> dans <literal>[1, 2147483562]</literal> et <literal>s2</literal>
+                                    dans <literal>[1, 2147483398]</literal> doivent être fournis ;
                                 </para>
                             </listitem>
                         </varlistentry>
                             <term>pour clcg4</term>
                             <listitem>
                                 <para>
-                                    <literal>4</literal> entiers <literal>s1</literal> dans <literal>[1,2147483646]</literal>, <literal>s2</literal>
-                                    dans <literal>[1,2147483542]</literal>, <literal>s3</literal> dans <literal>[1,2147483422]</literal>,
-                                    <literal>s4</literal> dans <literal>[1,2147483322]</literal> sont requis ;
+                                    <literal>4</literal> entiers <literal>s1</literal> dans <literal>[1, 2147483646]</literal>, <literal>s2</literal>
+                                    dans <literal>[1, 2147483542]</literal>, <literal>s3</literal> dans <literal>[1, 2147483422]</literal>,
+                                    <literal>s4</literal> dans <literal>[1, 2147483322]</literal> sont requis ;
                                     <literal>ATTENTION</literal> : avec clcg4 vous positionnez l'état interne du générateur virtuel
                                     courant mais vous perdez alors la synchronisation avec les autres générateurs virtuels.
                                     (=&gt; si vous utilisez clcg4 avec différents générateurs virtuels, il faut utiliser
                             <listitem>
                                 <para>
                                     <literal>1</literal> entier <literal>s1</literal> appartenant à
-                                    <literal>[0,2^31[</literal> est requis.
+                                    <literal>[0, 2^31[</literal> est requis.
                                 </para>
                             </listitem>
                         </varlistentry>
                             <listitem>
                                 <para>
                                     <literal>S</literal> est un vecteur de <literal>40</literal> entiers (son premier élément doit être dans
-                                    l'intervalle<literal>[0,37]</literal>, son deuxième (drapeau) doit être 0 ou 1, le troisième un
-                                    entier de <literal>[1,2^32[</literal> et les 37 composantes suivantes, des entiers de <literal>[0,2^32[</literal>) ; il est recommandé
+                                    l'intervalle<literal>[0, 37]</literal>, son deuxième (drapeau) doit être 0 ou 1, le troisième un
+                                    entier de <literal>[1, 2^32[</literal> et les 37 composantes suivantes, des entiers de <literal>[0, 2^32[</literal>) ; il est recommandé
                                     d'utiliser l'autre procédure d'initialisation (plus simple) avec deux entiers <literal>s1</literal> et
-                                    <literal>s2</literal> de <literal>[0,2^32[</literal>.
+                                    <literal>s2</literal> de <literal>[0, 2^32[</literal>.
                                 </para>
                             </listitem>
                         </varlistentry>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>action= "phr2sd"</term>
+                <term>action = "phr2sd"</term>
                 <listitem>
                     <para>
-                        <literal>Sd=grand("phr2sd", phrase)</literal> étant donnée une chaîne de caractères <literal>phrase</literal>
+                        <literal>Sd = grand("phr2sd", phrase)</literal> étant donnée une chaîne de caractères <literal>phrase</literal>
                         cet appel retourne un vecteur <literal>1 x 2</literal> qui peut être utilisé comme
                         état interne pour un générateur de base (initialement adapté pour clcg2).
                     </para>
             intersection (quand vous utilisez un générateur classique vous pouvez changer l'état initial
             de façon à obtenir une autre séquence mais vous n'êtes pas complètement sûr d'obtenir une
             séquence complètement différente). Chaque générateur virtuel correspond à une séquence de
-            longueur <literal>2^72</literal> qui est de plus découpée en <literal>V=2^31</literal> segments de longueur
-            <literal>W=2^41</literal>. Pour un générateur virtuel donné vous pouvez retourner au début de la séquence
+            longueur <literal>2^72</literal> qui est de plus découpée en <literal>V = 2^31</literal> segments de longueur
+            <literal>W = 2^41</literal>. Pour un générateur virtuel donné vous pouvez retourner au début de la séquence
             ou au début du segment ou bien au début du segment suivant.
             Vous pouvez aussi changer l'état initial du générateur <literal>0</literal> avec l'option
             "setall" qui recalcule l'état initial des autres générateurs virtuels de sorte à obtenir
         </para>
         <variablelist>
             <varlistentry>
-                <term>action= "setcgn"</term>
+                <term>action = "setcgn"</term>
                 <listitem>
                     <para>
-                        <literal>grand("setcgn",G)</literal> sélectionne le générateur virtuel numéro <literal>G</literal> :
+                        <literal>grand("setcgn", G)</literal> sélectionne le générateur virtuel numéro <literal>G</literal> :
                         lorsque le générateur de base courant est clcg4, c'est le générateur virtuel <literal>G</literal>
                         qui sera alors utilisé ; les <literal>101</literal> générateurs virtuels sont numérotés
                         <literal>0,1,...,100</literal> (ainsi <literal>G</literal> doit être un entier de l'intervalle
-                        <literal>[0,100]</literal>) ; par défaut le générateur virtuel courant est celui de numéro
+                        <literal>[0, 100]</literal>) ; par défaut le générateur virtuel courant est celui de numéro
                         <literal>0</literal>.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>action= "getcgn"</term>
+                <term>action = "getcgn"</term>
                 <listitem>
                     <para>
-                        <literal>S=grand("getcgn")</literal> retourne le numéro du générateur
+                        <literal>S = grand("getcgn")</literal> retourne le numéro du générateur
                         virtuel courant.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>action= "initgn"</term>
+                <term>action = "initgn"</term>
                 <listitem>
                     <para>
-                        <literal>grand("initgn",I)</literal> réinitialise l'état du générateur virtuel courant :
+                        <literal>grand("initgn", I)</literal> réinitialise l'état du générateur virtuel courant :
                     </para>
                     <variablelist>
                         <varlistentry>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>action= "setall"</term>
+                <term>action = "setall"</term>
                 <listitem>
                     <para>
-                        <literal>grand("setall",s1,s2,s3,s4)</literal> impose l'état interne du générateur virtuel
-                        de numéro <literal>0</literal> à <literal>s1,s2,s3,s4</literal>. L'état initial des autres générateurs est
+                        <literal>grand("setall", s1, s2, s3, s4)</literal> impose l'état interne du générateur virtuel
+                        de numéro <literal>0</literal> à <literal>s1, s2, s3, s4</literal>. L'état initial des autres générateurs est
                         alors reconstruit (de façon à obtenir 101 séquences qui ne s'intersectent pas). Voir
                         l'action "setsd" pour les contraintes sur <literal>s1, s2, s3, s4</literal>.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>action= "advnst"</term>
+                <term>action = "advnst"</term>
                 <listitem>
                     <para>
-                        <literal>grand("advnst",K)</literal> avance l'état du générateur virtuel courant de <literal>2^K</literal>
+                        <literal>grand("advnst", K)</literal> avance l'état du générateur virtuel courant de <literal>2^K</literal>
                         valeurs et réinitialise l'état initial (du générateur virtuel courant) à
                         ce nouvel état.
                     </para>
         <programlisting role="example"><![CDATA[ 
 // Renvoit une matrice de taille 400-par-800 de doubles aléatoires, 
 // avec une distribution normale de moyenne 0 et d'écart-type 1. 
-R = grand(400,800,"nor",0,1);
+R = grand(400, 800, "nor", 0, 1);
 scf();
-histplot(10,R);
-xtitle("Nombres aléatoires (loi normale) par grand","X","Fréquence");
+histplot(10, R);
+xtitle("Nombres aléatoires (loi normale) par grand", "X", "Fréquence");
  ]]></programlisting>
         <scilab:image localized="true">
-            R = grand(400,800,"nor",0,1);
-            histplot(10,R);
-            xtitle("Nombres aléatoires (loi normale) par grand","X","Fréquence");
+            R = grand(400, 800, "nor", 0, 1);
+            histplot(10, R);
+            xtitle("Nombres aléatoires (loi normale) par grand", "X", "Fréquence");
         </scilab:image>
         <programlisting role="example"><![CDATA[ 
 // Renvoit une matrice de taille 400-par-800 de doubles aléatoires, 
-// uniformes dans [0,1).
-R = grand(400,800,"def");
+// uniformes dans [0, 1).
+R = grand(400, 800, "def");
 scf();
-histplot(10,R);
-xtitle("Nombres aléatoires uniformes par grand","X","Fréquence");
+histplot(10, R);
+xtitle("Nombres aléatoires uniformes par grand", "X", "Fréquence");
  ]]></programlisting>
         <scilab:image localized="true">
-            R = grand(400,800,"def");
-            histplot(10,R);
-            xtitle("Nombres aléatoires uniformes par grand","X","Fréquence");
+            R = grand(400, 800, "def");
+            histplot(10, R);
+            xtitle("Nombres aléatoires uniformes par grand", "X", "Fréquence");
         </scilab:image>
         <programlisting role="example"><![CDATA[ 
 // Renvoit une matrice de taille 400-par-800 de doubles aléatoires, 
 // avec une distribution de Poisson de moyenne 5.
-R = grand(400,800,"poi",5);
+R = grand(400, 800, "poi", 5);
 scf();
-histplot(10,R);
-xtitle("Nombres aléatoires (loi de Poisson) par grand","X","Fréquence");
+histplot(10, R);
+xtitle("Nombres aléatoires (loi de Poisson) par grand", "X", "Fréquence");
  ]]></programlisting>
         <scilab:image localized="true">
-            R = grand(400,800,"poi",5);
-            histplot(10,R);
-            xtitle("Nombres aléatoires (loi de Poisson) par grand","X","Fréquence");
+            R = grand(400, 800, "poi", 5);
+            histplot(10, R);
+            xtitle("Nombres aléatoires (loi de Poisson) par grand", "X", "Fréquence");
         </scilab:image>
         <para>
             Dans l'exemple suivant, nous produisons des nombres aléatoires
@@ -797,74 +811,100 @@ xtitle("Nombres aléatoires (loi de Poisson) par grand","X","Fréquence");
             et la fonction de distribution théorique.
         </para>
         <programlisting role="example"><![CDATA[ 
-lambda=1.6;
-N=100000;
-X = grand(1,N,"exp",lambda);
+lambda = 1.6;
+N = 100000;
+X = grand(1, N, "exp", lambda);
 scf();
-classes = linspace(0,12,25);
-histplot(classes,X)
-x=linspace(0,12,25);
+classes = linspace(0, 12, 25);
+histplot(classes, X)
+x = linspace(0, 12, 25);
 y = (1/lambda)*exp(-(1/lambda)*x);
-plot(x,y,"ro-");
+plot(x, y, "ro-");
 legend(["Empirique" "Theorique"]);
-xtitle("Loi exponentielle par grand","X","Fréquence");
+xtitle("Loi exponentielle par grand", "X", "Fréquence");
  ]]></programlisting>
         <scilab:image localized="true">
-            lambda=1.6;
-            N=100000;
-            X = grand(1,N,"exp",lambda);
-            classes = linspace(0,12,25);
-            histplot(classes,X)
-            x=linspace(0,12,25);
+            lambda = 1.6;
+            N = 100000;
+            X = grand(1, N, "exp", lambda);
+            classes = linspace(0, 12, 25);
+            histplot(classes, X)
+            x = linspace(0, 12, 25);
             y = (1/lambda)*exp(-(1/lambda)*x);
-            plot(x,y,"ro-");
+            plot(x, y, "ro-");
             legend(["Empirique" "Theorique"]);
-            xtitle("Loi exponentielle par grand","X","Fréquence");
+            xtitle("Loi exponentielle par grand", "X", "Fréquence");
         </scilab:image>
         <para>
             Dans l'exemple suivant, nous générons des nombres aléatoires selon la distribution
             gamma et comparons la distribution empirique et la loi de distribution théorique.
         </para>
         <programlisting role="example"><![CDATA[ 
-N=10000;
-A=10;
-B=4;
-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));
+N = 10000;
+A = 10;
+B = 4;
+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));
 scf();
-plot(XS,PS,"b-"); // Empirical distribution
-plot(XS,P,"r-"); // Theoretical distribution
+plot(XS, PS, "b-"); // Empirical distribution
+plot(XS, P, "r-"); // Theoretical distribution
 legend(["Empirique" "Théorique"]);
-xtitle("Fonction de distribution cumulée de nombres aléatoires selon la loi Gamma","X","F");
+xtitle("Fonction de distribution cumulée de nombres aléatoires selon la loi Gamma", "X", "F");
  ]]></programlisting>
         <scilab:image localized="true">
-            N=10000;
-            A=10;
-            B=4;
-            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));
-            plot(XS,PS,"b-");
-            plot(XS,P,"r-");
+            N = 10000;
+            A = 10;
+            B = 4;
+            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));
+            plot(XS, PS, "b-");
+            plot(XS, P, "r-");
             legend(["Empirique" "Théorique"]);
-            xtitle("Fonction de distribution cumulée de nombres aléatoires selon la loi Gamma","X","F");
+            xtitle("Fonction de distribution cumulée de nombres aléatoires selon la loi Gamma", "X", "F");
         </scilab:image>
         <para>
-            Dans l'exemple suivant, nous générons 10 entiers aléatoires dans l'intervalle [1,365].
+            Dans l'exemple suivant, nous générons 10 entiers aléatoires dans l'intervalle [1, 365].
         </para>
         <programlisting role="example"><![CDATA[ 
-grand(10,1,"uin",1,365)
+grand(10, 1, "uin", 1, 365)
  ]]></programlisting>
         <para>
             Dans l'exemple suivant, nous générons 12 permutations de l'ensemble [1,2,...,7].
             Les 12 permutations sont stockées colonne par colonne.
         </para>
         <programlisting role="example"><![CDATA[ 
-grand(12,"prm",(1:7)')
+grand(12, "prm", (1:7)')
+ ]]></programlisting>
+        <para>
+            L'exemple suivant génère une hypermatrice <varname>10</varname>-par-<varname>10</varname>-par-<varname>10</varname>
+            de nombre aléatoires provenant de la distribution "normale" et affiche les histogrammes associés.
+            Le graphes montrent les première et dernière couches de la matrice.
+        </para>
+        <programlisting role="example"><![CDATA[ 
+// Retounrne une hypermatrice 400-par-800-par-10 de nombre aléatoires,
+// avec la distribution normale, une moyenne de 0 et un écart-type de 1.
+// Affichage de la première et dernière couches.
+R = grand(10,10,10,"nor",0,1);
+subplot(1,2,1)
+hist3d(R(:,:,1));
+xtitle("Couche 1");
+subplot(1,2,2)
+hist3d(R(:,:,10));
+xtitle("Couche 10");
  ]]></programlisting>
+        <scilab:image localized="true">
+            R = grand(10,10,10,"nor",0,1);
+            subplot(1,2,1)
+            hist3d(R(:,:,1));
+            xtitle("Couche 1");
+            subplot(1,2,2)
+            hist3d(R(:,:,10));
+            xtitle("Couche 10");
+        </scilab:image>
     </refsection>
     <refsection>
         <title>Produire des nombres prévisibles ou moins prévisibles</title>
@@ -881,8 +921,8 @@ grand(12,"prm",(1:7)')
             Dans ce cas, on peut initialiser la graine avec la sortie de la fonction <literal>getdate</literal> :
         </para>
         <programlisting role="example"><![CDATA[
-n=getdate("s");
-grand("setsd",n)
+n = getdate("s");
+grand("setsd", n)
     ]]></programlisting>
     </refsection>
     <refsection>
index 95890be..b9fac64 100644 (file)
@@ -1,4 +1,3 @@
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA
 //
@@ -8,18 +7,8 @@
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
-
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2005-2008 - INRIA - Allan CORNET <allan.cornet@inria.fr>
-//
-// 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
-
-if (isdef('genlib') == %f) then
-       exec(SCI+'/modules/functions/scripts/buildmacros/loadgenlib.sce');
+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 ef7c6b8..27e7898 100644 (file)
@@ -20,7 +20,8 @@
 #include <string.h>
 #include <math.h>
 #include "localization.h"
-#include "stack-c.h"
+#include "api_scilab.h"
+#include "MALLOC.h"
 
 /** external functions to be called through this interface **/
 
@@ -72,6 +73,9 @@ double factor[NbGenInScilab] = { 2.3283064365386963e-10,  /* mt    */
                                  2.3283064365386963e-10
                                }; /* fsultra*/
 
+
+static double* createOutputVar(void* _pvCtx, int _iVar, int _iRows, int _iCols, int* _piDims, int _iDims);
+
 double C2F(ranf)(void)
 {
     /* random deviate from U[0,1) */
@@ -131,11 +135,15 @@ int sci_Rand(char *fname, unsigned long fname_len)
     int ResL, ResC, suite, m2, n2, l2, m1, n1, l1, ls, ms, ns, la, lr, lb, lc;
     int l3, l4;
     int i;
+    int iHyperMat = 0;
+    int iDims = 0;
+    int* piDims = NULL;
+    double* pdblData = NULL;
 
     Nbvars = 0;
     CheckRhs(minrhs, maxrhs);
     CheckLhs(minlhs, maxlhs);
-    if (GetType(1) != sci_matrix)
+    if (GetType(1) != sci_matrix && GetType(1) != 17)
     {
         int un = 1, deux = 2, dim_state_mt = 625, dim_state_fsultra = 40, dim_state_4 = 4;
         GetRhsVar(1, STRING_DATATYPE, &ms, &ns, &ls);
@@ -154,27 +162,27 @@ int sci_Rand(char *fname, unsigned long fname_len)
 
             switch (current_gen)
             {
-                case(MT) :
+                case (MT) :
                     CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &dim_state_mt, &un, &lr);
                     get_state_mt(stk(lr));
                     break;
-                case(KISS) :
+                case (KISS) :
                     CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &dim_state_4, &un, &lr);
                     get_state_kiss(stk(lr));
                     break;
-                case(CLCG4) :
+                case (CLCG4) :
                     CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &dim_state_4, &un, &lr);
                     get_state_clcg4(current_clcg4, stk(lr));
                     break;
-                case(CLCG2) :
+                case (CLCG2) :
                     CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &deux, &un, &lr);
                     get_state_clcg2(stk(lr));
                     break;
-                case(URAND) :
+                case (URAND) :
                     CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &un, &un, &lr);
                     get_state_urand(stk(lr));
                     break;
-                case(FSULTRA) :
+                case (FSULTRA) :
                     CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &dim_state_fsultra, &un, &lr);
                     get_state_fsultra(stk(lr));
                     break;
@@ -195,25 +203,25 @@ int sci_Rand(char *fname, unsigned long fname_len)
                 return 0;
             }
             GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-            if ( m1*n1 != 1)
+            if ( m1 * n1 != 1)
             {
                 Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 2);
                 return 0;
             }
             GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l2);
-            if ( m1*n1 != 1)
+            if ( m1 * n1 != 1)
             {
                 Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 3);
                 return 0;
             }
             GetRhsVar(4, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l3);
-            if ( m1*n1 != 1)
+            if ( m1 * n1 != 1)
             {
                 Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 4);
                 return 0;
             }
             GetRhsVar(5, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l4);
-            if ( m1*n1 != 1)
+            if ( m1 * n1 != 1)
             {
                 Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 5);
                 return 0;
@@ -233,14 +241,14 @@ int sci_Rand(char *fname, unsigned long fname_len)
         {
             switch (current_gen)
             {
-                case(MT) :
+                case (MT) :
                     if ( Rhs != 2 )
                     {
                         Scierror(999, _("%s: Wrong number of input arguments: %d expected for '%s' with the %s generator.\n"), fname, 2, "setsd", "mt");
                         return 0;
                     }
                     GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-                    if ( m1*n1 == 1)          /* simple init of mt     */
+                    if ( m1 * n1 == 1)        /* simple init of mt     */
                     {
                         if (! set_state_mt_simple(*stk(l1)) )
                         {
@@ -248,7 +256,7 @@ int sci_Rand(char *fname, unsigned long fname_len)
                             return(0);
                         };
                     }
-                    else if ( m1*n1 == 625 )  /* init of all the state */
+                    else if ( m1 * n1 == 625 ) /* init of all the state */
                     {
                         if (! set_state_mt(stk(l1)))
                         {
@@ -263,7 +271,7 @@ int sci_Rand(char *fname, unsigned long fname_len)
                     };
                     break;
 
-                case(FSULTRA) :
+                case (FSULTRA) :
                     if ( Rhs == 2 ) /* init via a "complete" state */
                     {
                         GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
@@ -282,13 +290,13 @@ int sci_Rand(char *fname, unsigned long fname_len)
                     else if ( Rhs == 3 ) /* init with 2 integers (like before) */
                     {
                         GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-                        if ( m1*n1 != 1)
+                        if ( m1 * n1 != 1)
                         {
                             Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 2);
                             return 0;
                         };
                         GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l2);
-                        if ( m1*n1 != 1)
+                        if ( m1 * n1 != 1)
                         {
                             Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 3);
                             return 0;
@@ -306,33 +314,33 @@ int sci_Rand(char *fname, unsigned long fname_len)
                     }
                     break;
 
-                case(KISS) :
-                case(CLCG4) :
+                case (KISS) :
+                case (CLCG4) :
                     if ( Rhs != 5 )
                     {
                         Scierror(999, _("%s: Wrong number of input arguments: expected %d for '%s' option with the %s or %s generator.\n"), fname, 5, "setsd", "kiss", "clcg4");
                         return 0;
                     }
                     GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-                    if ( m1*n1 != 1)
+                    if ( m1 * n1 != 1)
                     {
                         Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 2);
                         return 0;
                     }
                     GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l2);
-                    if ( m1*n1 != 1)
+                    if ( m1 * n1 != 1)
                     {
                         Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 3);
                         return 0;
                     }
                     GetRhsVar(4, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l3);
-                    if ( m1*n1 != 1)
+                    if ( m1 * n1 != 1)
                     {
                         Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 4);
                         return 0;
                     }
                     GetRhsVar(5, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l4);
-                    if ( m1*n1 != 1)
+                    if ( m1 * n1 != 1)
                     {
                         Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 5);
                         return 0;
@@ -355,20 +363,20 @@ int sci_Rand(char *fname, unsigned long fname_len)
                     }
                     break;
 
-                case(CLCG2) :
+                case (CLCG2) :
                     if ( Rhs != 3 )
                     {
                         Scierror(999, _("%s: Wrong number of input arguments: %d expected for '%s' option with the %s generator.\n"), fname, 3, "setsd", "clcg2");
                         return 0;
                     }
                     GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-                    if ( m1*n1 != 1)
+                    if ( m1 * n1 != 1)
                     {
                         Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 2);
                         return 0;
                     };
                     GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l2);
-                    if ( m1*n1 != 1)
+                    if ( m1 * n1 != 1)
                     {
                         Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 3);
                         return 0;
@@ -380,14 +388,14 @@ int sci_Rand(char *fname, unsigned long fname_len)
                     };
                     break;
 
-                case(URAND) :
+                case (URAND) :
                     if ( Rhs != 2 )
                     {
                         Scierror(999, _("%s: Wrong number of input arguments: %d expected for '%s' option with the %s generator.\n"), fname, 2, "setsd", "urand");
                         return 0;
                     }
                     GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-                    if ( m1*n1 != 1)
+                    if ( m1 * n1 != 1)
                     {
                         Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 2);
                         return 0;
@@ -577,29 +585,82 @@ int sci_Rand(char *fname, unsigned long fname_len)
     CheckRhs(minrhs, maxrhs);
     if ( GetType(2) == sci_matrix ) /** m,n,'string' */
     {
-        GetRhsVar(1, MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &l1);
-        if ( m1*n1 != 1)
+        //find all sci_matrix before sci_string.
+        SciErr sciErr;
+        int iSize = 1;
+
+        for (iDims = 2 ; iDims < Rhs ; iDims++)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 1);
+            int* piAddr = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx, iDims + 1, &piAddr);
+            if (isDoubleType(pvApiCtx, piAddr))
+            {
+                //set hypermatrix flag
+                iHyperMat = 1;
+                continue;
+            }
+
+            if (isStringType(pvApiCtx, piAddr))
+            {
+                break;
+            }
+
+            Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, iDims);
             return 0;
         }
-        ResL = *istk(l1);
-        GetRhsVar(2, MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
-        if ( m2*n2 != 1)
+
+        suite = iDims + 1;
+        if (iHyperMat)
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 2);
-            return 0;
+            piDims = (int*)MALLOC(sizeof(int) * iDims);
+            for (i = 0 ; i < iDims ; i++)
+            {
+                double dblVal = 0;
+                int* piAddr = NULL;
+                sciErr = getVarAddressFromPosition(pvApiCtx, i + 1 , &piAddr);
+
+                if (getScalarDouble(pvApiCtx, piAddr, &dblVal))
+                {
+                    Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, i + 1);
+                    return 0;
+                }
+
+                iSize *= (int)dblVal;
+                piDims[i] = (int)dblVal;
+            }
+
+            ResL = 1;
+            ResC = iSize;
+
+            //reset iHypermat flag to make difference between input hypermatrix cases
+            iHyperMat = 0;
         }
-        ResC = *istk(l2);
-        minrhs = 3;
-        CheckRhs(minrhs, maxrhs);
-        if ( GetType(3) != sci_strings )
+        else
         {
-            Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 3);
+            GetRhsVar(1, MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &l1);
+            if ( m1 * n1 != 1)
+            {
+                Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 1);
+                return 0;
+            }
+            ResL = *istk(l1);
+            GetRhsVar(2, MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
+            if ( m2 * n2 != 1)
+            {
+                Scierror(999, _("%s: Wrong type for input argument #%d: Scalar expected.\n"), fname, 2);
+                return 0;
+            }
+            ResC = *istk(l2);
+        }
+
+        if ( GetType(suite) != sci_strings )
+        {
+            Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, suite);
             return 0;
         }
-        GetRhsVar(3, STRING_DATATYPE, &ms, &ns, &ls);
-        suite = 4;
+
+        GetRhsVar(suite, STRING_DATATYPE, &ms, &ns, &ls);
+        suite++;
         if (ResL < 0 && (ResL != -1 || ResC != -1)) //ResL=-1 & ResC=-1 => eye
         {
             Scierror(999, _("%s: Wrong value for input argument #%d: Positive scalar expected.\n"), fname, 1);
@@ -614,9 +675,29 @@ int sci_Rand(char *fname, unsigned long fname_len)
     }
     else
     {
-        GetRhsVar(1, MATRIX_OF_INTEGER_DATATYPE, &ResL, &ResC, &l1);
+        int* piAddr = NULL;
+        getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+        if (isHypermatType(pvApiCtx, piAddr))
+        {
+            //get dimension information from input hypermatrix
+            getHypermatDimensions(pvApiCtx, piAddr, &piDims, &iDims);
+            iHyperMat = 1;
+
+            ResL = 1;
+            ResC = 1;
+            for (i = 0 ; i < iDims ; i++)
+            {
+                ResC *= piDims[i];
+            }
+        }
+        else
+        {
+            GetRhsVar(1, MATRIX_OF_INTEGER_DATATYPE, &ResL, &ResC, &l1);
+        }
+
         GetRhsVar(2, STRING_DATATYPE, &ms, &ns, &ls);
         suite = 3;
+
     }
     if ( strcmp(cstk(ls), "bet") == 0)
     {
@@ -627,18 +708,20 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument: Scalar expected for %s.\n"), fname, "A");
             return 0;
         }
         GetRhsVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lb);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument: Scalar expected for %s.\n"), fname, "B");
             return 0;
         }
-        CreateVar(suite + 2, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
+        pdblData = createOutputVar(pvApiCtx, suite + 2, ResL, ResC, piDims, iDims);
+
         if ( *stk(la) < minlog || *stk(lb) < minlog)
         {
             Scierror(999, _("Rand(...,'bet',..): A or B < %f\n"), minlog);
@@ -646,11 +729,11 @@ int sci_Rand(char *fname, unsigned long fname_len)
         }
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = C2F(genbet)(stk(la), stk(lb));
+            pdblData[i] = C2F(genbet)(stk(la), stk(lb));
         }
+
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "f") == 0)
     {
@@ -660,18 +743,20 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument: Scalar expected for %s.\n"), fname, "Dfn");
             return 0;
         }
         GetRhsVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lb);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument: Scalar expected for %s.\n"), fname, "Dfd");
             return 0;
         }
-        CreateVar(suite + 2, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
+        pdblData = createOutputVar(pvApiCtx, suite + 2, ResL, ResC, piDims, iDims);
+
         if ( *stk(la) <= 0.0 || *stk(lb) <= 0.0)
         {
             Scierror(999, _("Degrees of freedom nonpositive\n"));
@@ -679,17 +764,16 @@ int sci_Rand(char *fname, unsigned long fname_len)
         }
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = C2F(genf)(stk(la), stk(lb));
+            pdblData[i] = C2F(genf)(stk(la), stk(lb));
         }
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "mul") == 0)
     {
         int l_i, nn, ncat;
         double ptot;
-        if ( suite != 3 || ResL*ResC != 1)
+        if ( suite != 3 || ResL * ResC != 1)
         {
             Scierror(999, _("%s: Wrong value for input argument #%d: Must be the number of random deviate.\n"), fname, 1);
             return 0;
@@ -701,7 +785,7 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument: Scalar expected for %s.\n"), fname, "N");
             return 0;
@@ -750,7 +834,6 @@ int sci_Rand(char *fname, unsigned long fname_len)
         }
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "gam") == 0)
     {
@@ -764,18 +847,20 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument: Scalar expected for %s.\n"), fname, "shape");
             return 0;
         }
         GetRhsVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lb);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument: Scalar expected for %s.\n"), fname, "rate");
             return 0;
         }
-        CreateVar(suite + 2, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
+        pdblData = createOutputVar(pvApiCtx, suite + 2, ResL, ResC, piDims, iDims);
+
         if ( (*stk(la)) <= 0.0 ||  (*stk(lb)) <= 0.0 )
         {
             Scierror(999, _("grand(..'gam',A,R) : A <= 0.0 or R <= 0.0\n"));
@@ -786,13 +871,11 @@ int sci_Rand(char *fname, unsigned long fname_len)
             /** WARNING : order is changed in parameters for
             compatibility between Rand(...'gam',..) and cdfgam
             **/
-            *stk(lr + i) = C2F(gengam)(stk(lb), stk(la));
+            pdblData[i] = C2F(gengam)(stk(lb), stk(la));
         }
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
-
     else if ( strcmp(cstk(ls), "nor") == 0)
     {
         if ( Rhs != suite + 1)
@@ -801,18 +884,20 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument: Scalar expected for %s.\n"), fname, "Av");
             return 0;
         }
         GetRhsVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lb);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument: Scalar expected for %s.\n"), fname, "Sd");
             return 0;
         }
-        CreateVar(suite + 2, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
+        pdblData = createOutputVar(pvApiCtx, suite + 2, ResL, ResC, piDims, iDims);
+
         if ( *stk(lb) < 0 )
         {
             Scierror(999, _("SD < 0.0\n"));
@@ -820,11 +905,10 @@ int sci_Rand(char *fname, unsigned long fname_len)
         }
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = C2F(gennor)(stk(la), stk(lb));
+            pdblData[i] = C2F(gennor)(stk(la), stk(lb));
         }
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "unf") == 0)
     {
@@ -836,20 +920,21 @@ int sci_Rand(char *fname, unsigned long fname_len)
         }
 
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
 
         GetRhsVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lb);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
 
-        CreateVar(suite + 2, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+        pdblData = createOutputVar(pvApiCtx, suite + 2, ResL, ResC, piDims, iDims);
+
         low = *stk(la);
         high =  *stk(lb);
         if ( low > high )
@@ -859,11 +944,10 @@ int sci_Rand(char *fname, unsigned long fname_len)
         }
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = low + (high - low) * C2F(ranf)();
+            pdblData[i] = low + (high - low) * C2F(ranf)();
         }
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "uin") == 0)
     {
@@ -876,14 +960,14 @@ int sci_Rand(char *fname, unsigned long fname_len)
 
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
 
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
 
         GetRhsVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lb);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
@@ -903,14 +987,15 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
 
-        CreateVar(suite + 2, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+        pdblData = createOutputVar(pvApiCtx, suite + 2, ResL, ResC, piDims, iDims);
+
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = C2F(ignuin)(stk(la), stk(lb));
+            pdblData[i] = C2F(ignuin)(stk(la), stk(lb));
         }
+
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "lgi") == 0)
     {
@@ -919,19 +1004,20 @@ int sci_Rand(char *fname, unsigned long fname_len)
             Scierror(999, _("%s: Wrong number of input argument: %d expected with option '%s'.\n"), fname, suite - 1, "lgi");
             return 0;
         }
-        CreateVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
+        pdblData = createOutputVar(pvApiCtx, suite, ResL, ResC, piDims, iDims);
+
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = ignlgi();
+            pdblData[i] = ignlgi();
         }
         LhsVar(1) = suite;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "prm") == 0)
     {
         int nn;
-        if ( suite != 3 || ResL*ResC != 1)
+        if ( suite != 3 || ResL * ResC != 1)
         {
             Scierror(999, _("%s: Wrong value for input argument: Number of random simulation expected.\n"), fname);
             return 0;
@@ -970,18 +1056,20 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
         GetRhsVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lb);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
-        CreateVar(suite + 2, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
+        pdblData = createOutputVar(pvApiCtx, suite + 2, ResL, ResC, piDims, iDims);
+
         if ( *stk(lb) < 0.0 || *stk(lb) > 1.0 )
         {
             Scierror(999, _("P is not in [0,1]\n"));
@@ -994,11 +1082,10 @@ int sci_Rand(char *fname, unsigned long fname_len)
         }
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = (double) C2F(ignnbn)(istk(la), stk(lb));
+            pdblData[i] = (double) C2F(ignnbn)(istk(la), stk(lb));
         }
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "bin") == 0)
     {
@@ -1008,18 +1095,20 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
         GetRhsVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lb);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
-        CreateVar(suite + 2, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
+        pdblData = createOutputVar(pvApiCtx, suite + 2, ResL, ResC, piDims, iDims);
+
         if ( *stk(lb) < 0.0 || *stk(lb) > 1.0 )
         {
             Scierror(999, _("P is not in [0,1]\n"));
@@ -1032,17 +1121,16 @@ int sci_Rand(char *fname, unsigned long fname_len)
         }
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = (double) C2F(ignbin)(istk(la), stk(lb));
+            pdblData[i] = (double) C2F(ignbin)(istk(la), stk(lb));
         }
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
 
     else if ( strcmp(cstk(ls), "mn") == 0)
     {
         int nn, un = 1, work, mp, parm, ierr;
-        if ( suite != 3 || ResL*ResC != 1)
+        if ( suite != 3 || ResL * ResC != 1)
         {
             Scierror(999, _("%s: Wrong value for input argument #%d: Must be the number of random simulation.\n"), fname, 1);
             return 0;
@@ -1092,12 +1180,11 @@ int sci_Rand(char *fname, unsigned long fname_len)
         }
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "markov") == 0)
     {
         int nn, n1p1, lr1, j, icur, mm, jj;
-        if ( suite != 3 || ResL*ResC != 1)
+        if ( suite != 3 || ResL * ResC != 1)
         {
             Scierror(999, _("%s: Wrong value for input argument #%d: Must be the number of random simulation.\n"), fname, 1);
             return 0;
@@ -1116,7 +1203,7 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
 
-        if ( m2*n2 == 0 )
+        if ( m2 * n2 == 0 )
         {
             Scierror(999, _("X0 is empty\n"));
             return 0;
@@ -1199,14 +1286,15 @@ int sci_Rand(char *fname, unsigned long fname_len)
             Scierror(999, _("%s: Wrong number of input argument.\n"), fname);
             return 0;
         }
-        CreateVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
+        pdblData = createOutputVar(pvApiCtx, suite, ResL, ResC, piDims, iDims);
+
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = C2F(ranf)();
+            pdblData[i] = C2F(ranf)();
         }
         LhsVar(1) = suite;
         PutLhsVar();
-        return 0;
     }
 
     else if ( strcmp(cstk(ls), "nch") == 0)
@@ -1217,30 +1305,32 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
         GetRhsVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lb);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
-        CreateVar(suite + 2, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
         if ( *stk(la) < 1.0 || *stk(lb) < 0.0 )
         {
             Scierror(999, _("DF < 1 or XNONC < 0\n"));
             return 0;
         }
+
+        pdblData = createOutputVar(pvApiCtx, suite + 2, ResL, ResC, piDims, iDims);
+
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = C2F(gennch)(stk(la), stk(lb));
+            pdblData[i] = C2F(gennch)(stk(la), stk(lb));
         }
         LhsVar(1) = suite + 2;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "nf") == 0)
     {
@@ -1250,38 +1340,39 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
         GetRhsVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lb);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
         GetRhsVar(suite + 2, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lc);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
-        CreateVar(suite + 3, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
         if ( *stk(la) < 1.0 || *stk(lb) < 0.0 || *stk(lc) < 0.0 )
         {
             Scierror(999, _("DF < 1.0 or DF <= 0.0 or Xnonc < 0.0\n"));
             return 0;
         }
+
+        pdblData = createOutputVar(pvApiCtx, suite + 3, ResL, ResC, piDims, iDims);
+
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = C2F(gennf)(stk(la), stk(lb), stk(lc));
+            pdblData[i] = C2F(gennf)(stk(la), stk(lb), stk(lc));
         }
         LhsVar(1) = suite + 3;
         PutLhsVar();
-        return 0;
     }
-
     else if ( strcmp(cstk(ls), "chi") == 0)
     {
         if ( Rhs != suite )
@@ -1290,24 +1381,26 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
-        CreateVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
         if  ( *stk(la) <= 0.0)
         {
             Scierror(999, _("Rand: DF <= 0\n"));
             return 0;
         }
+
+        pdblData = createOutputVar(pvApiCtx, suite + 1, ResL, ResC, piDims, iDims);
+
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = C2F(genchi)(stk(la));
+            pdblData[i] = C2F(genchi)(stk(la));
         }
         LhsVar(1) = suite + 1;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "poi") == 0)
     {
@@ -1317,24 +1410,26 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
-        CreateVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
         if ( *stk(la) < 0.0 )
         {
             Scierror(999, _("Av < 0\n"));
             return 0;
         }
+
+        pdblData = createOutputVar(pvApiCtx, suite + 1, ResL, ResC, piDims, iDims);
+
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = (double) C2F(ignpoi)(stk(la));
+            pdblData[i] = (double) C2F(ignpoi)(stk(la));
         }
         LhsVar(1) = suite + 1;
         PutLhsVar();
-        return 0;
     }
     else if ( strcmp(cstk(ls), "geom") == 0)
     {
@@ -1345,7 +1440,7 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
@@ -1357,14 +1452,14 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
 
-        CreateVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+        pdblData = createOutputVar(pvApiCtx, suite + 1, ResL, ResC, piDims, iDims);
+
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = igngeom(p);
+            pdblData[i] = igngeom(p);
         }
         LhsVar(1) = suite + 1;
         PutLhsVar();
-        return 0;
     }
 
     else if ( strcmp(cstk(ls), "exp") == 0)
@@ -1375,29 +1470,58 @@ int sci_Rand(char *fname, unsigned long fname_len)
             return 0;
         }
         GetRhsVar(suite, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-        if ( m1*n1 != 1)
+        if ( m1 * n1 != 1)
         {
             Scierror(999, _("%s: Wrong type for input argument: Scalar expected.\n"), fname);
             return 0;
         }
-        CreateVar(suite + 1, MATRIX_OF_DOUBLE_DATATYPE, &ResL, &ResC, &lr);
+
         if ( *stk(la) < 0.0 )
         {
             Scierror(999, _("Av < 0.0\n"));
             return 0;
         }
+
+        pdblData = createOutputVar(pvApiCtx, suite + 1, ResL, ResC, piDims, iDims);
+
         for ( i = 0 ; i < ResL * ResC ; i++)
         {
-            *stk(lr + i) = C2F(genexp)(stk(la));
+            pdblData[i] = C2F(genexp)(stk(la));
         }
         LhsVar(1) = suite + 1;
         PutLhsVar();
-        return 0;
     }
-
     else
     {
         Scierror(999, _("%s: Wrong value for input argument %s.\n"), fname, cstk(ls));
         return 0;
     }
+
+    if (piDims && iHyperMat == 0)
+    {
+        FREE(piDims);
+    }
+
+    return 0;
+}
+
+
+static double* createOutputVar(void* _pvCtx, int _iVar, int _iRows, int _iCols, int* _piDims, int _iDims)
+{
+    double* pdblData = NULL;
+    if (_piDims)
+    {
+        int* piAddr = NULL;
+        int* piAddrEntries = NULL;
+        int iRows = 0, iCols = 0;
+        allocHypermatOfDouble(pvApiCtx, _iVar, _piDims, _iDims, &pdblData);
+    }
+    else
+    {
+        int lr = 0;
+        CreateVar(_iVar, MATRIX_OF_DOUBLE_DATATYPE, &_iRows, &_iCols, &lr);
+        pdblData = stk(lr);
+    }
+
+    return pdblData;
 }
index 38947fd..084ba18 100644 (file)
@@ -2,8 +2,8 @@
 
 <!DOCTYPE GATEWAY SYSTEM "../../functions/xml/gateway.dtd">
 <GATEWAY name="randlib">
-<!-- =================== -->
-<!--
+    <!-- =================== -->
+    <!--
  Scilab
  Interface description. In this file, we define the list of the function which
  will be available into Scilab and the link to the "native" function.
@@ -22,7 +22,7 @@
  ===================
  Don't touch if you do not know what you are doing
 -->
-<!-- =================== -->
-
-<PRIMITIVE gatewayId="38" primitiveId="1" primitiveName="grand" />
-</GATEWAY>
\ No newline at end of file
+    <!-- =================== -->
+    
+    <PRIMITIVE gatewayId="38" primitiveId="1" primitiveName="grand" />
+</GATEWAY>
diff --git a/scilab/modules/randlib/tests/nonreg_tests/bug_5207.dia.ref b/scilab/modules/randlib/tests/nonreg_tests/bug_5207.dia.ref
new file mode 100644 (file)
index 0000000..fa6f142
--- /dev/null
@@ -0,0 +1,45 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Antoine ELIAS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// <-- Non-regression test for bug 5207 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=5207
+//
+// <-- Short Description -->
+// grand did not managed 3-D inputs/outputs
+//dimension as input parameters
+//init mt generator with seed = 1337
+grand("setsd", 1337);
+a = grand(3, 4, 5, "def");
+grand("setsd", 1337);
+ref = grand(1, 3 * 4 * 5, "def");
+ref = matrix(ref, [3, 4, 5]);
+assert_checkequal(a, ref);
+grand("setsd", 1337);
+a = grand(3, 4, 5, 6, "def");
+grand("setsd", 1337);
+ref = grand(1, 3 * 4 * 5 * 6, "def");
+ref = matrix(ref, [3, 4, 5, 6]);
+assert_checkequal(a, ref);
+//dimension from size of input parameter
+grand("setsd", 1337);
+Z = zeros(3,4,5);
+a = grand(Z, "def");
+grand("setsd", 1337);
+ref = grand(1, 3 * 4 * 5, "def");
+ref = matrix(ref, [3, 4, 5]);
+assert_checkequal(a, ref);
+grand("setsd", 1337);
+Z = zeros(3,4,5,6);
+a = grand(Z, "def");
+grand("setsd", 1337);
+ref = grand(1, 3 * 4 * 5 * 6, "def");
+ref = matrix(ref, [3, 4, 5, 6]);
+assert_checkequal(a, ref);
diff --git a/scilab/modules/randlib/tests/nonreg_tests/bug_5207.tst b/scilab/modules/randlib/tests/nonreg_tests/bug_5207.tst
new file mode 100644 (file)
index 0000000..ea54c2f
--- /dev/null
@@ -0,0 +1,51 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Antoine ELIAS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// <-- Non-regression test for bug 5207 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=5207
+//
+// <-- Short Description -->
+// grand did not managed 3-D inputs/outputs
+
+//dimension as input parameters
+
+//init mt generator with seed = 1337
+grand("setsd", 1337);
+a = grand(3, 4, 5, "def");
+grand("setsd", 1337);
+ref = grand(1, 3 * 4 * 5, "def");
+ref = matrix(ref, [3, 4, 5]);
+assert_checkequal(a, ref);
+
+grand("setsd", 1337);
+a = grand(3, 4, 5, 6, "def");
+grand("setsd", 1337);
+ref = grand(1, 3 * 4 * 5 * 6, "def");
+ref = matrix(ref, [3, 4, 5, 6]);
+assert_checkequal(a, ref);
+
+//dimension from size of input parameter
+grand("setsd", 1337);
+Z = zeros(3,4,5);
+a = grand(Z, "def");
+grand("setsd", 1337);
+ref = grand(1, 3 * 4 * 5, "def");
+ref = matrix(ref, [3, 4, 5]);
+assert_checkequal(a, ref);
+
+grand("setsd", 1337);
+Z = zeros(3,4,5,6);
+a = grand(Z, "def");
+grand("setsd", 1337);
+ref = grand(1, 3 * 4 * 5 * 6, "def");
+ref = matrix(ref, [3, 4, 5, 6]);
+assert_checkequal(a, ref);
+
index 9f7c11a..bfdc01e 100644 (file)
@@ -14,8 +14,8 @@
 //
 // <-- Short Description -->
 // grand returns non-empty matrix for negative size argument
-errMsg1 = msprintf(_("%s: Wrong value for input argument #1: Positive scalar expected.\n"),"Rand");
-errMsg2 = msprintf(_("%s: Wrong value for input argument #2: Positive scalar expected.\n"),"Rand");
+errMsg1 = msprintf(_("%s: Wrong value for input argument #1: Positive scalar expected.\n"),"grand");
+errMsg2 = msprintf(_("%s: Wrong value for input argument #2: Positive scalar expected.\n"),"grand");
 assert_checkequal(grand(1,0,'def'),[]);
 assert_checkerror("grand(-1,1,""def"");", errMsg1);
 assert_checkerror("grand(1,-1,""def"");", errMsg2);
index 2bf7d2d..d5973cb 100644 (file)
@@ -15,8 +15,8 @@
 // <-- Short Description -->
 // grand returns non-empty matrix for negative size argument
 
-errMsg1 = msprintf(_("%s: Wrong value for input argument #1: Positive scalar expected.\n"),"Rand");
-errMsg2 = msprintf(_("%s: Wrong value for input argument #2: Positive scalar expected.\n"),"Rand");
+errMsg1 = msprintf(_("%s: Wrong value for input argument #1: Positive scalar expected.\n"),"grand");
+errMsg2 = msprintf(_("%s: Wrong value for input argument #2: Positive scalar expected.\n"),"grand");
 assert_checkequal(grand(1,0,'def'),[]);
 assert_checkerror("grand(-1,1,""def"");", errMsg1);
 assert_checkerror("grand(1,-1,""def"");", errMsg2);
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_hypermat.dia.ref b/scilab/modules/randlib/tests/unit_tests/grand_hypermat.dia.ref
new file mode 100644 (file)
index 0000000..5447dc8
--- /dev/null
@@ -0,0 +1,98 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- CLI SHELL MODE -->
+// <-- ENGLISH INPOSED -->
+// Run with test_run('randlib', 'grand_hypermat', ['no_check_error_output'])
+///////////////////////////////////////////////////////////////////////////////
+//
+// Dimensions
+mat = grand(100, 101, 102, 'unf', 0, 1);
+assert_checktrue(size(mat) == [100 101 102]);
+///////////////////////////////////////////////////////////////////////////////
+//
+// Generators
+// The grand(i, j, ...) should be equal to the first element of grand(i, j, k, ...).
+// mt generator
+grand('setgen', 'mt');
+grand('setsd', 0);
+expected = grand(4, 6, 'def');
+grand('setsd', 0); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+grand('setsd', 0);
+expected = grand(4, 6, 'lgi');
+grand('setsd', 0); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
+// kiss generator
+grand('setgen', 'kiss');
+grand('setsd', 0, 0, 0, 0);
+expected = grand(4, 6, 'def');
+grand('setsd', 0, 0, 0, 0); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+grand('setsd', 0, 0, 0, 0);
+expected = grand(4, 6, 'lgi');
+grand('setsd', 0, 0, 0, 0); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
+// clcg2 generator
+grand('setgen', 'clcg2');
+grand('setsd', 1, 1);
+expected = grand(4, 6, 'def');
+grand('setsd', 1, 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+grand('setsd', 1, 1);
+expected = grand(4, 6, 'lgi');
+grand('setsd', 1, 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
+// clcg4 generator
+grand('setgen', 'clcg4');
+warning('off');
+grand('setsd',1,1,1,1);
+warning('on');
+expected = grand(4, 6, 'def');
+warning('off');
+grand('setsd',1,1,1,1); // Resetting the seed to obtain the same results
+warning('on');
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+warning('off');
+grand('setsd',1,1,1,1); // Resetting the seed to obtain the same results
+warning('on');
+expected = grand(4, 6, 'lgi');
+warning('off');
+grand('setsd',1,1,1,1); // Resetting the seed to obtain the same results
+warning('on');
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
+// fsultra generator
+grand('setgen', 'fsultra');
+grand('setsd', 1, 1);
+expected = grand(4, 6, 'def');
+grand('setsd', 1, 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+grand('setsd', 1, 1);
+expected = grand(4, 6, 'lgi');
+grand('setsd', 1, 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
+// urand generator
+grand('setgen', 'urand');
+grand('setsd', 1);
+expected = grand(4, 6, 'def');
+grand('setsd', 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+grand('setsd', 1);
+expected = grand(4, 6, 'lgi');
+grand('setsd', 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_hypermat.tst b/scilab/modules/randlib/tests/unit_tests/grand_hypermat.tst
new file mode 100644 (file)
index 0000000..9981edb
--- /dev/null
@@ -0,0 +1,109 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- CLI SHELL MODE -->
+// <-- ENGLISH INPOSED -->
+
+// Run with test_run('randlib', 'grand_hypermat', ['no_check_error_output'])
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Dimensions
+mat = grand(100, 101, 102, 'unf', 0, 1);
+assert_checktrue(size(mat) == [100 101 102]);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Generators
+// The grand(i, j, ...) should be equal to the first element of grand(i, j, k, ...).
+
+// mt generator
+grand('setgen', 'mt');
+grand('setsd', 0);
+expected = grand(4, 6, 'def');
+grand('setsd', 0); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+grand('setsd', 0);
+expected = grand(4, 6, 'lgi');
+grand('setsd', 0); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
+
+// kiss generator
+grand('setgen', 'kiss');
+grand('setsd', 0, 0, 0, 0);
+expected = grand(4, 6, 'def');
+grand('setsd', 0, 0, 0, 0); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+grand('setsd', 0, 0, 0, 0);
+expected = grand(4, 6, 'lgi');
+grand('setsd', 0, 0, 0, 0); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
+
+// clcg2 generator
+grand('setgen', 'clcg2');
+grand('setsd', 1, 1);
+expected = grand(4, 6, 'def');
+grand('setsd', 1, 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+grand('setsd', 1, 1);
+expected = grand(4, 6, 'lgi');
+grand('setsd', 1, 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
+
+// clcg4 generator
+grand('setgen', 'clcg4');
+warning('off');
+grand('setsd',1,1,1,1);
+warning('on');
+expected = grand(4, 6, 'def');
+warning('off');
+grand('setsd',1,1,1,1); // Resetting the seed to obtain the same results
+warning('on');
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+warning('off');
+grand('setsd',1,1,1,1); // Resetting the seed to obtain the same results
+warning('on');
+expected = grand(4, 6, 'lgi');
+warning('off');
+grand('setsd',1,1,1,1); // Resetting the seed to obtain the same results
+warning('on');
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
+
+// fsultra generator
+grand('setgen', 'fsultra');
+grand('setsd', 1, 1);
+expected = grand(4, 6, 'def');
+grand('setsd', 1, 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+grand('setsd', 1, 1);
+expected = grand(4, 6, 'lgi');
+grand('setsd', 1, 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));
+
+// urand generator
+grand('setgen', 'urand');
+grand('setsd', 1);
+expected = grand(4, 6, 'def');
+grand('setsd', 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'def');
+assert_checkequal(expected, computed(:, :, 1));
+grand('setsd', 1);
+expected = grand(4, 6, 'lgi');
+grand('setsd', 1); // Resetting the seed to obtain the same results
+computed = grand(4, 6, 5, 'lgi');
+assert_checkequal(expected, computed(:, :, 1));