randlib: Fixed bug #8560 41/2741/9
Michael Baudin [Fri, 10 Dec 2010 17:21:04 +0000 (18:21 +0100)]
Change-Id: I904fe7816d70883fb3d51947d51157cc067bceb6

28 files changed:
scilab/CHANGES_5.3.X
scilab/modules/randlib/help/en_US/grand.xml
scilab/modules/randlib/includes/clcg4.h
scilab/modules/randlib/includes/others_generators.h
scilab/modules/randlib/sci_gateway/c/sci_grand.c
scilab/modules/randlib/src/c/clcg2.c
scilab/modules/randlib/src/c/clcg4.c
scilab/modules/randlib/src/c/fsultra.c
scilab/modules/randlib/src/c/kiss.c
scilab/modules/randlib/src/c/mt.c
scilab/modules/randlib/src/c/urand.c
scilab/modules/randlib/tests/unit_tests/Rand.dia.ref [deleted file]
scilab/modules/randlib/tests/unit_tests/Rand.tst [deleted file]
scilab/modules/randlib/tests/unit_tests/grand.dia.ref [deleted file]
scilab/modules/randlib/tests/unit_tests/grand.tst [deleted file]
scilab/modules/randlib/tests/unit_tests/grand_clcg4.dia.ref [moved from scilab/modules/randlib/tests/unit_tests/grandb.dia.ref with 87% similarity]
scilab/modules/randlib/tests/unit_tests/grand_clcg4.tst [moved from scilab/modules/randlib/tests/unit_tests/grandb.tst with 100% similarity]
scilab/modules/randlib/tests/unit_tests/grand_generators.dia.ref [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grand_generators.tst [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grand_laws.dia.ref [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grand_laws.tst [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grand_laws2.dia.ref [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grand_laws2.tst [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grand_plot.dia.ref [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grand_plot.tst [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grand_prm.dia.ref [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grand_prm.tst [new file with mode: 0644]
scilab/modules/randlib/tests/unit_tests/grandb.sci [deleted file]

index 78ab7e9..c3ac5e1 100644 (file)
@@ -150,10 +150,10 @@ Xcos:
 * bug 8658 fixed - Use accentuated characters on file name lead to a modelica
                    compiler error.
 
-* bug 8674 fixed - xcosShowBlockWarning was not protected against arbitrary 
+* bug 8674 fixed - xcosShowBlockWarning was not protected against arbitrary
                    arguments.
 
-* bug 8696 fixed - An exception was thrown while linking and deleting the 
+* bug 8696 fixed - An exception was thrown while linking and deleting the
                    source block.
 
 * bug 8711 fixed - The "Cont. Plant-Hybrid Observer" demo contains a translated
@@ -259,6 +259,13 @@ Scilab:
 * Scilab startup script of the binary is now automatically synchronized with
   the one from the source tree.
 
+
+Statistics:
+==========
+
+* bug 8560 fixed - The grand function failed on 64 bits machines.
+
+
 Optimization:
 =============
 
index bfce9fa..76c3110 100644 (file)
@@ -2,6 +2,7 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA
+ * Copyright (C) 2010 - DIGITEO - Michael Baudin
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
   </refnamediv>
   <refsynopsisdiv>
     <title>Calling Sequence</title>
-    <synopsis>Y=grand(m, n, dist_type [,p1,...,pk])
-      Y=grand(X, dist_type [,p1,...,pk])
-      Y=grand(n, dist_type [,p1,...,pk])
-      S=grand(action [,q1,....,ql])</synopsis>
+    <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(n,'mn',Mean,Cov)
+      Y=grand(m,n,'geom', p)
+      Y=grand(n,'markov',P,x0)
+      Y=grand(n,'mul',nb,P)
+      Y=grand(m,n,'poi',mu)
+      Y=grand(n,'prm',vect)
+      Y=grand(m,n,'def')
+      Y=grand(m,n,'unf',Low,High)
+      Y=grand(m,n,'uin',Low,High)
+      Y=grand(m,n,'lgi')
+      S=grand('getgen')
+      grand('setgen',gen)
+      S=grand('getsd')
+      grand('setsd',S)
+      grand('setcgn',G)
+      S=grand('getcgn')
+      grand('initgn',I)
+      grand('setall',s1,s2,s3,s4)
+      grand('advnst',K)
+    </synopsis>
   </refsynopsisdiv>
   <refsection>
     <title>Arguments</title>
   <refsection>
     <title>Description</title>
     
-    <para>Warning: without a seed, the sequence will remain the same
-      from a session to the other.</para>
-    <para>At the beginning of each script using rand function, you
-      should use:</para>
-    <programlisting role="example"><![CDATA[rand('seed',getdate('s'))]]></programlisting>
-    
     <para>
       This function may be used to generate random numbers from various
       distributions. In this case you must apply one of the
@@ -396,9 +418,9 @@ scale       x          e          /  gamma(shape)
   </refsection>
   <refsection>
     <title>Set/get the current generator and its state</title>
-    <para> Since Scilab-2.7 you have the possibility to choose between different base 
+    <para> The user has the possibility to choose between different base 
       generators (which give random integers following the 'lgi' distribution, the others 
-      being gotten from it) :
+      being gotten from it).
     </para>
     <variablelist>
       <varlistentry>
@@ -421,7 +443,7 @@ scale       x          e          /  gamma(shape)
         <listitem>
           <para>a Combined 2 Linear Congruential Generator of P. L'Ecuyer,
             period about <literal>2^61</literal>, state given by <literal>2</literal> integers ; this was 
-            the only generator previously used by grand (but slightly modified)</para>
+            the only generator previously used by grand (but slightly modified).</para>
         </listitem>
       </varlistentry>
       <varlistentry>
@@ -649,6 +671,109 @@ scale       x          e          /  gamma(shape)
       and do the same  for the second method.  This assures that the initial data  for method two is 
       that used by  method  one.  When both  have concluded,  advance the block for both generators.</para>
   </refsection>
+
+  <refsection>
+    <title>Examples</title>
+
+    <para>
+    In the following example, we generate random numbers from various distributions and 
+    plot the associated histograms.
+    </para>
+
+    <programlisting role="example">
+<![CDATA[ 
+// Normal
+R = grand(400,800,"nor",0,1);
+histplot(10,R)
+// Uniform
+R = grand(400,800,"def");
+histplot(10,R)
+// Poisson
+R = grand(400,800,"poi",2);
+histplot(10,R)
+ ]]>
+</programlisting>
+
+    <para>
+    In the following example, we generate random numbers from the exponential distribution and 
+    then compare the empirical with the theoretical distribution.
+    </para>
+
+    <programlisting role="example">
+<![CDATA[ 
+lambda=1.6;
+N=100000;
+X = grand(1,100000,"exp",lambda);
+clf();
+classes = linspace(0,12,25);
+histplot(classes,X)
+x=linspace(0,12,25);
+y = (1/lambda)*exp(-(1/lambda)*x);
+plot(x,y,"ro-");
+legend(["Empirical" "Theory"]);
+ ]]>
+</programlisting>
+
+    <para>
+    In the following example, we generate random numbers from the gamma distribution and 
+    then compare the empirical with the theoretical distribution.
+    </para>
+
+    <programlisting role="example">
+<![CDATA[ 
+    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-"); // Empirical distribution
+    plot(XS,P,"r-"); // Theoretical distribution
+    legend(["Empirical" "Theory"]);
+ ]]>
+</programlisting>
+
+    <para>
+    In the following example, we generate 10 random integers in the [1,365] interval.
+    </para>
+
+    <programlisting role="example">
+<![CDATA[ 
+    grand(10,1,"uin",1,365)
+ ]]>
+</programlisting>
+
+    <para>
+    In the following example, we generate 12 permutations of the [1,2,...,7] set. 
+    The 12 permutations are stored column-by-column.
+    </para>
+
+    <programlisting role="example">
+<![CDATA[ 
+    grand(12,"prm",(1:7)')
+ ]]>
+</programlisting>
+
+    <para>
+    This pseudo random number generator is a deterministic sequence which aims at 
+    reproducing a independent identically distributed numbers.
+    In order to get reproducible simulations, the initial seed of the generator is constant, 
+    such that the sequence will remain the same from a session to the other. 
+    The first numbers produced by grand always are the same. 
+    In some situations, we may want to initialize the seed of the generator in 
+    order to produce less reproducible numbers. 
+    In this case, we may initialize the seed with the output of the getdate function:
+    </para>
+
+    <programlisting role="example">
+    <![CDATA[
+grand("setsd",getdate("s"))
+    ]]>
+    </programlisting>
+
+  </refsection>
+
   <refsection>
     <title>See Also</title>
     <simplelist type="inline">
@@ -666,7 +791,8 @@ scale       x          e          /  gamma(shape)
           <para>
             The codes to generate sequences following other distributions than def, unf, lgi,  uin and geom are
             from "Library of Fortran Routines for Random Number  Generation", by Barry W. Brown 
-            and James Lovato, Department of Biomathematics, The University of Texas, Houston.  
+            and James Lovato, Department of Biomathematics, The University of Texas, Houston.
+            The source code is available at : http://www.netlib.org/random/ranlib.f.tar.gz
           </para>
         </listitem>
       </varlistentry>
@@ -695,8 +821,15 @@ scale       x          e          /  gamma(shape)
         <term>clcg2</term>
         <listitem>
           <para>
-            The method is from P. L'Ecuyer but the C code is provided at the Luc  Devroye home page 
-            (<ulink url="http://cgm.cs.mcgill.ca/~luc/rng.html">http://cgm.cs.mcgill.ca/~luc/rng.html</ulink>).
+            The method is from P. L'Ecuyer but the C code is provided at Luc Devroye's home page 
+            (<ulink url="http://cg.scs.carleton.ca/~luc/rng.html">http://cg.scs.carleton.ca/~luc/rng.html</ulink> See "lecuyer.c".).
+            This generator is made of two linear congruential sequences s1 = a1*s1 mod m1, 
+            with a1 = 40014, m1 = 2147483563 and s2 = a2*s2 mod m2 , with a2 = 40692, m2 = 2147483399.
+            The output is computed from output =  s1-s2 mod (m1 - 1).
+            Therefore, output is in [0, 2147483561]. The perido is about 2.3 10^18.
+            The state is given by (s1, s2). In case of a user modification of the state we must have :
+            s1 in [1, m1-1] and s2 in [1, m2-1].
+            The default initial seeds are s1 = 1234567890  and s2 = 123456789.
           </para>
         </listitem>
       </varlistentry>
@@ -707,7 +840,8 @@ scale       x          e          /  gamma(shape)
             The code is from P. L'Ecuyer and Terry H.Andres and provided at the P. L'Ecuyer
             home page ( <ulink url="http://www.iro.umontreal.ca/~lecuyer/papers.html">http://www.iro.umontreal.ca/~lecuyer/papers.html</ulink>) A paper is also provided 
             and this new package is the logical successor of an old 's one from : P.  L'Ecuyer
-            and S. Cote.   Implementing a Random   Number Package with Splitting Facilities.  ACM Transactions 
+            and S. Cote.
+            Implementing a Random   Number Package with Splitting Facilities.  ACM Transactions
             on Mathematical  Software 17:1,pp 98-111.
           </para>
         </listitem>
@@ -728,6 +862,14 @@ scale       x          e          /  gamma(shape)
           </para>
         </listitem>
       </varlistentry>
+      <varlistentry>
+        <term>This help page</term>
+        <listitem>
+          <para>
+             Copyright (C) 2010 - DIGITEO - Michael Baudin
+          </para>
+        </listitem>
+      </varlistentry>
     </variablelist>
   </refsection>
 </refentry>
index 01a9d2d..d7e8ea2 100644 (file)
@@ -30,6 +30,6 @@ RANDLIB_IMPEXP void advance_state_clcg4(int g, int k);
 
 RANDLIB_IMPEXP int set_initial_seed_clcg4(double s0, double s1, double s2, double s3);
 
-RANDLIB_IMPEXP unsigned long clcg4(int g);
+RANDLIB_IMPEXP unsigned int clcg4(int g);
 
 #endif
index fe6e6d4..8e3d5f6 100644 (file)
 #include "dynlib_randlib.h"
 
 /* header for the Mersenne Twister */
-RANDLIB_IMPEXP unsigned long randmt(void);
+RANDLIB_IMPEXP unsigned int randmt(void);
 RANDLIB_IMPEXP int set_state_mt_simple(double s);
 RANDLIB_IMPEXP int set_state_mt(double seed_array[]);
 RANDLIB_IMPEXP void get_state_mt(double state[]);
 
 /* header for kiss */
-RANDLIB_IMPEXP unsigned long kiss(void);
+RANDLIB_IMPEXP unsigned int kiss(void);
 RANDLIB_IMPEXP int set_state_kiss(double g1, double g2, double g3, double g4);
 RANDLIB_IMPEXP void get_state_kiss(double g[]);
 
 /* header for clcg2 */
-RANDLIB_IMPEXP unsigned long clcg2(void);
+RANDLIB_IMPEXP unsigned int clcg2(void);
 RANDLIB_IMPEXP int set_state_clcg2(double g1, double g2);
 RANDLIB_IMPEXP void get_state_clcg2(double g[]);
 
 /* header for scilab urand */
-RANDLIB_IMPEXP unsigned long urandc(void);
+RANDLIB_IMPEXP unsigned int urandc(void);
 RANDLIB_IMPEXP int set_state_urand(double g);
 RANDLIB_IMPEXP void get_state_urand(double g[]);
 
 /* header for scilab fsultra */
-RANDLIB_IMPEXP unsigned long fsultra(void);
+RANDLIB_IMPEXP unsigned int fsultra(void);
 RANDLIB_IMPEXP int set_state_fsultra(double g[]);
 RANDLIB_IMPEXP int set_state_fsultra_simple(double g1,double g2);
 RANDLIB_IMPEXP void get_state_fsultra(double g[]);
index f040f50..741a883 100644 (file)
@@ -1,23 +1,23 @@
 
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) ENPC
- *
- * 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
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) ENPC
+*
+* 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
+*
+*/
 
 /*------------------------------------------------------------------------
- *    Interface for grand
- *    jpc@cermics.enpc.fr
- *    stuff to deal with several generators added
- *         by Bruno Pincon (12/11/2001)
- *
- --------------------------------------------------------------------------*/
+*    Interface for grand
+*    jpc@cermics.enpc.fr
+*    stuff to deal with several generators added
+*         by Bruno Pincon (12/11/2001)
+*
+--------------------------------------------------------------------------*/
 #include <string.h>
 #include <math.h>
 #ifdef _MSC_VER
@@ -47,7 +47,7 @@ static int current_clcg4 = 0;
 /* clcg4 must be called with the virtual generator number */
 static unsigned long int clcg4_with_gen(void)
 {
-  return ( clcg4(current_clcg4) );
+    return ( clcg4(current_clcg4) );
 }
 
 #define NbGenInScilab 6
@@ -61,1006 +61,1006 @@ static char *names_gen[NbGenInScilab] = { "mt",  "kiss","clcg4", "clcg2", "urand
 /* all the generators provided integers in [0, RngMaxInt] :        */
 static
 unsigned long RngMaxInt[NbGenInScilab] = { 4294967295ul,  /* mt    */
-                                          4294967295ul,  /* kiss  */
-                                          2147483646ul,  /* clcg4 */
-                                          2147483561ul,  /* clcg2 */
-                                          2147483647ul,  /* urand */
-                                          4294967295ul}; /* fsultra*/
+4294967295ul,  /* kiss  */
+2147483646ul,  /* clcg4 */
+2147483561ul,  /* clcg2 */
+2147483647ul,  /* urand */
+4294967295ul}; /* fsultra*/
 /* the factors (1/(RngMaxInt+1)) to get reals in [0,1) :           */
 static
 double factor[NbGenInScilab] = { 2.3283064365386963e-10,  /* mt    */
-                                2.3283064365386963e-10,  /* kiss  */
-                                 4.6566128752457969e-10,  /* clcg4 */
-                                4.6566130595601735e-10,  /* clcg2 */
-                                4.6566128730773926e-10,  /* urand */
-                                2.3283064365386963e-10}; /* fsultra*/
+2.3283064365386963e-10,  /* kiss  */
+4.6566128752457969e-10,  /* clcg4 */
+4.6566130595601735e-10,  /* clcg2 */
+4.6566128730773926e-10,  /* urand */
+2.3283064365386963e-10}; /* fsultra*/
 
 double C2F(ranf)(void)
 {
-  /* random deviate from U[0,1) */
-  return ( (double) gen[current_gen]() * factor[current_gen] );
+    /* random deviate from U[0,1) */
+    return ( (double) gen[current_gen]() * factor[current_gen] );
 }
 
 double ignlgi(void)
 {
-  /* random deviate from Ui[0,RngMaxInt] (direct output of the current gen) */
-  return ( (double) gen[current_gen]() );
+    /* random deviate from Ui[0,RngMaxInt] (direct output of the current gen) */
+    return ( (double) gen[current_gen]() );
 }
 
 double C2F(ignuin)(double *a, double *b)
 {
-  /*  random deviate from Ui[a,b]
-   *  it is assumed that : (i)  a and b are integers (stored in double)
-   *                       (ii) b-a+1 <= RngMaxInt[current_gen]
-   *  (these verif are done at the calling level)
-   *
-   *  We use the classic method with a minor difference : to choose
-   *  uniformly an int in [a,b] (ie d=b-a+1 numbers) with a generator
-   *  which provides uniformly integers in [0,RngMaxInt] (ie m=RngMaxInt+1
-   *  numbers) we do the Euclidian division :
-   *                                           m = q d + r,   r in [0,d-1]
-   *
-   *  and accept only numbers l in [0, qd-1], then the output is k = a + (l mod d)
-   *  (ie numbers falling in [qd , RngMaxInt] are rejected).
-   *  The problem is that RngMaxInt is 2^32-1 for mt and kiss so that RngMaxInt+1 = 0
-   *  with the 32 bits unsigned int arithmetic. So in place of rejected r
-   *  numbers we reject r+1 by using RngMaxInt in place of m. The constraint is
-   *  then that (b-a+1) <= RngMaxInt and if we doesn't want to deal we each generator
-   *  we take (b-a+1) <= Min RngMaxInt =  2147483561 (clcg2)
-   */
-  unsigned long k, d = (unsigned long)((*b-*a)+1), qd;
+    /*  random deviate from Ui[a,b]
+    *  it is assumed that : (i)  a and b are integers (stored in double)
+    *                       (ii) b-a+1 <= RngMaxInt[current_gen]
+    *  (these verif are done at the calling level)
+    *
+    *  We use the classic method with a minor difference : to choose
+    *  uniformly an int in [a,b] (ie d=b-a+1 numbers) with a generator
+    *  which provides uniformly integers in [0,RngMaxInt] (ie m=RngMaxInt+1
+    *  numbers) we do the Euclidian division :
+    *                                           m = q d + r,   r in [0,d-1]
+    *
+    *  and accept only numbers l in [0, qd-1], then the output is k = a + (l mod d)
+    *  (ie numbers falling in [qd , RngMaxInt] are rejected).
+    *  The problem is that RngMaxInt is 2^32-1 for mt and kiss so that RngMaxInt+1 = 0
+    *  with the 32 bits unsigned int arithmetic. So in place of rejected r
+    *  numbers we reject r+1 by using RngMaxInt in place of m. The constraint is
+    *  then that (b-a+1) <= RngMaxInt and if we doesn't want to deal we each generator
+    *  we take (b-a+1) <= Min RngMaxInt =  2147483561 (clcg2)
+    */
+    unsigned long k, d = (unsigned long)((*b-*a)+1), qd;
 
-  if ( d == 1)
-    return (*a);
+    if ( d == 1)
+        return (*a);
 
-  qd = RngMaxInt[current_gen] - RngMaxInt[current_gen] % d;
-  do
+    qd = RngMaxInt[current_gen] - RngMaxInt[current_gen] % d;
+    do
     {
-      k = (unsigned long)ignlgi();
+        k = (unsigned long)ignlgi();
     }
-  while ( k >= qd );
-  return ( *a + (double)(k % d) );
+    while ( k >= qd );
+    return ( *a + (double)(k % d) );
 }
 
 /**************************************************
- *  hand written interface for the randlib
- ***********************************************************************/
+*  hand written interface for the randlib
+***********************************************************************/
 
 int sci_Rand(char *fname,unsigned long fname_len)
 {
-  int minrhs = 1,maxrhs = 10,minlhs=1,maxlhs=2;
-  int ResL,ResC,suite,m2,n2,l2,m1,n1,l1,ls,ms,ns,la,lr,lb,lc;
-  int l3,l4;
-  int i;
+    int minrhs = 1,maxrhs = 10,minlhs=1,maxlhs=2;
+    int ResL,ResC,suite,m2,n2,l2,m1,n1,l1,ls,ms,ns,la,lr,lb,lc;
+    int l3,l4;
+    int i;
 
-  Nbvars = 0;
-  CheckRhs(minrhs,maxrhs);
-  CheckLhs(minlhs,maxlhs);
-  if ( GetType(1) != sci_matrix)
+    Nbvars = 0;
+    CheckRhs(minrhs,maxrhs);
+    CheckLhs(minlhs,maxlhs);
+    if ( GetType(1) != sci_matrix)
     {
-     int un=1,deux=2, dim_state_mt=625, dim_state_fsultra = 40, dim_state_4=4;
-      GetRhsVar(1,STRING_DATATYPE,&ms,&ns,&ls);
-      if ( strcmp(cstk(ls),"getsd")==0)
-       {
-               if ( Rhs != 1 )
-           {
-                       Scierror(999,_("%s: Wrong number of input argument: %d expected with option '%s'.\n"),fname,1,"getsd");
-                       return 0;
-           }
-               if ( Lhs != 1 )
-                       {
-                               Scierror(999,_("%s: Wrong number of output argument: %d expected the option '%s'.\n"),fname,1,"getsd");
-                               return 0;
-                       }
+        int un=1,deux=2, dim_state_mt=625, dim_state_fsultra = 40, dim_state_4=4;
+        GetRhsVar(1,STRING_DATATYPE,&ms,&ns,&ls);
+        if ( strcmp(cstk(ls),"getsd")==0)
+        {
+            if ( Rhs != 1 )
+            {
+                Scierror(999,_("%s: Wrong number of input argument: %d expected with option '%s'.\n"),fname,1,"getsd");
+                return 0;
+            }
+            if ( Lhs != 1 )
+            {
+                Scierror(999,_("%s: Wrong number of output argument: %d expected the option '%s'.\n"),fname,1,"getsd");
+                return 0;
+            }
 
-             switch(current_gen)
-               {
-               case(MT) :
-                 CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&dim_state_mt,&un,&lr);
-                 get_state_mt(stk(lr));
-                 break;
-               case(KISS) :
-                 CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&dim_state_4,&un,&lr);
-                 get_state_kiss(stk(lr));
-                 break;
-               case(CLCG4) :
-                 CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&dim_state_4,&un,&lr);
-                 get_state_clcg4(current_clcg4, stk(lr));
-                 break;
-               case(CLCG2) :
-                 CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&deux,&un,&lr);
-                 get_state_clcg2(stk(lr));
-                 break;
-               case(URAND) :
-                 CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&un,&un,&lr);
-                 get_state_urand(stk(lr));
-                 break;
-               case(FSULTRA) :
-                 CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&dim_state_fsultra,&un,&lr);
-                 get_state_fsultra(stk(lr));
-                 break;
-               };
-             LhsVar(1) = Rhs+2;
-             PutLhsVar();
-             return 0;
-           }
-         else if ( strcmp(cstk(ls),"setall")==0 )
-           {
-             if ( current_gen != CLCG4 )
-                         sciprint(_("The %s option affects only the clcg4 generator\n"),"setall");
-             if ( Rhs != 5 )
-               {
-                 Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,5,"setall");
-                 return 0;
-               }
-             GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
-             if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname);
-             return 0;}
-             GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l2);
-             if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong type for third input argument: Scalar expected.\n"),fname);
-             return 0;}
-             GetRhsVar(4,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l3);
-             if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong type for fourth input argument: Scalar expected.\n"),fname);
-             return 0;}
-             GetRhsVar(5,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l4);
-             if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong type for fifth input argument: Scalar expected.\n"),fname);
-             return 0;}
+            switch(current_gen)
+            {
+            case(MT) :
+                CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&dim_state_mt,&un,&lr);
+                get_state_mt(stk(lr));
+                break;
+            case(KISS) :
+                CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&dim_state_4,&un,&lr);
+                get_state_kiss(stk(lr));
+                break;
+            case(CLCG4) :
+                CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&dim_state_4,&un,&lr);
+                get_state_clcg4(current_clcg4, stk(lr));
+                break;
+            case(CLCG2) :
+                CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&deux,&un,&lr);
+                get_state_clcg2(stk(lr));
+                break;
+            case(URAND) :
+                CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&un,&un,&lr);
+                get_state_urand(stk(lr));
+                break;
+            case(FSULTRA) :
+                CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&dim_state_fsultra,&un,&lr);
+                get_state_fsultra(stk(lr));
+                break;
+            };
+            LhsVar(1) = Rhs+2;
+            PutLhsVar();
+            return 0;
+        }
+        else if ( strcmp(cstk(ls),"setall")==0 )
+        {
+            if ( current_gen != CLCG4 )
+                sciprint(_("The %s option affects only the clcg4 generator\n"),"setall");
+            if ( Rhs != 5 )
+            {
+                Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,5,"setall");
+                return 0;
+            }
+            GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
+            if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname);
+            return 0;}
+            GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l2);
+            if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong type for third input argument: Scalar expected.\n"),fname);
+            return 0;}
+            GetRhsVar(4,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l3);
+            if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong type for fourth input argument: Scalar expected.\n"),fname);
+            return 0;}
+            GetRhsVar(5,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l4);
+            if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong type for fifth input argument: Scalar expected.\n"),fname);
+            return 0;}
 
-             if (! set_initial_seed_clcg4(*stk(l1),*stk(l2), *stk(l3), *stk(l4)) )
-               {   /* => seeds were not good  (info is displayed by the function) */
-                 SciError(999);return 0;
-               }
-             LhsVar(1) = 1;
-             PutLhsVar();
-             return(0);
-           }
-      else if ( strcmp(cstk(ls),"setsd")==0 )
-       {
-         switch(current_gen)
-           {
-           case(MT) :
-             if ( Rhs != 2 )
-               {
-                 Scierror(999,_("%s: Wrong number of input arguments: %d expected for '%s' with the %s generator.\n"),fname,2,"setall","mt");
-                 return 0;
-               }
-             GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
-             if ( m1*n1 == 1)          /* simple init of mt     */
-               { if (! set_state_mt_simple(*stk(l1)) ) {SciError(999); return(0);}; }
-             else if ( m1*n1 == 625 )  /* init of all the state */
-               { if (! set_state_mt(stk(l1))) {SciError(999); return(0);}; }
-             else
-               {
-                       Scierror(999,_("%s: Wrong values for input argument: Vector of %d or %d values for %s expected.\n"),fname,1, 625,"mt");
-                       return 0;
-               };
-             break;
+            if (! set_initial_seed_clcg4(*stk(l1),*stk(l2), *stk(l3), *stk(l4)) )
+            {   /* => seeds were not good  (info is displayed by the function) */
+                SciError(999);return 0;
+            }
+            LhsVar(1) = 1;
+            PutLhsVar();
+            return(0);
+        }
+        else if ( strcmp(cstk(ls),"setsd")==0 )
+        {
+            switch(current_gen)
+            {
+            case(MT) :
+                if ( Rhs != 2 )
+                {
+                    Scierror(999,_("%s: Wrong number of input arguments: %d expected for '%s' with the %s generator.\n"),fname,2,"setall","mt");
+                    return 0;
+                }
+                GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
+                if ( m1*n1 == 1)          /* simple init of mt     */
+                { if (! set_state_mt_simple(*stk(l1)) ) {SciError(999); return(0);}; }
+                else if ( m1*n1 == 625 )  /* init of all the state */
+                { if (! set_state_mt(stk(l1))) {SciError(999); return(0);}; }
+                else
+                {
+                    Scierror(999,_("%s: Wrong values for input argument: Vector of %d or %d values for %s expected.\n"),fname,1, 625,"mt");
+                    return 0;
+                };
+                break;
 
-           case(FSULTRA) :
-             if ( Rhs == 2 ) /* init via a "complete" state */
-               {
-                 GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
-                 if ( m1 != 40  ||  n1 != 1)
-                   {
-                     Scierror(999,_("%s: Wrong size for second input argument: %dx%d expected.\n"),fname,40,1);
-                     return 0;
-                   };
-                 if (! set_state_fsultra(stk(l1)) ) {SciError(999); return(0);};
-               }
-             else if ( Rhs == 3 ) /* init with 2 integers (like before) */
-               {
-                 GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
-                 if ( m1*n1 != 1)
-                   { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname); return 0;};
-                 GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l2);
-                 if ( m1*n1 != 1)
-                   { Scierror(999,_("%s: Wrong type for third input argument: Scalar expected.\n"),fname); return 0;};
-                 if (! set_state_fsultra_simple(*stk(l1),*stk(l2)) ) {SciError(999); return(0);};
-               }
-             else
-               {
-                       Scierror(999,_("%s: Wrong number of input arguments: %d or %d expected for '%s' option with the %s generator.\n"),fname,2,3,"setsd","fsultra");
-                 return 0;
-               }
-             break;
+            case(FSULTRA) :
+                if ( Rhs == 2 ) /* init via a "complete" state */
+                {
+                    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
+                    if ( m1 != 40  ||  n1 != 1)
+                    {
+                        Scierror(999,_("%s: Wrong size for second input argument: %dx%d expected.\n"),fname,40,1);
+                        return 0;
+                    };
+                    if (! set_state_fsultra(stk(l1)) ) {SciError(999); return(0);};
+                }
+                else if ( Rhs == 3 ) /* init with 2 integers (like before) */
+                {
+                    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
+                    if ( m1*n1 != 1)
+                    { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname); return 0;};
+                    GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l2);
+                    if ( m1*n1 != 1)
+                    { Scierror(999,_("%s: Wrong type for third input argument: Scalar expected.\n"),fname); return 0;};
+                    if (! set_state_fsultra_simple(*stk(l1),*stk(l2)) ) {SciError(999); return(0);};
+                }
+                else
+                {
+                    Scierror(999,_("%s: Wrong number of input arguments: %d or %d expected for '%s' option with the %s generator.\n"),fname,2,3,"setsd","fsultra");
+                    return 0;
+                }
+                break;
 
-           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)
-               { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname); return 0;}
-             GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l2);
-             if ( m1*n1 != 1)
-               { Scierror(999,_("%s: Wrong type for third input argument: Scalar expected.\n"),fname); return 0;}
-             GetRhsVar(4,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l3);
-             if ( m1*n1 != 1)
-               { Scierror(999,_("%s: Wrong type for fourth input argument: Scalar expected.\n"),fname); return 0;}
-             GetRhsVar(5,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l4);
-             if ( m1*n1 != 1)
-               { Scierror(999,_("%s: Wrong type for fifth input argument: Scalar expected.\n"),fname); return 0;}
-             if (current_gen == KISS)
-               {if (! set_state_kiss(*stk(l1),*stk(l2),*stk(l3),*stk(l4))) {SciError(999); return 0;};}
-             else
-               {if (! set_seed_clcg4(current_clcg4,*stk(l1),*stk(l2),*stk(l3),*stk(l4)))
-                 {SciError(999); return 0;};}
-             break;
+            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)
+                { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname); return 0;}
+                GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l2);
+                if ( m1*n1 != 1)
+                { Scierror(999,_("%s: Wrong type for third input argument: Scalar expected.\n"),fname); return 0;}
+                GetRhsVar(4,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l3);
+                if ( m1*n1 != 1)
+                { Scierror(999,_("%s: Wrong type for fourth input argument: Scalar expected.\n"),fname); return 0;}
+                GetRhsVar(5,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l4);
+                if ( m1*n1 != 1)
+                { Scierror(999,_("%s: Wrong type for fifth input argument: Scalar expected.\n"),fname); return 0;}
+                if (current_gen == KISS)
+                {if (! set_state_kiss(*stk(l1),*stk(l2),*stk(l3),*stk(l4))) {SciError(999); return 0;};}
+                else
+                {if (! set_seed_clcg4(current_clcg4,*stk(l1),*stk(l2),*stk(l3),*stk(l4)))
+                {SciError(999); return 0;};}
+                break;
 
-           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)
-               { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname); return 0;};
-             GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l2);
-             if ( m1*n1 != 1)
-               { Scierror(999,_("%s: Wrong type for third input argument: Scalar expected.\n"),fname); return 0;};
-             if (! set_state_clcg2(*stk(l1),*stk(l2)))
-               { SciError(999); return 0;};
-             break;
+            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)
+                { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname); return 0;};
+                GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l2);
+                if ( m1*n1 != 1)
+                { Scierror(999,_("%s: Wrong type for third input argument: Scalar expected.\n"),fname); return 0;};
+                if (! set_state_clcg2(*stk(l1),*stk(l2)))
+                { SciError(999); return 0;};
+                break;
 
-           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)
-               { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname); return 0;};
-             if (! set_state_urand(*stk(l1)))
-               {SciError(999); return 0;};
-             break;
-           };
-         LhsVar(1) = 0;
-         PutLhsVar();
-         return 0;
-       }
-      else if (strcmp("phr2sd",cstk(ls)) == 0)
-       {
-               if ( Rhs != 2 )
-           {
-                       Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,2,"phr2sd");
-                       return 0;
-               }
-               if ( Lhs > 1 ) 
-                       {
-                 Scierror(999,_("%s: Wrong number of output argument: %d expected with option '%s'.\n"),fname,1,"phr2sd");
+            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)
+                { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname); return 0;};
+                if (! set_state_urand(*stk(l1)))
+                {SciError(999); return 0;};
+                break;
+            };
+            LhsVar(1) = 0;
+            PutLhsVar();
+            return 0;
+        }
+        else if (strcmp("phr2sd",cstk(ls)) == 0)
+        {
+            if ( Rhs != 2 )
+            {
+                Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,2,"phr2sd");
+                return 0;
+            }
+            if ( Lhs > 1 ) 
+            {
+                Scierror(999,_("%s: Wrong number of output argument: %d expected with option '%s'.\n"),fname,1,"phr2sd");
 
-             return 0;
-           }
-         GetRhsVar(2,STRING_DATATYPE,&m1,&n1,&l1);
-         CreateVar(3,MATRIX_OF_INTEGER_DATATYPE,&un,&deux,&l2);
+                return 0;
+            }
+            GetRhsVar(2,STRING_DATATYPE,&m1,&n1,&l1);
+            CreateVar(3,MATRIX_OF_INTEGER_DATATYPE,&un,&deux,&l2);
 
-         C2F(phrtsd)(cstk(l1),&m1,istk(l2),istk(l2+1),m1);
-         LhsVar(1) = 3;
-         PutLhsVar();
-         return 0;
-       }
+            C2F(phrtsd)(cstk(l1),&m1,istk(l2),istk(l2+1),m1);
+            LhsVar(1) = 3;
+            PutLhsVar();
+            return 0;
+        }
 
-      else if (strcmp("initgn",cstk(ls))==0)
-       {
-         SeedType Where;
-         if ( current_gen != CLCG4 )
-           sciprint(_("%s: The %s option affects only the %s generator\n"),fname,"initgn","clcg4");
-         if ( Rhs != 2)
-           {
-                 Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,2,"initgn");
-             return 0;
-           }
-         GetRhsVar(2,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l1);
-         if ( *istk(l1) != 0 && *istk(l1)!= -1 && *istk(l1) != 1)
-           {
-                       Scierror(999,_("%s: Wrong value for second input argument: %d, %d or %d expected.\n"),fname, -1, 0, 1);
-                       return 0;
-           }
-         Where = (SeedType) (*istk(l1) + 1);
-         init_generator_clcg4(current_clcg4, Where);
-         LhsVar(1) = 2;
-         PutLhsVar();
-         return 0;
-       }
-      else if (strcmp("setcgn",cstk(ls))==0)
-       {
-         if ( current_gen != CLCG4 )
-           sciprint(_("The %s option affects only the %s generator\n"),"setcgn","clcg4");
-         if ( Rhs != 2)
-           {
-                 Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,2,"setcgn");
-             return 0;
-           }
-         GetRhsVar(2,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l1);
-         if ( *istk(l1) < 0 || *istk(l1) > Maxgen )
-           {
-             Scierror(999,_("%s: Wrong value for second input argument: Must be between %d and %d.\n"),fname,0, Maxgen);
-             return 0;
-           }
-         current_clcg4 = *istk(l1);
-         LhsVar(1) = 2;
-         PutLhsVar();
-         return 0;
-       }
-      else if (strcmp("advnst",cstk(ls))==0)
-       {
-         int k;
-         if ( current_gen != CLCG4 )
-           sciprint(_("The %s option affects only the %s generator\n"),"advnst","clcg4");
-         if ( Rhs != 2)
-           {
-                 Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,2,"advnst");
-             return 0;
-           }
-         GetRhsVar(2,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l1);
-         k = *istk(l1);
-         if ( k < 1 )
-           {
-             Scierror(999,_("%s: Wrong value for second input argument: Must be > %d.\n"),fname,0);
-             return 0;
-           }
-         advance_state_clcg4(current_clcg4, k);
-         LhsVar(1) = 2;
-         PutLhsVar();
-         return 0;
-       }
-      else if (strcmp("getcgn",cstk(ls))==0)
-       {
-         if ( Rhs != 1)
-           {
-                 Scierror(999,_("%s: Wrong number of input argument: %d expected with option '%s'.\n"),fname,1,"getcgn");
-             return 0;
-           }
-         if ( current_gen != CLCG4 )
-           sciprint(_("This information concerns only the clcg4 generator\n"));
-         CreateVar(2,MATRIX_OF_INTEGER_DATATYPE,&un,&un,&l1);
-         *istk(l1) = current_clcg4;
-         LhsVar(1) = 2;
-         PutLhsVar();
-         return 0;
-       }
-      else if (strcmp("setgen",cstk(ls))==0)
-       {
-         int msb, nsb, lsb;
-         if ( Rhs != 2)
-           {
-                 Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,2,"setgen");
-             return 0;
-           }
-         GetRhsVar(2,STRING_DATATYPE,&msb,&nsb,&lsb);
-         if (strcmp("mt",cstk(lsb))==0)
-           current_gen = MT;
-         else if (strcmp("kiss",cstk(lsb))==0)
-           current_gen = KISS;
-         else if (strcmp("clcg4",cstk(lsb))==0)
-           current_gen = CLCG4;
-         else if (strcmp("clcg2",cstk(lsb))==0)
-           current_gen = CLCG2;
-         else if (strcmp("urand",cstk(lsb))==0)
-           current_gen = URAND;
-         else if (strcmp("fsultra",cstk(lsb))==0)
-           current_gen = FSULTRA;
-         else
-           {
-             Scierror(999,_("%s: Wrong value for second input argument: '%s', '%s', '%s', '%s', '%s' or '%s' expected.\n"),fname,"mt","kiss","clcg4","clcg2","urand","fsultra");
-             return 0;
-           }
-         LhsVar(1) = 2;
-         PutLhsVar();
-         return 0;
-       }
-      else if (strcmp("getgen",cstk(ls))==0)
-       {
-         int l_un=1;
-         if ( Rhs != 1)
-           {
-                 Scierror(999,_("%s: Wrong number of input argument: %d expected with option '%s'.\n"),fname,1,"getgen");
-             return 0;
-           }
-         CreateVarFromPtr( Rhs+2,MATRIX_OF_STRING_DATATYPE, &l_un, &l_un, &names_gen[current_gen]);
-         LhsVar(1) = Rhs+2;
-         PutLhsVar();
-         return 0;
-       }
-      else
-       {
-         Scierror(999,_("%s Wrong value for first input argument %s.\n"),fname,cstk(ls));
+        else if (strcmp("initgn",cstk(ls))==0)
+        {
+            SeedType Where;
+            if ( current_gen != CLCG4 )
+                sciprint(_("%s: The %s option affects only the %s generator\n"),fname,"initgn","clcg4");
+            if ( Rhs != 2)
+            {
+                Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,2,"initgn");
+                return 0;
+            }
+            GetRhsVar(2,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l1);
+            if ( *istk(l1) != 0 && *istk(l1)!= -1 && *istk(l1) != 1)
+            {
+                Scierror(999,_("%s: Wrong value for second input argument: %d, %d or %d expected.\n"),fname, -1, 0, 1);
+                return 0;
+            }
+            Where = (SeedType) (*istk(l1) + 1);
+            init_generator_clcg4(current_clcg4, Where);
+            LhsVar(1) = 2;
+            PutLhsVar();
+            return 0;
+        }
+        else if (strcmp("setcgn",cstk(ls))==0)
+        {
+            if ( current_gen != CLCG4 )
+                sciprint(_("The %s option affects only the %s generator\n"),"setcgn","clcg4");
+            if ( Rhs != 2)
+            {
+                Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,2,"setcgn");
+                return 0;
+            }
+            GetRhsVar(2,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l1);
+            if ( *istk(l1) < 0 || *istk(l1) > Maxgen )
+            {
+                Scierror(999,_("%s: Wrong value for second input argument: Must be between %d and %d.\n"),fname,0, Maxgen);
+                return 0;
+            }
+            current_clcg4 = *istk(l1);
+            LhsVar(1) = 2;
+            PutLhsVar();
+            return 0;
+        }
+        else if (strcmp("advnst",cstk(ls))==0)
+        {
+            int k;
+            if ( current_gen != CLCG4 )
+                sciprint(_("The %s option affects only the %s generator\n"),"advnst","clcg4");
+            if ( Rhs != 2)
+            {
+                Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,2,"advnst");
+                return 0;
+            }
+            GetRhsVar(2,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l1);
+            k = *istk(l1);
+            if ( k < 1 )
+            {
+                Scierror(999,_("%s: Wrong value for second input argument: Must be > %d.\n"),fname,0);
+                return 0;
+            }
+            advance_state_clcg4(current_clcg4, k);
+            LhsVar(1) = 2;
+            PutLhsVar();
+            return 0;
+        }
+        else if (strcmp("getcgn",cstk(ls))==0)
+        {
+            if ( Rhs != 1)
+            {
+                Scierror(999,_("%s: Wrong number of input argument: %d expected with option '%s'.\n"),fname,1,"getcgn");
+                return 0;
+            }
+            if ( current_gen != CLCG4 )
+                sciprint(_("This information concerns only the clcg4 generator\n"));
+            CreateVar(2,MATRIX_OF_INTEGER_DATATYPE,&un,&un,&l1);
+            *istk(l1) = current_clcg4;
+            LhsVar(1) = 2;
+            PutLhsVar();
+            return 0;
+        }
+        else if (strcmp("setgen",cstk(ls))==0)
+        {
+            int msb, nsb, lsb;
+            if ( Rhs != 2)
+            {
+                Scierror(999,_("%s: Wrong number of input arguments: %d expected with option '%s'.\n"),fname,2,"setgen");
+                return 0;
+            }
+            GetRhsVar(2,STRING_DATATYPE,&msb,&nsb,&lsb);
+            if (strcmp("mt",cstk(lsb))==0)
+                current_gen = MT;
+            else if (strcmp("kiss",cstk(lsb))==0)
+                current_gen = KISS;
+            else if (strcmp("clcg4",cstk(lsb))==0)
+                current_gen = CLCG4;
+            else if (strcmp("clcg2",cstk(lsb))==0)
+                current_gen = CLCG2;
+            else if (strcmp("urand",cstk(lsb))==0)
+                current_gen = URAND;
+            else if (strcmp("fsultra",cstk(lsb))==0)
+                current_gen = FSULTRA;
+            else
+            {
+                Scierror(999,_("%s: Wrong value for second input argument: '%s', '%s', '%s', '%s', '%s' or '%s' expected.\n"),fname,"mt","kiss","clcg4","clcg2","urand","fsultra");
+                return 0;
+            }
+            LhsVar(1) = 2;
+            PutLhsVar();
+            return 0;
+        }
+        else if (strcmp("getgen",cstk(ls))==0)
+        {
+            int l_un=1;
+            if ( Rhs != 1)
+            {
+                Scierror(999,_("%s: Wrong number of input argument: %d expected with option '%s'.\n"),fname,1,"getgen");
+                return 0;
+            }
+            CreateVarFromPtr( Rhs+2,MATRIX_OF_STRING_DATATYPE, &l_un, &l_un, &names_gen[current_gen]);
+            LhsVar(1) = Rhs+2;
+            PutLhsVar();
+            return 0;
+        }
+        else
+        {
+            Scierror(999,_("%s Wrong value for first input argument %s.\n"),fname,cstk(ls));
 
-         return 0;
-       }
+            return 0;
+        }
     }
-  minrhs = 2;
-  CheckRhs(minrhs,maxrhs);
-  if ( GetType(2) == sci_matrix ) /** m,n,'string' */
+    minrhs = 2;
+    CheckRhs(minrhs,maxrhs);
+    if ( GetType(2) == sci_matrix ) /** m,n,'string' */
     {
-               GetRhsVar(1, MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &l1);
-       if ( m1*n1 != 1)
-         { Scierror(999,_("%s: Wrong type for first input argument: Scalar expected.\n"),fname);return 0;}
-      ResL= *istk(l1);
-      GetRhsVar(2,MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
-      if ( m2*n2 != 1)
-       { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname);return 0;}
-      ResC= *istk(l2);
-      GetRhsVar(3,STRING_DATATYPE, &ms, &ns, &ls);
-      suite=4;
+        GetRhsVar(1, MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &l1);
+        if ( m1*n1 != 1)
+        { Scierror(999,_("%s: Wrong type for first input argument: Scalar expected.\n"),fname);return 0;}
+        ResL= *istk(l1);
+        GetRhsVar(2,MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
+        if ( m2*n2 != 1)
+        { Scierror(999,_("%s: Wrong type for second input argument: Scalar expected.\n"),fname);return 0;}
+        ResC= *istk(l2);
+        GetRhsVar(3,STRING_DATATYPE, &ms, &ns, &ls);
+        suite=4;
     }
-  else
+    else
     {
-      GetRhsVar(1,MATRIX_OF_INTEGER_DATATYPE, &ResL, &ResC, &l1);
-      GetRhsVar(2,STRING_DATATYPE, &ms, &ns, &ls);
-      suite = 3;
+        GetRhsVar(1,MATRIX_OF_INTEGER_DATATYPE, &ResL, &ResC, &l1);
+        GetRhsVar(2,STRING_DATATYPE, &ms, &ns, &ls);
+        suite = 3;
     }
-  if ( strcmp(cstk(ls),"bet")==0)
+    if ( strcmp(cstk(ls),"bet")==0)
     {
-      double minlog=1.e-37;
-      if ( Rhs != suite + 1)
-       { Scierror(999,_("Missing A and B for beta law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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) { 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);
-      if ( *stk(la) < minlog || *stk(lb) < minlog)
-       {
-         Scierror(999,_("Rand(...,'bet',..): A or B < %f\n"),minlog);
-         return 0;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= C2F(genbet)(stk(la),stk(lb));
-       }
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+        double minlog=1.e-37;
+        if ( Rhs != suite + 1)
+        { Scierror(999,_("Missing A and B for beta law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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) { 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);
+        if ( *stk(la) < minlog || *stk(lb) < minlog)
+        {
+            Scierror(999,_("Rand(...,'bet',..): A or B < %f\n"),minlog);
+            return 0;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= C2F(genbet)(stk(la),stk(lb));
+        }
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"f")==0)
+    else if ( strcmp(cstk(ls),"f")==0)
     {
-      if ( Rhs != suite + 1)
-       { Scierror(999,_("Missing Dfn and Dfd for F law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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) { 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);
-      if ( *stk(la) <= 0.0 || *stk(lb) <= 0.0)
-       {
-         Scierror(999,_("Degrees of freedom nonpositive\n"));
-         return 0;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= C2F(genf)(stk(la),stk(lb));
-       }
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite + 1)
+        { Scierror(999,_("Missing Dfn and Dfd for F law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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) { 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);
+        if ( *stk(la) <= 0.0 || *stk(lb) <= 0.0)
+        {
+            Scierror(999,_("Degrees of freedom nonpositive\n"));
+            return 0;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= C2F(genf)(stk(la),stk(lb));
+        }
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"mul")==0)
+    else if ( strcmp(cstk(ls),"mul")==0)
     {
-      int l_i,nn,ncat;
-      double ptot;
-      if ( suite != 3 || ResL*ResC != 1)
-       { Scierror(999,_("%s: Wrong value for first input argument: Must be the number of random deviate.\n"),fname);
-       return 0;
-       }
-      nn= *istk(l1);
-      if ( Rhs != suite + 1)
-       { Scierror(999,_("Missing N and P for MULtinomial law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &la);
-      if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong size for input argument: Scalar expected for %s.\n"),fname,"N");return 0;}
-      GetRhsVar(suite+1,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &lb);
-      if ( n2 != 1 )
-       {
-         Scierror(999,_("%s: Wrong size for input argument: Column vector expected.\n"),fname);
-         return 0;
-       }
-      ncat = m2+1;
-      CreateVar(suite+2,MATRIX_OF_INTEGER_DATATYPE,&ncat,&nn,&lr);
-      if ( *istk(la) < 0 )
-       {
-         Scierror(999,_("N < 0\n"));
-         return 0;
-       }
-      if ( ncat <= 1)
-       {
-         Scierror(999,_("Ncat <= 1\n"));
-         return 0;
-       }
-      ptot = 0.0;
-      for ( l_i= 0 ; l_i < ncat -1 ; l_i++ )
-       {
-         if ( *stk(lb+l_i) < 0.0 )
-           {
-             Scierror(999,_("P(%d) < 0\n"),l_i+1);
-             return 0;
-           }
-         if ( *stk(lb+l_i) > 1.0 )
-           {
-             Scierror(999,_("P(%d) > 1\n"),l_i+1);
-             return 0;
-           }
-         ptot += *stk(lb+l_i);
-       }
-      if ( ptot > 1.0)
-       {
-         Scierror(999,_("Sum of P(i) > 1\n"));
-         return 0;
-       }
-      for ( l_i=0 ; l_i < nn ; l_i++)
-       {
-         C2F(genmul)(istk(la),stk(lb),&ncat,istk(lr+ncat*l_i));
-       }
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+        int l_i,nn,ncat;
+        double ptot;
+        if ( suite != 3 || ResL*ResC != 1)
+        { Scierror(999,_("%s: Wrong value for first input argument: Must be the number of random deviate.\n"),fname);
+        return 0;
+        }
+        nn= *istk(l1);
+        if ( Rhs != suite + 1)
+        { Scierror(999,_("Missing N and P for MULtinomial law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &la);
+        if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong size for input argument: Scalar expected for %s.\n"),fname,"N");return 0;}
+        GetRhsVar(suite+1,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &lb);
+        if ( n2 != 1 )
+        {
+            Scierror(999,_("%s: Wrong size for input argument: Column vector expected.\n"),fname);
+            return 0;
+        }
+        ncat = m2+1;
+        CreateVar(suite+2,MATRIX_OF_INTEGER_DATATYPE,&ncat,&nn,&lr);
+        if ( *istk(la) < 0 )
+        {
+            Scierror(999,_("N < 0\n"));
+            return 0;
+        }
+        if ( ncat <= 1)
+        {
+            Scierror(999,_("Ncat <= 1\n"));
+            return 0;
+        }
+        ptot = 0.0;
+        for ( l_i= 0 ; l_i < ncat -1 ; l_i++ )
+        {
+            if ( *stk(lb+l_i) < 0.0 )
+            {
+                Scierror(999,_("P(%d) < 0\n"),l_i+1);
+                return 0;
+            }
+            if ( *stk(lb+l_i) > 1.0 )
+            {
+                Scierror(999,_("P(%d) > 1\n"),l_i+1);
+                return 0;
+            }
+            ptot += *stk(lb+l_i);
+        }
+        if ( ptot > 1.0)
+        {
+            Scierror(999,_("Sum of P(i) > 1\n"));
+            return 0;
+        }
+        for ( l_i=0 ; l_i < nn ; l_i++)
+        {
+            C2F(genmul)(istk(la),stk(lb),&ncat,istk(lr+ncat*l_i));
+        }
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"gam")==0)
+    else if ( strcmp(cstk(ls),"gam")==0)
     {
-      if ( Rhs != suite + 1)
+        if ( Rhs != suite + 1)
 
-       /*  ETRE PLUS CONSISTANT ICI : choisir entre shape , scale ou
+            /*  ETRE PLUS CONSISTANT ICI : choisir entre shape , scale ou
             bien A et R (idem pour le man)
-       */
-       { Scierror(999,_("Missing shape and scale for Gamma law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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) { Scierror(999,_("%s: Wrong size for input argument: Scalar expected for %s.\n"),fname,"scale");return 0;}
-      CreateVar(suite+2,MATRIX_OF_DOUBLE_DATATYPE,&ResL,&ResC,&lr);
-      if ( (*stk(la)) <= 0.0 ||  (*stk(lb)) <= 0.0 )
-       {
-         Scierror(999,_("grand(..'gam',A,R) : A <= 0.0 or R <= 0.0\n")); return 0;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         /** WARNING : order is changed in parameters for
-             compatibility between Rand(...'gam',..) and cdfgam
-         **/
-         *stk(lr+i)= C2F(gengam)(stk(lb),stk(la));
-       }
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+            */
+        { Scierror(999,_("Missing shape and scale for Gamma law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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) { Scierror(999,_("%s: Wrong size for input argument: Scalar expected for %s.\n"),fname,"scale");return 0;}
+        CreateVar(suite+2,MATRIX_OF_DOUBLE_DATATYPE,&ResL,&ResC,&lr);
+        if ( (*stk(la)) <= 0.0 ||  (*stk(lb)) <= 0.0 )
+        {
+            Scierror(999,_("grand(..'gam',A,R) : A <= 0.0 or R <= 0.0\n")); return 0;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            /** WARNING : order is changed in parameters for
+            compatibility between Rand(...'gam',..) and cdfgam
+            **/
+            *stk(lr+i)= C2F(gengam)(stk(lb),stk(la));
+        }
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
 
-  else if ( strcmp(cstk(ls),"nor")==0)
+    else if ( strcmp(cstk(ls),"nor")==0)
     {
-      if ( Rhs != suite + 1)
-       { Scierror(999,_("Missing Av and Sd for Normal law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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) { 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);
-      if ( *stk(lb) < 0 )
-       {
-         Scierror(999,_("SD < 0.0\n"));return 0;}
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= C2F(gennor)(stk(la),stk(lb));
-       }
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite + 1)
+        { Scierror(999,_("Missing Av and Sd for Normal law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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) { 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);
+        if ( *stk(lb) < 0 )
+        {
+            Scierror(999,_("SD < 0.0\n"));return 0;}
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= C2F(gennor)(stk(la),stk(lb));
+        }
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"unf")==0)
+    else if ( strcmp(cstk(ls),"unf")==0)
     {
-      double low, high;
-      if ( Rhs != suite + 1)
-       { Scierror(999,_("Missing Low and High for Uniform Real law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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) { Scierror(999,_("%s: Wrong type for input argument: Scalar expected.\n"),fname);return 0;}
-      CreateVar(suite+2,MATRIX_OF_DOUBLE_DATATYPE,&ResL,&ResC,&lr);
-      low = *stk(la) ; high =  *stk(lb);
-      if ( low > high )
-       {
-         Scierror(999,_("Low > High\n"));
-         return 0;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       *stk(lr+i)= low + (high - low)* C2F(ranf)();
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+        double low, high;
+        if ( Rhs != suite + 1)
+        { Scierror(999,_("Missing Low and High for Uniform Real law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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) { Scierror(999,_("%s: Wrong type for input argument: Scalar expected.\n"),fname);return 0;}
+        CreateVar(suite+2,MATRIX_OF_DOUBLE_DATATYPE,&ResL,&ResC,&lr);
+        low = *stk(la) ; high =  *stk(lb);
+        if ( low > high )
+        {
+            Scierror(999,_("Low > High\n"));
+            return 0;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+            *stk(lr+i)= low + (high - low)* C2F(ranf)();
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"uin")==0)
+    else if ( strcmp(cstk(ls),"uin")==0)
     {
-      double a, b;
-      if ( Rhs != suite + 1)
-       { Scierror(999,_("Missing Low and High for Uniform int law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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) { Scierror(999,_("%s: Wrong type for input argument: Scalar expected.\n"),fname);return 0;}
-      a = *stk(la) ; b = *stk(lb);
-      if ( a != floor(a) || b != floor(b) || (b-a+1) > 2147483561 )
-       {
-         Scierror(999,_("a and b must integers with (b-a+1) <= 2147483561"));
-         return 0;
-       }
-      CreateVar(suite+2,MATRIX_OF_DOUBLE_DATATYPE,&ResL,&ResC,&lr);
-      for ( i=0 ; i < ResL*ResC ; i++)
-       *stk(lr+i)= C2F(ignuin)(stk(la),stk(lb));
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+        double a, b;
+        if ( Rhs != suite + 1)
+        { Scierror(999,_("Missing Low and High for Uniform int law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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) { Scierror(999,_("%s: Wrong type for input argument: Scalar expected.\n"),fname);return 0;}
+        a = *stk(la) ; b = *stk(lb);
+        if ( a != floor(a) || b != floor(b) || (b-a+1) > 2147483561 )
+        {
+            Scierror(999,_("a and b must integers with (b-a+1) <= 2147483561"));
+            return 0;
+        }
+        CreateVar(suite+2,MATRIX_OF_DOUBLE_DATATYPE,&ResL,&ResC,&lr);
+        for ( i=0 ; i < ResL*ResC ; i++)
+            *stk(lr+i)= C2F(ignuin)(stk(la),stk(lb));
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"lgi")==0)
+    else if ( strcmp(cstk(ls),"lgi")==0)
     {
-      if ( Rhs != suite -1 )
-       {
-         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);
-      for ( i=0 ; i < ResL*ResC ; i++)
-       *stk(lr+i)= ignlgi();
-      LhsVar(1) = suite;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite -1 )
+        {
+            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);
+        for ( i=0 ; i < ResL*ResC ; i++)
+            *stk(lr+i)= ignlgi();
+        LhsVar(1) = suite;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"prm")==0)
+    else if ( strcmp(cstk(ls),"prm")==0)
     {
-      int nn;
-      if ( suite != 3 || ResL*ResC != 1)
-       {
-         Scierror(999,_("%s: Wrong value for input argument: Number of random simulation expected.\n"),fname);
-         return 0;
-       }
-      nn= *istk(l1);
-      if ( Rhs != suite)
-       {
-         Scierror(999,_("Missing vect for random permutation\n"));
-         return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      if ( n1 != 1) { Scierror(999,_("%s: Wrong type for input argument: Column vector expected.\n"),fname);
-      return 0;}
-      CreateVar(suite+1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&nn,&lr);
-      for ( i=0 ; i < nn ; i++)
-       {
-         int j ;
-         for (j=0; j < m1 ; j++ ) *stk(lr+(m1)*i+j)= *stk(la+j);
-         C2F(genprm)(stk(lr+(m1)*i),&m1);
-       }
-      LhsVar(1) = suite+1;
-      PutLhsVar();
-      return 0;
+        int nn;
+        if ( suite != 3 || ResL*ResC != 1)
+        {
+            Scierror(999,_("%s: Wrong value for input argument: Number of random simulation expected.\n"),fname);
+            return 0;
+        }
+        nn= *istk(l1);
+        if ( Rhs != suite)
+        {
+            Scierror(999,_("Missing vect for random permutation\n"));
+            return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        if ( n1 != 1) { Scierror(999,_("%s: Wrong type for input argument: Column vector expected.\n"),fname);
+        return 0;}
+        CreateVar(suite+1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&nn,&lr);
+        for ( i=0 ; i < nn ; i++)
+        {
+            int j ;
+            for (j=0; j < m1 ; j++ ) *stk(lr+(m1)*i+j)= *stk(la+j);
+            C2F(genprm)(stk(lr+(m1)*i),&m1);
+        }
+        LhsVar(1) = suite+1;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"nbn")==0)
+    else if ( strcmp(cstk(ls),"nbn")==0)
     {
-      if ( Rhs != suite + 1)
-       { Scierror(999,_("Missing N and P for Negative Binomial law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &la);
-      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) { 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(lb) < 0.0 || *stk(lb) > 1.0 )
-       {
-         Scierror(999,_("P is not in [0,1]\n"));
-         return 0;
-       }
-      if ( *istk(la) < 0 )
-       {
-         Scierror(999,_("N < 0\n"));
-         return 0;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= (double) C2F(ignnbn)(istk(la),stk(lb));
-       }
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite + 1)
+        { Scierror(999,_("Missing N and P for Negative Binomial law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &la);
+        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) { 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(lb) < 0.0 || *stk(lb) > 1.0 )
+        {
+            Scierror(999,_("P is not in [0,1]\n"));
+            return 0;
+        }
+        if ( *istk(la) < 0 )
+        {
+            Scierror(999,_("N < 0\n"));
+            return 0;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= (double) C2F(ignnbn)(istk(la),stk(lb));
+        }
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"bin")==0)
+    else if ( strcmp(cstk(ls),"bin")==0)
     {
-      if ( Rhs != suite + 1)
-       { Scierror(999,_("Missing N and P for Binomial law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &la);
-      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) { 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(lb) < 0.0 || *stk(lb) > 1.0 )
-       {
-         Scierror(999,_("P is not in [0,1]\n"));
-         return 0;
-       }
-      if ( *istk(la) < 0 )
-       {
-         Scierror(999,_("N < 0\n"));
-         return 0;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= (double) C2F(ignbin)(istk(la),stk(lb));
-       }
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite + 1)
+        { Scierror(999,_("Missing N and P for Binomial law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_INTEGER_DATATYPE, &m1, &n1, &la);
+        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) { 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(lb) < 0.0 || *stk(lb) > 1.0 )
+        {
+            Scierror(999,_("P is not in [0,1]\n"));
+            return 0;
+        }
+        if ( *istk(la) < 0 )
+        {
+            Scierror(999,_("N < 0\n"));
+            return 0;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= (double) C2F(ignbin)(istk(la),stk(lb));
+        }
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
 
-  else if ( strcmp(cstk(ls),"mn")==0)
+    else if ( strcmp(cstk(ls),"mn")==0)
     {
-      int nn,un=1,work,mp,parm,ierr;
-      if ( suite != 3 || ResL*ResC != 1)
-       { Scierror(999,_("%s: Wrong value for first input argument: Must be the number of random simulation.\n"),fname);return 0;
-       }
-      nn= *istk(l1);
-      if ( Rhs != suite + 1)
-       { Scierror(999,_("Missing Mean and Cov for Multivariate Normal law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      if ( n1 != 1) { Scierror(999,_("%s: Wrong type for input argument: Column vector expected.\n"),fname);return 0;}
-      GetRhsVar(suite+1,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &lb);
-      if ( m2 != n2 ) { Scierror(999,_("%s: Wrong type for input argument: Square matrix expected.\n"),fname);return 0;}
-      if ( m2 != m1 ) { Scierror(999,_("%s: Wrong type for input arguments: Mean and Cov have incompatible dimensions\n"),fname);return 0;}
+        int nn,un=1,work,mp,parm,ierr;
+        if ( suite != 3 || ResL*ResC != 1)
+        { Scierror(999,_("%s: Wrong value for first input argument: Must be the number of random simulation.\n"),fname);return 0;
+        }
+        nn= *istk(l1);
+        if ( Rhs != suite + 1)
+        { Scierror(999,_("Missing Mean and Cov for Multivariate Normal law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        if ( n1 != 1) { Scierror(999,_("%s: Wrong type for input argument: Column vector expected.\n"),fname);return 0;}
+        GetRhsVar(suite+1,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &lb);
+        if ( m2 != n2 ) { Scierror(999,_("%s: Wrong type for input argument: Square matrix expected.\n"),fname);return 0;}
+        if ( m2 != m1 ) { Scierror(999,_("%s: Wrong type for input arguments: Mean and Cov have incompatible dimensions\n"),fname);return 0;}
 
-      CreateVar(suite+2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&nn,&lr);
-      CreateVar(suite+3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&un,&work);
-      mp=m1*(m1+3)/2 + 1;
-      CreateVar(suite+4,MATRIX_OF_DOUBLE_DATATYPE,&mp,&un,&parm);
-      if ( m1 <= 0 )
-       {
-         Scierror(999,_("%s: Wrong size for input arguments: Mean and Cov are of null size.\n"),fname);
-         return 0;
-       }
-      C2F(setgmn)(stk(la),stk(lb),&m2,&m1,stk(parm),&ierr);
-      if ( ierr == 1)
-       {
-         SciError(999);return 0;
-       }
-      for ( i=0 ; i < nn ; i++)
-       {
-         C2F(genmn)(stk(parm),stk(lr+(m1)*i),stk(work));
-       }
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+        CreateVar(suite+2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&nn,&lr);
+        CreateVar(suite+3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&un,&work);
+        mp=m1*(m1+3)/2 + 1;
+        CreateVar(suite+4,MATRIX_OF_DOUBLE_DATATYPE,&mp,&un,&parm);
+        if ( m1 <= 0 )
+        {
+            Scierror(999,_("%s: Wrong size for input arguments: Mean and Cov are of null size.\n"),fname);
+            return 0;
+        }
+        C2F(setgmn)(stk(la),stk(lb),&m2,&m1,stk(parm),&ierr);
+        if ( ierr == 1)
+        {
+            SciError(999);return 0;
+        }
+        for ( i=0 ; i < nn ; i++)
+        {
+            C2F(genmn)(stk(parm),stk(lr+(m1)*i),stk(work));
+        }
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"markov")==0)
+    else if ( strcmp(cstk(ls),"markov")==0)
     {
-      int nn,n1p1,lr1,j,icur,mm,jj;
-      if ( suite != 3 || ResL*ResC != 1)
-       { Scierror(999,_("%s: Wrong value for first input argument: Must be the number of random simulation.\n"),fname);return 0;
-       }
-      nn= *istk(l1);
-      if ( Rhs != suite +1 )
-       { Scierror(999,_("%s: Missing P matrix and X0 for Markov chain\n"),"fname");return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      GetRhsVar(suite+1,MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &lb);
-      if ( m1 != n1 && m1 != 1 )
-       {
-         Scierror(999,_("%s: Wrong second input argument: Square matrix or row vector expected.\n"), fname);return 0;
-       }
+        int nn,n1p1,lr1,j,icur,mm,jj;
+        if ( suite != 3 || ResL*ResC != 1)
+        { Scierror(999,_("%s: Wrong value for first input argument: Must be the number of random simulation.\n"),fname);return 0;
+        }
+        nn= *istk(l1);
+        if ( Rhs != suite +1 )
+        { Scierror(999,_("%s: Missing P matrix and X0 for Markov chain\n"),"fname");return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        GetRhsVar(suite+1,MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &lb);
+        if ( m1 != n1 && m1 != 1 )
+        {
+            Scierror(999,_("%s: Wrong second input argument: Square matrix or row vector expected.\n"), fname);return 0;
+        }
 
-      if ( m2*n2 == 0 ) { Scierror(999,_("X0 is empty\n"));return 0;}
+        if ( m2*n2 == 0 ) { Scierror(999,_("X0 is empty\n"));return 0;}
 
-      for ( i = 0 ; i < m2*n2 ; i++)
-       if ( *istk(lb+i)-1 < 0 || *istk(lb+i)-1 >= n1 )
-         {
-           Scierror(999,_("%s: X0(%d) must be in the range [1,%d]\n"),fname,i,n1);
-           return 0;
-         }
-      mm= m2*n2;
-      CreateVar(suite+2,MATRIX_OF_INTEGER_DATATYPE,&mm,&nn,&lr);
+        for ( i = 0 ; i < m2*n2 ; i++)
+            if ( *istk(lb+i)-1 < 0 || *istk(lb+i)-1 >= n1 )
+            {
+                Scierror(999,_("%s: X0(%d) must be in the range [1,%d]\n"),fname,i,n1);
+                return 0;
+            }
+            mm= m2*n2;
+            CreateVar(suite+2,MATRIX_OF_INTEGER_DATATYPE,&mm,&nn,&lr);
 
-      n1p1=n1+1;
-      CreateVar(suite+3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1p1,&lr1);
-      for ( i= 0 ; i < m1 ; i++ )
-       {
-         double ptot = 0.0;
-         for ( j = 0 ; j < n1 ; j++ )
-           {
-             if ( *stk(la+i+m1*j) < 0 )
-               {
-                 Scierror(999,_("P(%d,%d) < 0\n"),i+1,j+1);
-                 return 0;
-               }
-             if ( *stk(la+i+m1*j) > 1 )
-               {
-                 Scierror(999,_("P(%d,%d) > 1\n"),i+1,j+1);
-                 return 0;
-               }
-             ptot += *stk(la+i+m1*j) ;
-           }
-         if ( fabs(ptot-1.0) > 1e-8 )
-           {
-             Scierror(999,_("Sum of P(%d,1:%d)=%f ~= 1\n"),i+1,n1,ptot);
-             return 0;
-           }
-       }
-      /** Computing the cumulative sum of the P matrix **/
-      for ( i = 0 ; i < m1 ; i++)
-       {
-         double cumsum=0.0;
-         *stk(lr1 +i) = cumsum;
-         for ( j= 1; j < n1p1 ; j++ )
-           {
-             cumsum += *stk(la + i + m1*(j-1));
-             *stk(lr1+i+m1*j) = cumsum;
-           }
-       }
-      for ( jj = 0 ; jj < mm ; jj++)
-       {
-         icur = *istk(lb+jj)-1;
-         for ( i=0 ; i < nn ; i++)
-           {
-             int niv=0;
-             double rr = C2F(ranf)();
-             if ( m1 == 1 ) icur =0;
-             while ( rr >= *stk(lr1+ icur +m1*niv) && niv < n1p1 )
-               {
-                 niv++;
-               }
-             /** projection to avoid boundaries **/
-             niv = Max(Min(niv,n1),1);
-             *istk(lr+jj+mm*i)= niv ;
-             icur=niv-1;
-           }
-       }
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+            n1p1=n1+1;
+            CreateVar(suite+3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1p1,&lr1);
+            for ( i= 0 ; i < m1 ; i++ )
+            {
+                double ptot = 0.0;
+                for ( j = 0 ; j < n1 ; j++ )
+                {
+                    if ( *stk(la+i+m1*j) < 0 )
+                    {
+                        Scierror(999,_("P(%d,%d) < 0\n"),i+1,j+1);
+                        return 0;
+                    }
+                    if ( *stk(la+i+m1*j) > 1 )
+                    {
+                        Scierror(999,_("P(%d,%d) > 1\n"),i+1,j+1);
+                        return 0;
+                    }
+                    ptot += *stk(la+i+m1*j) ;
+                }
+                if ( fabs(ptot-1.0) > 1e-8 )
+                {
+                    Scierror(999,_("Sum of P(%d,1:%d)=%f ~= 1\n"),i+1,n1,ptot);
+                    return 0;
+                }
+            }
+            /** Computing the cumulative sum of the P matrix **/
+            for ( i = 0 ; i < m1 ; i++)
+            {
+                double cumsum=0.0;
+                *stk(lr1 +i) = cumsum;
+                for ( j= 1; j < n1p1 ; j++ )
+                {
+                    cumsum += *stk(la + i + m1*(j-1));
+                    *stk(lr1+i+m1*j) = cumsum;
+                }
+            }
+            for ( jj = 0 ; jj < mm ; jj++)
+            {
+                icur = *istk(lb+jj)-1;
+                for ( i=0 ; i < nn ; i++)
+                {
+                    int niv=0;
+                    double rr = C2F(ranf)();
+                    if ( m1 == 1 ) icur =0;
+                    while ( rr >= *stk(lr1+ icur +m1*niv) && niv < n1p1 )
+                    {
+                        niv++;
+                    }
+                    /** projection to avoid boundaries **/
+                    niv = Max(Min(niv,n1),1);
+                    *istk(lr+jj+mm*i)= niv ;
+                    icur=niv-1;
+                }
+            }
+            LhsVar(1) = suite+2;
+            PutLhsVar();
+            return 0;
     }
-  else if ( strcmp(cstk(ls),"def")==0)
+    else if ( strcmp(cstk(ls),"def")==0)
     {
-      if ( Rhs != suite -1 )
-       { Scierror(999,_("%s: Wrong number of input argument.\n"),fname);return 0;}
-      CreateVar(suite,MATRIX_OF_DOUBLE_DATATYPE,&ResL,&ResC,&lr);
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= C2F(ranf)();
-       }
-      LhsVar(1) = suite;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite -1 )
+        { Scierror(999,_("%s: Wrong number of input argument.\n"),fname);return 0;}
+        CreateVar(suite,MATRIX_OF_DOUBLE_DATATYPE,&ResL,&ResC,&lr);
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= C2F(ranf)();
+        }
+        LhsVar(1) = suite;
+        PutLhsVar();
+        return 0;
     }
 
-  else if ( strcmp(cstk(ls),"nch")==0)
+    else if ( strcmp(cstk(ls),"nch")==0)
     {
-      if ( Rhs != suite + 1)
-       { Scierror(999,_("Missing Df and Xnonc for non-central chi-square law\n"));return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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) { 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;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= C2F(gennch)(stk(la),stk(lb));
-       }
-      LhsVar(1) = suite+2;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite + 1)
+        { Scierror(999,_("Missing Df and Xnonc for non-central chi-square law\n"));return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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) { 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;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= C2F(gennch)(stk(la),stk(lb));
+        }
+        LhsVar(1) = suite+2;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"nf")==0)
+    else if ( strcmp(cstk(ls),"nf")==0)
     {
-      if ( Rhs != suite + 2)
-       {
-         Scierror(999,_("Missing Dfn, Dfd and Xnonc for non-central F law\n"));
-         return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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) { 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) { 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;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= C2F(gennf)(stk(la),stk(lb),stk(lc));
-       }
-      LhsVar(1) = suite+3;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite + 2)
+        {
+            Scierror(999,_("Missing Dfn, Dfd and Xnonc for non-central F law\n"));
+            return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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) { 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) { 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;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= C2F(gennf)(stk(la),stk(lb),stk(lc));
+        }
+        LhsVar(1) = suite+3;
+        PutLhsVar();
+        return 0;
     }
 
-  else if ( strcmp(cstk(ls),"chi")==0)
+    else if ( strcmp(cstk(ls),"chi")==0)
     {
-      if ( Rhs != suite )
-       { Scierror(999,_("Missing Df for chi-square law\n"));
-       return 0;
-       }
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= C2F(genchi)(stk(la));
-       }
-      LhsVar(1) = suite+1;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite )
+        { Scierror(999,_("Missing Df for chi-square law\n"));
+        return 0;
+        }
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= C2F(genchi)(stk(la));
+        }
+        LhsVar(1) = suite+1;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"poi")==0)
+    else if ( strcmp(cstk(ls),"poi")==0)
     {
-      if ( Rhs != suite )
-       { Scierror(999,_("Missing Av for Poisson law\n"));
-       return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= (double) C2F(ignpoi)(stk(la));
-       }
-      LhsVar(1) = suite+1;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite )
+        { Scierror(999,_("Missing Av for Poisson law\n"));
+        return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= (double) C2F(ignpoi)(stk(la));
+        }
+        LhsVar(1) = suite+1;
+        PutLhsVar();
+        return 0;
     }
-  else if ( strcmp(cstk(ls),"geom")==0)
+    else if ( strcmp(cstk(ls),"geom")==0)
     {
-      double p;
-      if ( Rhs != suite )
-       { Scierror(999,_("Missing p for Geometric law\n"));
-       return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong type for input argument: Scalar expected.\n"),fname);return 0;}
-      p = *stk(la);
-      if ( p < 1.3e-307 || p > 1 ) { Scierror(999,_("%s: Wrong value for input argument: Must be between '%s' and %d.\n"),fname,"pmin",1);return 0;}
+        double p;
+        if ( Rhs != suite )
+        { Scierror(999,_("Missing p for Geometric law\n"));
+        return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        if ( m1*n1 != 1) { Scierror(999,_("%s: Wrong type for input argument: Scalar expected.\n"),fname);return 0;}
+        p = *stk(la);
+        if ( p < 1.3e-307 || p > 1 ) { Scierror(999,_("%s: Wrong value for input argument: Must be between '%s' and %d.\n"),fname,"pmin",1);return 0;}
 
-      CreateVar(suite+1,MATRIX_OF_DOUBLE_DATATYPE,&ResL,&ResC,&lr);
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= igngeom(p);
-       }
-      LhsVar(1) = suite+1;
-      PutLhsVar();
-      return 0;
+        CreateVar(suite+1,MATRIX_OF_DOUBLE_DATATYPE,&ResL,&ResC,&lr);
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= igngeom(p);
+        }
+        LhsVar(1) = suite+1;
+        PutLhsVar();
+        return 0;
     }
 
-  else if ( strcmp(cstk(ls),"exp")==0)
+    else if ( strcmp(cstk(ls),"exp")==0)
     {
-      if ( Rhs != suite )
-       { Scierror(999,_("Missing Av for exponential law\n"));
-       return 0;}
-      GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
-      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;
-       }
-      for ( i=0 ; i < ResL*ResC ; i++)
-       {
-         *stk(lr+i)= C2F(genexp)(stk(la));
-       }
-      LhsVar(1) = suite+1;
-      PutLhsVar();
-      return 0;
+        if ( Rhs != suite )
+        { Scierror(999,_("Missing Av for exponential law\n"));
+        return 0;}
+        GetRhsVar(suite,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &la);
+        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;
+        }
+        for ( i=0 ; i < ResL*ResC ; i++)
+        {
+            *stk(lr+i)= C2F(genexp)(stk(la));
+        }
+        LhsVar(1) = suite+1;
+        PutLhsVar();
+        return 0;
     }
 
-  else
+    else
     {
-      Scierror(999,_("%s: Wrong value for input argument %s.\n"),fname,cstk(ls));
-      return 0;
+        Scierror(999,_("%s: Wrong value for input argument %s.\n"),fname,cstk(ls));
+        return 0;
     }
 }
index 2effae9..147e800 100644 (file)
@@ -1,4 +1,10 @@
 /*  
+ * 
+ * Copyright (C) 2010 - DIGITEO - Michael Baudin
+ * Copyright (C) 2004 - Bruno Pincon
+ * Copyright (C) Luc Devroye
+ * Copyright (C) Pierre Lecuyer
+ * 
  *  PURPOSE
  *     uniform random number generator developed by Pierre 
  *     Lecuyer based on a clever and tested combination of 
 #include "others_generators.h"
 
 /* initial default state (seeds) : */
-static long s1 = 1234567890 ;
-static long s2 = 123456789  ;
+static int s1 = 1234567890 ;
+static int s2 = 123456789  ;
 
-unsigned long clcg2()
+unsigned int clcg2()
 {
-  register long k,z;
+    register int k,z;
 
-  /*  s1 = a1*s1 mod m1  (Schrage 's method)  */
-  k= s1 /53668;
-  s1 =40014*(s1%53668)-k*12211;
-  if (s1 < 0) s1 += 2147483563;
+    /*  s1 = a1*s1 mod m1  (Schrage 's method)  */
+    k= s1 /53668;
+    s1 =40014*(s1%53668)-k*12211;
+    if (s1 < 0) s1 += 2147483563;
 
-  /*  s2 = a2*s2 mod m2  (Schrage 's method)  */
-  k=s2/52774;
-  s2=40692*(s2%52774)-k*3791;
-  if (s2 < 0) s2 += 2147483399;
+    /*  s2 = a2*s2 mod m2  (Schrage 's method)  */
+    k=s2/52774;
+    s2=40692*(s2%52774)-k*3791;
+    if (s2 < 0) s2 += 2147483399;
 
-  /* final step : z = s1-s2 mod m1-1  */
-  z = s1 - s2;  /* here z is in [2-m2,m1-2] */
-  if (z < 0) z += 2147483562;
+    /* final step : z = s1-s2 mod m1-1  */
+    z = s1 - s2;  /* here z is in [2-m2,m1-2] */
+    if (z < 0) z += 2147483562;
 
-  /* NOTE : in the  original implementation the final test is :
-   *     if (z < 1) z += 2147483562;
-   * 
-   *   which is not exactly  z = s1-s2 mod (m1 - 1)
-   *
-   *   This is also why it is different from the version used by
-   *   randlib.
-   */
-  
-  return( (unsigned long) z );
+    /* NOTE : in the  original implementation the final test is :
+    *     if (z < 1) z += 2147483562;
+    * 
+    *   which is not exactly  z = s1-s2 mod (m1 - 1)
+    *
+    *   This is also why it is different from the version used by
+    *   randlib.
+    */
+
+    return( (unsigned int) z );
 }
 
 int set_state_clcg2(double g1, double g2)
 {
-  
-  if ( g1 == floor(g1) && g2 == floor(g2)  && 
-       1 <= g1 && g1 <= 2147483562    && 
-       1 <= g2 && g2 <= 2147483398 )
+
+    if ( g1 == floor(g1) && g2 == floor(g2)  && 
+        1 <= g1 && g1 <= 2147483562    && 
+        1 <= g2 && g2 <= 2147483398 )
     {
-      s1 = (long) g1;
-      s2 = (long) g2;
-      return ( 1 );
+        s1 = (int) g1;
+        s2 = (int) g2;
+        return ( 1 );
     }
-  else
+    else
     {
-      sciprint(_("\nBad seeds for clcg2, must be integers with  s1 in [1, 2147483562]\n                                        and  s2 in [1, 2147483398]\n"));
-      return ( 0 );
+        sciprint(_("\nBad seeds for clcg2, must be integers with  s1 in [1, 2147483562]\n                                        and  s2 in [1, 2147483398]\n"));
+        return ( 0 );
     }
 }
 
 void get_state_clcg2(double g[])
 {
-  g[0] = (double) s1;
-  g[1] = (double) s2;
+    g[0] = (double) s1;
+    g[1] = (double) s2;
 }
 
index cbd8d16..66b9fce 100644 (file)
@@ -1,4 +1,10 @@
 /*
+ * 
+ * Copyright (C) 2010 - DIGITEO - Michael Baudin
+ * Copyright (C) 2004 - Bruno Pincon
+ * Copyright (C) 1998 - Terry H. Andres
+ * Copyright (C) 1998 - Pierre Lecuyer
+ * 
  *  PURPOSE
  *     clcg4 generator stuff
  *
 
 #define H   32768               /* = 2^15 : use in MultModM.           */
 
-static long aw[4], avw[4],      /*   a[j]^{2^w} et a[j]^{2^{v+w}}.     */
-            a[4] = { 45991, 207707, 138556, 49689 },
-            m[4] = { 2147483647, 2147483543, 2147483423, 2147483323 };
+static int aw[4], avw[4],      /*   a[j]^{2^w} et a[j]^{2^{v+w}}.     */
+a[4] = { 45991, 207707, 138556, 49689 },
+m[4] = { 2147483647, 2147483543, 2147483423, 2147483323 };
 
-static long Ig[4][Maxgen+1], Lg[4][Maxgen+1], Cg[4][Maxgen+1];
-                     /* Initial seed, previous seed, and current seed. */
+static int Ig[4][Maxgen+1], Lg[4][Maxgen+1], Cg[4][Maxgen+1];
+/* Initial seed, previous seed, and current seed. */
 
 
 static int  is_init = 0;
-static long v_default = 31;
-static long w_default = 41;
+static int v_default = 31;
+static int w_default = 41;
 
 
-static long MultModM (long s, long t, long M)
-   /* Returns (s*t) MOD M.  Assumes that -M < s < M and -M < t < M.    */
-   /* See L'Ecuyer and Cote (1991).                                    */
-  {
-  long R, S0, S1, q, qh, rh, k;
+static int MultModM (int s, int t, int M)
+/* Returns (s*t) MOD M.  Assumes that -M < s < M and -M < t < M.    */
+/* See L'Ecuyer and Cote (1991).                                    */
+{
+    int R, S0, S1, q, qh, rh, k;
 
-  if (s < 0)  s += M;
-  if (t < 0)  t += M;
-  if (s < H)  { S0 = s;  R = 0; }
-  else
+    if (s < 0)  s += M;
+    if (t < 0)  t += M;
+    if (s < H)  { S0 = s;  R = 0; }
+    else
     {
-    S1 = s/H;  S0 = s - H*S1;
-    qh = M/H;  rh = M - H*qh;
-    if (S1 >= H)
-      {
-      S1 -= H;   k = t/qh;   R = H * (t - k*qh) - k*rh;
-      while (R < 0)  R += M;
-      }
-    else R = 0;
-    if (S1 != 0)
-      {
-      q = M/S1;   k = t/q;   R -= k * (M - S1*q);
-      if (R > 0)  R -= M;
-      R += S1*(t - k*q);
-      while (R < 0)  R += M;
-      }
-    k = R/qh;   R = H * (R - k*qh) - k*rh;
-    while (R < 0) R += M;
+        S1 = s/H;  S0 = s - H*S1;
+        qh = M/H;  rh = M - H*qh;
+        if (S1 >= H)
+        {
+            S1 -= H;   k = t/qh;   R = H * (t - k*qh) - k*rh;
+            while (R < 0)  R += M;
+        }
+        else R = 0;
+        if (S1 != 0)
+        {
+            q = M/S1;   k = t/q;   R -= k * (M - S1*q);
+            if (R > 0)  R -= M;
+            R += S1*(t - k*q);
+            while (R < 0)  R += M;
+        }
+        k = R/qh;   R = H * (R - k*qh) - k*rh;
+        while (R < 0) R += M;
     }
-  if (S0 != 0)
+    if (S0 != 0)
     {
-    q = M/S0;   k = t/q;   R -= k* (M - S0*q);
-    if (R > 0)  R -= M;
-    R += S0 * (t - k*q);
-    while (R < 0)  R += M;
+        q = M/S0;   k = t/q;   R -= k* (M - S0*q);
+        if (R > 0)  R -= M;
+        R += S0 * (t - k*q);
+        while (R < 0)  R += M;
     }
-  return R;
-  }
+    return R;
+}
 
-static void comp_aw_and_avw(long v, long w)
+static void comp_aw_and_avw(int v, int w)
 {
-  int i, j;
-  for (j = 0; j < 4; j++)
+    int i, j;
+    for (j = 0; j < 4; j++)
     {
-      aw [j] = a [j];
-      for (i = 1; i <= w; i++)
-       aw [j]  = MultModM (aw [j], aw [j], m[j]);
-      avw [j] = aw [j];
-      for (i = 1; i <= v; i++)
-       avw [j] = MultModM (avw [j], avw [j], m[j]);
+        aw [j] = a [j];
+        for (i = 1; i <= w; i++)
+            aw [j]  = MultModM (aw [j], aw [j], m[j]);
+        avw [j] = aw [j];
+        for (i = 1; i <= v; i++)
+            avw [j] = MultModM (avw [j], avw [j], m[j]);
     }
 }
 
-static void init_clcg4(long v, long w)
+static void init_clcg4(int v, int w)
 {
-  /* currently the scilab interface don't let the user chooses
-   * v and w (always v_default and w_default) so this routine
-   * is in the "private" part (also because initialisation is
-   * always perform inside this module, depending of the var
-   * is_init)
-   */
-  double sd[4] = {11111111., 22222222., 33333333., 44444444.};
-  comp_aw_and_avw(v, w);
-  set_initial_seed_clcg4(sd[0], sd[1], sd[2], sd[3]);
+    /* currently the scilab interface don't let the user chooses
+    * v and w (always v_default and w_default) so this routine
+    * is in the "private" part (also because initialisation is
+    * always perform inside this module, depending of the var
+    * is_init)
+    */
+    double sd[4] = {11111111., 22222222., 33333333., 44444444.};
+    comp_aw_and_avw(v, w);
+    set_initial_seed_clcg4(sd[0], sd[1], sd[2], sd[3]);
 }
 
 static int verif_seeds_clcg4(double s0, double s1, double s2, double s3)
 {
-  /* verify that the seeds are "integers" and are in the good range */
-  if ( s0 == floor(s0) && s1 == floor(s1) &&
-       s2 == floor(s2) && s3 == floor(s3) &&
-       1 <= s0  &&  s0 <= 2147483646      &&
-       1 <= s1  &&  s1 <= 2147483542      &&
-       1 <= s2  &&  s2 <= 2147483422      &&
-       1 <= s3  &&  s3 <= 2147483322 )
-    return ( 1 );
-  else
-    return ( 0 );
+    /* verify that the seeds are "integers" and are in the good range */
+    if ( s0 == floor(s0) && s1 == floor(s1) &&
+        s2 == floor(s2) && s3 == floor(s3) &&
+        1 <= s0  &&  s0 <= 2147483646      &&
+        1 <= s1  &&  s1 <= 2147483542      &&
+        1 <= s2  &&  s2 <= 2147483422      &&
+        1 <= s3  &&  s3 <= 2147483322 )
+        return ( 1 );
+    else
+        return ( 0 );
 }
+
 static void display_info_clcg4()
 {
-  /* display the seeds range (in case of error) */
-  sciprint(_("\n bad seeds for clcg4, must be integers with  s1 in [1, 2147483646]\n                                             s2 in [1, 2147483542]\n                                             s3 in [1, 2147483422]\n                                             s4 in [1, 2147483322]"));
+    /* display the seeds range (in case of error) */
+    sciprint(_("\n bad seeds for clcg4, must be integers with  s1 in [1, 2147483646]\n                                             s2 in [1, 2147483542]\n                                             s3 in [1, 2147483422]\n                                             s4 in [1, 2147483322]"));
 }
 
 
@@ -169,141 +175,127 @@ static void display_info_clcg4()
 
 int set_seed_clcg4(int g, double s0, double s1, double s2, double s3)
 {
-  if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
+    if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
 
-  if ( verif_seeds_clcg4(s0, s1, s2, s3) )
+    if ( verif_seeds_clcg4(s0, s1, s2, s3) )
     {
-      Ig [0][g] = (long) s0; Ig [1][g] = (long) s1;
-      Ig [2][g] = (long) s2; Ig [3][g] = (long) s3;
-      init_generator_clcg4(g, InitialSeed);
-      sciprint(_("\n=> be aware that you have may lost synchronization\n    between the virtual gen %d and the others !\n    use grand(\"setall\", s1, s2, s3, s4) if you want recover it."), g);
-      return ( 1 );
+        Ig [0][g] = (int) s0; Ig [1][g] = (int) s1;
+        Ig [2][g] = (int) s2; Ig [3][g] = (int) s3;
+        init_generator_clcg4(g, InitialSeed);
+        sciprint(_("\n=> be aware that you have may lost synchronization\n    between the virtual gen %d and the others !\n    use grand(\"setall\", s1, s2, s3, s4) if you want recover it."), g);
+        return ( 1 );
     }
-  else
+    else
     {
-      display_info_clcg4();
-      return ( 0 );
+        display_info_clcg4();
+        return ( 0 );
     }
 }
 
 void get_state_clcg4(int g, double s[4])
 {
-  int j;
-  if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
-  for (j = 0; j < 4; j++)  s [j] = (double) Cg [j][g];
+    int j;
+    if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
+    for (j = 0; j < 4; j++)  s [j] = (double) Cg [j][g];
 }
 
 void init_generator_clcg4(int g, SeedType Where)
 {
-  int j;
-  if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
-  for (j = 0; j < 4; j++)
+    int j;
+    if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
+    for (j = 0; j < 4; j++)
     {
-      switch (Where)
-       {
-       case InitialSeed :
-         Lg [j][g] = Ig [j][g];   break;
-       case NewSeed :
-         Lg [j][g] = MultModM (aw [j], Lg [j][g], m [j]);   break;
-       case LastSeed :
-         break;
-       }
-      Cg [j][g] = Lg [j][g];
+        switch (Where)
+        {
+        case InitialSeed :
+            Lg [j][g] = Ig [j][g];   break;
+        case NewSeed :
+            Lg [j][g] = MultModM (aw [j], Lg [j][g], m [j]);   break;
+        case LastSeed :
+            break;
+        }
+        Cg [j][g] = Lg [j][g];
     }
 }
 
 void advance_state_clcg4(int g, int k)
 {
-  long int b[4];
-  int i, j;
+    int b[4];
+    int i, j;
 
-  if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
+    if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
 
-  for ( j = 0 ; j < 4 ; j++ )
+    for ( j = 0 ; j < 4 ; j++ )
     {
-      b[j] = a[j];
-      for ( i = 1 ; i <= k ; i++ )
-       b[j] = MultModM( b[j], b[j], m[j]);
-      Ig[j][g] = MultModM ( b[j], Cg[j][g], m[j] );
+        b[j] = a[j];
+        for ( i = 1 ; i <= k ; i++ )
+            b[j] = MultModM( b[j], b[j], m[j]);
+        Ig[j][g] = MultModM ( b[j], Cg[j][g], m[j] );
     }
-  init_generator_clcg4(g, InitialSeed);
+    init_generator_clcg4(g, InitialSeed);
 }
-  
+
 int set_initial_seed_clcg4(double s0, double s1, double s2, double s3)
 {
-  int g, j;
+    int g, j;
 
-  if (! is_init )  comp_aw_and_avw(v_default,w_default);
+    if (! is_init )  comp_aw_and_avw(v_default,w_default);
 
-  if ( ! verif_seeds_clcg4(s0, s1, s2, s3) )
+    if ( ! verif_seeds_clcg4(s0, s1, s2, s3) )
     {
-      display_info_clcg4();
-      return ( 0 );
+        display_info_clcg4();
+        return ( 0 );
     };
 
-  is_init = 1;
-  Ig [0][0] = (long) s0;
-  Ig [1][0] = (long) s1;
-  Ig [2][0] = (long) s2;
-  Ig [3][0] = (long) s3;
-  init_generator_clcg4(0, InitialSeed);
-  for (g = 1; g <= Maxgen; g++)
+    is_init = 1;
+    Ig [0][0] = (int) s0;
+    Ig [1][0] = (int) s1;
+    Ig [2][0] = (int) s2;
+    Ig [3][0] = (int) s3;
+    init_generator_clcg4(0, InitialSeed);
+    for (g = 1; g <= Maxgen; g++)
     {
-      for (j = 0; j < 4; j++)
-       Ig [j][g] = MultModM (avw [j], Ig [j][g-1], m [j]);
-      init_generator_clcg4(g, InitialSeed);
+        for (j = 0; j < 4; j++)
+            Ig [j][g] = MultModM (avw [j], Ig [j][g-1], m [j]);
+        init_generator_clcg4(g, InitialSeed);
     }
-  return ( 1 );
+    return ( 1 );
 }
 
-unsigned long clcg4(int g)
+unsigned int clcg4(int g)
 {
-  /* Modif Bruno : the generator have now the form (1) in place of (2) */
-
-  long k,s;
-  double u;
-
-  if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
-
-  /*  advance the 4 LCG */
-  s = Cg [0][g];  k = s / 46693;
-  s = 45991 * (s - k * 46693) - k * 25884;
-  if (s < 0) s = s + 2147483647;  Cg [0][g] = s;
-  s = Cg [1][g];  k = s / 10339;
-  s = 207707 * (s - k * 10339) - k * 870;
-  if (s < 0) s = s + 2147483543;  Cg [1][g] = s;
-
-  s = Cg [2][g];  k = s / 15499;
-  s = 138556 * (s - k * 15499) - k * 3979;
-  if (s < 0) s = s + 2147483423;  Cg [2][g] = s;
-
-  s = Cg [3][g];  k = s / 43218;
-  s = 49689 * (s - k * 43218) - k * 24121;
-  if (s < 0) s = s + 2147483323;  Cg [3][g] = s;
-
-  /*  final step */
-  u = (double)(Cg[0][g] - Cg[1][g]) + (double)(Cg[2][g] - Cg[3][g]);
-  /*  we must do  u mod 2147483647 with u in [- 4294966863 ; 4294967066 ] : */
-  if (u < 0) u += 2147483647;
-  if (u < 0) u += 2147483647;
-  if (u >= 2147483647) u -= 2147483647;
-  if (u >= 2147483647) u -= 2147483647;
-
-  return ((unsigned long) u );
-
-}
-
-
-
-
-
+    /* Modif Bruno : the generator have now the form (1) in place of (2) */
 
+    int k,s;
+    double u;
 
+    if (! is_init ) {init_clcg4(v_default,w_default); is_init = 1; };
 
+    /*  advance the 4 LCG */
+    s = Cg [0][g];  k = s / 46693;
+    s = 45991 * (s - k * 46693) - k * 25884;
+    if (s < 0) s = s + 2147483647;  Cg [0][g] = s;
 
+    s = Cg [1][g];  k = s / 10339;
+    s = 207707 * (s - k * 10339) - k * 870;
+    if (s < 0) s = s + 2147483543;  Cg [1][g] = s;
 
+    s = Cg [2][g];  k = s / 15499;
+    s = 138556 * (s - k * 15499) - k * 3979;
+    if (s < 0) s = s + 2147483423;  Cg [2][g] = s;
 
+    s = Cg [3][g];  k = s / 43218;
+    s = 49689 * (s - k * 43218) - k * 24121;
+    if (s < 0) s = s + 2147483323;  Cg [3][g] = s;
 
+    /*  final step */
+    u = (double)(Cg[0][g] - Cg[1][g]) + (double)(Cg[2][g] - Cg[3][g]);
+    /*  we must do  u mod 2147483647 with u in [- 4294966863 ; 4294967066 ] : */
+    if (u < 0) u += 2147483647;
+    if (u < 0) u += 2147483647;
+    if (u >= 2147483647) u -= 2147483647;
+    if (u >= 2147483647) u -= 2147483647;
 
+    return ((unsigned int) u );
 
+}
index 9f4ee42..02b0460 100644 (file)
@@ -1,4 +1,10 @@
 /* 
+ * 
+ * Copyright (C) 2010 - DIGITEO - Michael Baudin
+ * Copyright (C) 2004 - Bruno Pincon
+ * Copyright (C) 1992 - Arif Zaman
+ * Copyright (C) 1992 - George Marsaglia
+ * 
 FSU - ULTRA    The greatest random number generator that ever was
                or ever will be.  Way beyond Super-Duper.
                (Just kidding, but we think its a good one.)
@@ -67,14 +73,14 @@ See Also:   README          for a brief description
 #define N2 24           /* The shorter lag      */
 
 static int is_init=0;  
-static long swb_state[N];          /* state of the swb generator */
+static int swb_state[N];          /* state of the swb generator */
 static int swb_index=N;            /* an index on the swb state */
 static int swb_flag;              /* the carry flag for the SWB generator */
-static unsigned long cong_state;   /* state of the congruential generator */
+static unsigned int cong_state;   /* state of the congruential generator */
 
 /* for this generator the state seems completly defined by:
-      swb_state, swb_index, swb_flag (which define the state of the swb generator)
-      cong_state (which defines the state of the congruential generator)
+swb_state, swb_index, swb_flag (which define the state of the swb generator)
+cong_state (which defines the state of the congruential generator)
 */
 
 /* those are the default for the simple initialisation routine */
@@ -84,150 +90,150 @@ static  double DEFAULT_SEED1= 1234567.0, DEFAULT_SEED2=7654321.0;
 
 
 /* SWB is the subtract-with-borrow operation which should be one line
-   in assembler code. This should be done by using the hardware s-w-b
-   operation in the SWBfill routine (renamed advance_state_swb here).
+in assembler code. This should be done by using the hardware s-w-b
+operation in the SWBfill routine (renamed advance_state_swb here).
 
-   What has been done here is to look at the msb of x, y and z=x-y-c.
-   Using these three bits, one can determine if a borrow bit is needed
-   or not according to the following table:
+What has been done here is to look at the msb of x, y and z=x-y-c.
+Using these three bits, one can determine if a borrow bit is needed
+or not according to the following table:
 
-       msbz=0  msby=0  msby=1          msbz=1  msby=0  msby=1
+msbz=0  msby=0  msby=1          msbz=1  msby=0  msby=1
 
-       msbx=0  0       1               msbx=0  1       1
-       msbx=1  0       0               msbx=1  0       1
+msbx=0  0       1               msbx=0  1       1
+msbx=1  0       0               msbx=1  0       1
 
-   PS: note that the definition is very carefully written because the
-   calls to SWB have y and z as the same memory location, so y must
-   be tested before z is assigned a value.
+PS: note that the definition is very carefully written because the
+calls to SWB have y and z as the same memory location, so y must
+be tested before z is assigned a value.
 */
 #define SWB(c,x,y,z) c = (y<0) ? (((z=x-y-c) < 0) || (x>=0)) : (((z=x-y-c) < 0) && (x>=0));
 
 static void advance_state_swb()
 { 
-  int i;
-  /*
-   *  The following are the heart of the system and should be
-   *  written is assembler to be as fast as possible. It may even make sense
-   *  to unravel the loop and simply wirte 37 consecutive SWB operations!
-   */
-  for (i=0;  i<N2; i++) 
-    SWB(swb_flag,swb_state[i+N-N2],swb_state[i],swb_state[i]);
-  for (i=N2; i<N;  i++) 
-    SWB(swb_flag,swb_state[i  -N2],swb_state[i],swb_state[i]);
-  swb_index = 0;
+    int i;
+    /*
+    *  The following are the heart of the system and should be
+    *  written is assembler to be as fast as possible. It may even make sense
+    *  to unravel the loop and simply wirte 37 consecutive SWB operations!
+    */
+    for (i=0;  i<N2; i++) 
+        SWB(swb_flag,swb_state[i+N-N2],swb_state[i],swb_state[i]);
+    for (i=N2; i<N;  i++) 
+        SWB(swb_flag,swb_state[i  -N2],swb_state[i],swb_state[i]);
+    swb_index = 0;
 }
 
 /* set_state_fsultra_simple initializes the state from 2 integers  
-   
-   it defines the constants and fills the swb_state array one bit at
-   a time by taking the leading bit of the xor of a shift register
-   and a congruential sequence. The same congruential generator continues
-   to be used as a mixing generator for the Subtract-with-borrow generator
-   to produce the `ultra' random numbers
-
-   Since this is called just once, speed doesn't matter much and it might
-   be fine to leave this subroutine coded just as it is.
-
-   PS: there are quick and easy ways to fill this, but since random number
-       generators are really "randomness amplifiers", it is important to
-       start off on the right foot. This is why we take such care here.
+
+it defines the constants and fills the swb_state array one bit at
+a time by taking the leading bit of the xor of a shift register
+and a congruential sequence. The same congruential generator continues
+to be used as a mixing generator for the Subtract-with-borrow generator
+to produce the `ultra' random numbers
+
+Since this is called just once, speed doesn't matter much and it might
+be fine to leave this subroutine coded just as it is.
+
+PS:    there are quick and easy ways to fill this, but since random number
+generators are really "randomness amplifiers", it is important to
+start off on the right foot. This is why we take such care here.
 */
 
 int set_state_fsultra_simple(double s1, double s2)
 { 
-  unsigned long shrgx, tidbits=0;
-  int i, j;
+    unsigned int shrgx, tidbits=0;
+    int i, j;
 
-  if (    (s1 == floor(s1) && 0.0 <= s1 && s1 <= 4294967295.0)
-       && (s2 == floor(s2) && 0.0 <= s2 && s2 <= 4294967295.0) )
+    if (    (s1 == floor(s1) && 0.0 <= s1 && s1 <= 4294967295.0)
+        && (s2 == floor(s2) && 0.0 <= s2 && s2 <= 4294967295.0) )
     {
-      cong_state = ((unsigned long) s1)*2 + 1;
-      shrgx = (unsigned long) s2;
-      for ( i=0 ; i<N ; i++)
-       {
-         for ( j=32 ; j>0 ; j--)
-           { 
-             cong_state = cong_state * 69069;
-             shrgx = shrgx ^ (shrgx >> 15);
-             shrgx = shrgx ^ (shrgx << 17);
-             tidbits = (tidbits>>1) | (0x80000000 & (cong_state^shrgx));
-           }
-         swb_state[i] = tidbits;
-       }
-      swb_index = 0;
-      swb_flag = 0;
-      advance_state_swb();  /* pour retrouver la même séquence que ds scilab V3.0 */
-      is_init = 1;
-      return 1;
+        cong_state = ((unsigned int) s1)*2 + 1;
+        shrgx = (unsigned int) s2;
+        for ( i=0 ; i<N ; i++)
+        {
+            for ( j=32 ; j>0 ; j--)
+            { 
+                cong_state = cong_state * 69069;
+                shrgx = shrgx ^ (shrgx >> 15);
+                shrgx = shrgx ^ (shrgx << 17);
+                tidbits = (tidbits>>1) | (0x80000000 & (cong_state^shrgx));
+            }
+            swb_state[i] = tidbits;
+        }
+        swb_index = 0;
+        swb_flag = 0;
+        advance_state_swb();  /* pour retrouver la même séquence que ds scilab V3.0 */
+        is_init = 1;
+        return 1;
     }
-  else
+    else
     {
-      sciprint(_("\nBad seed for fsultra, must be integers in [0, 2^32-1]\n"));
-      return 0;
+        sciprint(_("\nBad seed for fsultra, must be integers in [0, 2^32-1]\n"));
+        return 0;
     }
 }
 
 int set_state_fsultra(double *s)
 { 
-  double try;
-  int i;
+    double try;
+    int i;
 
-  try = s[0];
-  if ( floor(try) != try || try < 0.0  ||  try > (double) N)
+    try = s[0];
+    if ( floor(try) != try || try < 0.0  ||  try > (double) N)
     {
-      sciprint(_("\nThe first component of the fsultra state, must be an int in [0, %d]\n"),N);
-      return 0;
+        sciprint(_("\nThe first component of the fsultra state, must be an int in [0, %d]\n"),N);
+        return 0;
     }
-  swb_index = (int) try;
+    swb_index = (int) try;
 
-  try = s[1];
-  if ( try != 0.0  &&  try != 1.0)
+    try = s[1];
+    if ( try != 0.0  &&  try != 1.0)
     {
-      sciprint(_("\nThe second component of the fsultra state, must be 0 or 1\n"));
-      return 0;
+        sciprint(_("\nThe second component of the fsultra state, must be 0 or 1\n"));
+        return 0;
     }
-  swb_flag = (int) try;
+    swb_flag = (int) try;
 
-  try = s[2];
-  if ( floor(try) != try  ||  try <= 0 ||  try > 4294967295.0 )
+    try = s[2];
+    if ( floor(try) != try  ||  try <= 0 ||  try > 4294967295.0 )
     {
-      sciprint(_("\nThe third component of the fsultra state, must be an int in [1, 2^32-1]\n"));
-      return 0;
+        sciprint(_("\nThe third component of the fsultra state, must be an int in [1, 2^32-1]\n"));
+        return 0;
     }
-  cong_state = (unsigned long) try;
-  /* no verif here ... */
-  for (i = 0 ; i < N ; i++) 
-    swb_state[i] = (long) (((unsigned long) s[i+3]) & 0xffffffff);
-
-  is_init = 1;
-  return 1;
+    cong_state = (unsigned int) try;
+
+    /* no verif here ... */
+    for (i = 0 ; i < N ; i++) 
+        swb_state[i] = (int) (((unsigned int) s[i+3]) & 0xffffffff);
+
+    is_init = 1;
+    return 1;
 }
 
 
 /*  to return the state at the scilab level  */
 void get_state_fsultra(double s[])
 {
-  int i;
+    int i;
 
-  if ( ! is_init )
-    set_state_fsultra_simple(DEFAULT_SEED1, DEFAULT_SEED2);
+    if ( ! is_init )
+        set_state_fsultra_simple(DEFAULT_SEED1, DEFAULT_SEED2);
 
-  s[0] = (double)  swb_index;
-  s[1] = (double)  swb_flag;
-  s[2] = (double)  cong_state;
-  for (i = 0 ; i < N ; i++) 
-    s[i+3] = (double) (unsigned long) swb_state[i];
+    s[0] = (double)  swb_index;
+    s[1] = (double)  swb_flag;
+    s[2] = (double)  cong_state;
+    for (i = 0 ; i < N ; i++) 
+        s[i+3] = (double) (unsigned int) swb_state[i];
 }
 
-unsigned long fsultra()
+unsigned int fsultra()
 {
-  if (swb_index >= N)  /* generate N words at one time */
+    if (swb_index >= N)  /* generate N words at one time */
     { 
-      if ( ! is_init )
-       set_state_fsultra_simple(DEFAULT_SEED1, DEFAULT_SEED2);
-      else
-       advance_state_swb();
+        if ( ! is_init )
+            set_state_fsultra_simple(DEFAULT_SEED1, DEFAULT_SEED2);
+        else
+            advance_state_swb();
     }
-  return (swb_state[swb_index++] ^ (cong_state = cong_state * 69069));
+    return (swb_state[swb_index++] ^ (cong_state = cong_state * 69069));
 }
index e6ee749..817fb7b 100644 (file)
@@ -1,4 +1,9 @@
 /* 
+ * 
+ * Copyright (C) 2010 - DIGITEO - Michael Baudin
+ * Copyright (C) 2004 - Bruno Pincon
+ * Copyright (C) 1999 - G. Marsaglia
+ * 
  *   PURPOSE
  *      the kiss generator of G. Marsaglia
  *      generate random integers (uint) in [0, 2^32 - 1]
  *      they  are not interfaced at the scilab level.
  *
  *      Need that it is assumed that the 
- *         unsigned long arithmetic is the classic 32 bits 
+ *         unsigned int arithmetic is the classic 32 bits 
  *         unsigned arithmetic modulo 2^32 (ie all is exact
  *         modulo 2^32) 
  *
  *     License: This code is released under public domain.
  *     (Compatible with CeCILL)
-
  */
 #include <math.h>             /* to use floor    */
 
 #define KISS  ((MWC^CONG)+SHR3)
 
 /*  the kiss 's state  (any int in [0,2^32-1] are OK ?) */
-static unsigned long z=362436069, w=521288629, jsr=123456789, jcong=380116160;
+static unsigned int z=362436069, w=521288629, jsr=123456789, jcong=380116160;
 
-unsigned long kiss()
+unsigned int kiss()
 {
-  return ( KISS );
+    return ( KISS );
 }
 
 int set_state_kiss(double g1, double g2, double g3, double g4)
 {
-  if (g1 == floor(g1) && g2 == floor(g2) && 
-      g3 == floor(g3) && g4 == floor(g4) &&  
-      0.0 <= g1 && g1 <= 4294967295.0 &&
-      0.0 <= g2 && g2 <= 4294967295.0 &&
-      0.0 <= g3 && g3 <= 4294967295.0 &&
-      0.0 <= g4 && g4 <= 4294967295.0 )
+    if (g1 == floor(g1) && g2 == floor(g2) && 
+        g3 == floor(g3) && g4 == floor(g4) &&  
+        0.0 <= g1 && g1 <= 4294967295.0 &&
+        0.0 <= g2 && g2 <= 4294967295.0 &&
+        0.0 <= g3 && g3 <= 4294967295.0 &&
+        0.0 <= g4 && g4 <= 4294967295.0 )
     {
-          z = (unsigned long) g1;
-          w = (unsigned long) g2;
-        jsr = (unsigned long) g3;
-      jcong = (unsigned long) g4;
-      return ( 1 );
+        z = (unsigned int) g1;
+        w = (unsigned int) g2;
+        jsr = (unsigned int) g3;
+        jcong = (unsigned int) g4;
+        return ( 1 );
     }
-  else
+    else
     {
-      sciprint(_("Bad seeds for kiss, must be integers in [0,2^32-1]\n"));
-      return ( 0 );
+        sciprint(_("Bad seeds for kiss, must be integers in [0,2^32-1]\n"));
+        return ( 0 );
     }
 }
 
 void get_state_kiss(double g[])
 {
-  g[0] = (double) z;
-  g[1] = (double) w;
-  g[2] = (double) jsr;
-  g[3] = (double) jcong;
+    g[0] = (double) z;
+    g[1] = (double) w;
+    g[2] = (double) jsr;
+    g[3] = (double) jcong;
 }
 
index 09c9f2a..8e932a2 100644 (file)
@@ -1,4 +1,12 @@
-/* A C-program for MT19937: Integer version (1999/10/28)          */
+/*
+ * 
+ * Copyright (C) 2010 - DIGITEO - Michael Baudin
+ * Copyright (C) 2005 - Bruno Pincon
+ * Copyright (C) 2002 - Bruno Pincon
+ * Copyright (C) 1997, 1999 - Makoto Matsumoto and Takuji Nishimura
+ * 
+ A C-program for MT19937: Integer version (1999/10/28)          
+*/
 /*  genrand() generates one pseudorandom unsigned int (32bit) */
 /* which is uniformly distributed among 0 to 2^32-1  for each     */
 /* call. sgenrand(seed) sets initial values to the working area   */
@@ -12,7 +20,6 @@
 /* For the verification of the code, its output sequence file      */
 /* mt19937int.out is attached (2001/4/2)                           */
 
-/* Copyright (C) 1997, 1999 Makoto Matsumoto and Takuji Nishimura. */
 /* Any feedback is very welcome. For any question, comments,       */
 /* see http://www.math.keio.ac.jp/matumoto/emt.html or email       */
 /* matumoto@math.keio.ac.jp                                        */
 #define TEMPERING_SHIFT_T(y)  (y << 15)
 #define TEMPERING_SHIFT_L(y)  (y >> 18)
 
-static unsigned long mt[N]; /* the array for the state vector  */
+static unsigned int mt[N]; /* the array for the state vector  */
 static int mti=N;
 static int is_init=0;  
 static double DEFAULT_SEED=5489.0;
 
-unsigned long randmt()
+unsigned int randmt()
 {
-    unsigned long y;
-    static unsigned long mag01[2]={0x0, MATRIX_A};
+    unsigned int y;
+    static unsigned int mag01[2]={0x0, MATRIX_A};
     /* mag01[x] = x * MATRIX_A  for x=0,1 */
 
     if (mti >= N) { /* generate N words at one time */
         int kk;
 
-       if ( ! is_init )
-         set_state_mt_simple(DEFAULT_SEED);
+        if ( ! is_init )
+            set_state_mt_simple(DEFAULT_SEED);
 
         for (kk=0;kk<N-M;kk++) {
             y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
@@ -101,7 +108,7 @@ unsigned long randmt()
 
         mti = 0;
     }
-  
+
     y = mt[mti++];
     y ^= TEMPERING_SHIFT_U(y);
     y ^= TEMPERING_SHIFT_S(y) & TEMPERING_MASK_B;
@@ -114,45 +121,45 @@ unsigned long randmt()
 
 int set_state_mt_simple(double s)
 {
-  /*   set the initial state with the simple procedure  */
-  unsigned long seed;
+    /*   set the initial state with the simple procedure  */
+    unsigned int seed;
 
-  if ( s == floor(s) && 0.0 <= s && s <= 4294967295.0)
+    if ( s == floor(s) && 0.0 <= s && s <= 4294967295.0)
     {
-      seed = (unsigned long) s;
-       mt[0]= seed & 0xffffffff;
-      for (mti=1; mti<N; mti++)
-       {
-         mt[mti] =  (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti); 
-         /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
-         /* In the previous versions, MSBs of the seed affect   */
-         /* only MSBs of the array mt[].                        */
-         /* 2002/01/09 modified by Makoto Matsumoto             */
-         mt[mti] &= 0xffffffffUL;   /* for >32 bit machines */
-       }
-      is_init = 1;
-      return ( 1 );
+        seed = (unsigned int) s;
+        mt[0]= seed & 0xffffffff;
+        for (mti=1; mti<N; mti++)
+        {
+            mt[mti] =  (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti); 
+            /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+            /* In the previous versions, MSBs of the seed affect   */
+            /* only MSBs of the array mt[].                        */
+            /* 2002/01/09 modified by Makoto Matsumoto             */
+            mt[mti] &= 0xffffffffUL;   /* for >32 bit machines */
+        }
+        is_init = 1;
+        return ( 1 );
     }
-  else
+    else
     {
-      sciprint(_("Bad seed for mt, must be an int in [0, 2^32-1]\n"));
-      return ( 0 );
+        sciprint(_("Bad seed for mt, must be an int in [0, 2^32-1]\n"));
+        return ( 0 );
     }
 }
 
 
 /* 
- *  Initialization by "set_state_simple_mt()" is an example. Theoretically,
- *  there are 2^19937-1 possible states as an intial state.           
- *   This function allows to choose any of 2^19937-1 ones.            
- *   Essential bits in "seed_array[]" is following 19937 bits:        
- *      (seed_array[0]&UPPER_MASK), seed_array[1], ..., seed_array[N-1].
- *      (seed_array[0]&LOWER_MASK) is discarded.                         
- *
- *   Theoretically,                                                   
- *      (seed_array[0]&UPPER_MASK), seed_array[1], ..., seed_array[N-1] 
- *   can take any values except all zeros.                            
- */
+*  Initialization by "set_state_simple_mt()" is an example. Theoretically,
+*  there are 2^19937-1 possible states as an intial state.           
+*   This function allows to choose any of 2^19937-1 ones.            
+*   Essential bits in "seed_array[]" is following 19937 bits:        
+*      (seed_array[0]&UPPER_MASK), seed_array[1], ..., seed_array[N-1].
+*      (seed_array[0]&LOWER_MASK) is discarded.                         
+*
+*   Theoretically,                                                   
+*      (seed_array[0]&UPPER_MASK), seed_array[1], ..., seed_array[N-1] 
+*   can take any values except all zeros.                            
+*/
 
 int set_state_mt(double seed_array[])
 
@@ -161,14 +168,14 @@ int set_state_mt(double seed_array[])
 
     mti_try = (int) seed_array[0];
     if (mti_try < 1  ||  mti_try > 624)
-      {
-       sciprint(_("The first component of the mt state mt, must be an int in [1, 624]\n"));
-       return ( 0 );
-      }
+    {
+        sciprint(_("The first component of the mt state mt, must be an int in [1, 624]\n"));
+        return ( 0 );
+    }
     is_init = 1;
     mti = mti_try;
     for (i=0;i<N;i++) 
-      mt[i] = ((unsigned long) seed_array[i+1]) & 0xffffffff;
+        mt[i] = ((unsigned int) seed_array[i+1]) & 0xffffffff;
     return ( 1 );
 }
 
@@ -179,19 +186,9 @@ void get_state_mt(double state[])
     int i;
 
     if ( ! is_init )
-      set_state_mt_simple(DEFAULT_SEED);
-    
+        set_state_mt_simple(DEFAULT_SEED);
+
     state[0] = (double) mti;
     for (i=0;i<N;i++) 
-      state[i+1] = (double) mt[i];
+        state[i+1] = (double) mt[i];
 }
-
-
-
-
-
-
-
-
-
-
index 1821724..05c5b79 100644 (file)
@@ -1,4 +1,10 @@
 /* 
+ *
+ * Copyright (C) 2010 - DIGITEO - Michael Baudin
+ * Copyright (C) 2004 - Bruno Pincon
+ * Copyright (C) 1973 - CLEVE B. MOLER
+ * Copyright (C) 1973 - MICHAEL A. MALCOLM
+ *
  *   PURPOSE
  *      the basic rand generator of Scilab : s <- (a*s + c) mod m
  *      with :
  *   NOTES
  *      a/ Rewritten (in C) so as to output integers like all the others 
  *         generators (and also to have the same manner to set/get the state)
- *      b/ unsigned long int arithmetic must be the classic 32 bits unsigned
+ *      b/ unsigned int arithmetic must be the classic 32 bits unsigned
  *         arithmetic (ie also is exact modulo 2^32).
  * 
+ *   URAND, A UNIVERSAL RANDOM NUMBER GENERATOR 
+ *   BY, MICHAEL A. MALCOLM, CLEVE B. MOLER, 
+ *   STAN-CS-73-334, JANUARY 1973, 
+ *   COMPUTER SCIENCE  DEPARTMENT, 
+ *   School of Humanities and Sciences, STANFORD UNIVERSITY, 
+ *   ftp://reports.stanford.edu/pub/cstr/reports/cs/tr/73/334/CS-TR-73-334.pdf
+ * 
+ * 
  */
 
 
 #include "others_generators.h"
 #include "localization.h"
 
-static unsigned long s = 0;
+static unsigned int s = 0;
 
-unsigned long urandc()
+unsigned int urandc()
 {
-  s = 843314861ul * s + 453816693ul;  /* => on obtient ici un resultat modulo 2^32 */
+    s = 843314861ul * s + 453816693ul;  /* => on obtient ici un resultat modulo 2^32 */
 
-  /* il suffit du test suivant pour obtenir le modulo 2^31 */
-  if (s >= 2147483648ul) s -= 2147483648ul;
+    /* il suffit du test suivant pour obtenir le modulo 2^31 */
+    if (s >= 2147483648ul) s -= 2147483648ul;
 
-  return ( s );
+    return ( s );
 }
 
 int set_state_urand(double g)
 {
-  if ( g == floor(g) &&  0 <= g && g <= 2147483647 )
+    if ( g == floor(g) &&  0 <= g && g <= 2147483647 )
     {
-      s = (unsigned long) g;
-      return ( 1 );
+        s = (unsigned int) g;
+        return ( 1 );
     }
-  else
+    else
     {
-      sciprint(_("\nBad seed for urand, must be an int in [0,  2147483647]\n"));
-      return ( 0 );
+        sciprint(_("\nBad seed for urand, must be an int in [0,  2147483647]\n"));
+        return ( 0 );
     }
 }
 
 void get_state_urand(double g[])
 {
-  g[0] = (double) s;
+    g[0] = (double) s;
 }
-
-
-  
diff --git a/scilab/modules/randlib/tests/unit_tests/Rand.dia.ref b/scilab/modules/randlib/tests/unit_tests/Rand.dia.ref
deleted file mode 100644 (file)
index bfd49bd..0000000
+++ /dev/null
@@ -1,165 +0,0 @@
-// =============================================================================
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) ????-2008 - INRIA
-//
-//  This file is distributed under the same license as the Scilab package.
-// =============================================================================
-// tests for randlib
-// for "continuous law"
-generators = ["mt" "kiss" "clcg2" "clcg4" "urand"];
-// test for beta random deviate
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'bet',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfbet("PQ",RdevS,1-RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for f
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'f',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdff("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for mul
-// test for gamma
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'gam',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfgam("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for nor
-N=10000;A=1;B=2;
-Rdev=grand(1,N,'nor',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfnor("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for unf
-N=10000;A=1;B=2;
-Rdev=grand(1,N,'unf',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for uin ( a finir )
-N=10000;A=1;B=10;
-Rdev=grand(1,N,'uin',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for lgi
-N=10000;
-Rdev=grand(1,N,'lgi');
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test fo perm
-N=1000;
-Mat=grand(N,'prm',[1:10]');
-if sum([1:10]')/10 - sum(Mat,'c')/N > 0 then bugmes();quit;end
-// test for nbn
-N=10000;A=5;B=0.7;
-Rdev=grand(1,N,'nbn',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfnbn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for bin
-N=10000;A=5;B=0.7;
-Rdev=grand(1,N,'bin',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfbin("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for mn
-// test for 'def'
-N=10000;
-Rdev=grand(1,N,'def');
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=RdevS;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for nch or chn
-N=10000;A=5;B=4;
-Rdev=grand(1,N,'nch',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfchn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for nf or fnc
-N=10000;A=5;B=4;C=10;
-Rdev=grand(1,N,'nf',A,B,C);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdffnc("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),C*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for chi
-N=10000;A=5;
-Rdev=grand(1,N,'chi',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfchi("PQ",RdevS,A*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for poi
-N=10000;A=50;
-Rdev=grand(1,N,'poi',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfpoi("PQ",RdevS,A*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
-// test for exp
-N=10000;A=2;
-Rdev=grand(1,N,'exp',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-P=1-exp(-RdevS/A);
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then bugmes();quit;end
diff --git a/scilab/modules/randlib/tests/unit_tests/Rand.tst b/scilab/modules/randlib/tests/unit_tests/Rand.tst
deleted file mode 100644 (file)
index 02207b4..0000000
+++ /dev/null
@@ -1,207 +0,0 @@
-// =============================================================================
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) ????-2008 - INRIA
-//
-//  This file is distributed under the same license as the Scilab package.
-// =============================================================================
-
-// tests for randlib
-
-// for "continuous law"
-
-generators = ["mt" "kiss" "clcg2" "clcg4" "urand"];
-
-// test for beta random deviate 
-
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'bet',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfbet("PQ",RdevS,1-RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for f 
-
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'f',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdff("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for mul
-
-// test for gamma 
-
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'gam',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfgam("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for nor 
-
-N=10000;A=1;B=2;
-Rdev=grand(1,N,'nor',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfnor("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for unf 
-
-N=10000;A=1;B=2;
-Rdev=grand(1,N,'unf',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for uin ( a finir ) 
-
-N=10000;A=1;B=10;
-Rdev=grand(1,N,'uin',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for lgi 
-
-N=10000;
-Rdev=grand(1,N,'lgi');
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-
-// test fo perm 
-
-N=1000;
-Mat=grand(N,'prm',[1:10]');
-if sum([1:10]')/10 - sum(Mat,'c')/N > 0 then pause;end 
-
-// test for nbn 
-
-N=10000;A=5;B=0.7;
-Rdev=grand(1,N,'nbn',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfnbn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-
-// test for bin 
-
-N=10000;A=5;B=0.7;
-Rdev=grand(1,N,'bin',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfbin("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for mn 
-
-// test for 'def'
-
-N=10000;
-Rdev=grand(1,N,'def');
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=RdevS;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for nch or chn 
-
-N=10000;A=5;B=4;
-Rdev=grand(1,N,'nch',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfchn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for nf or fnc
-
-N=10000;A=5;B=4;C=10;
-Rdev=grand(1,N,'nf',A,B,C); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdffnc("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),C*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for chi 
-
-N=10000;A=5;
-Rdev=grand(1,N,'chi',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfchi("PQ",RdevS,A*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-// test for poi 
-
-N=10000;A=50;
-Rdev=grand(1,N,'poi',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfpoi("PQ",RdevS,A*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
-
-// test for exp 
-
-N=10000;A=2;
-Rdev=grand(1,N,'exp',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-P=1-exp(-RdevS/A);
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS,"inf") < %eps then pause,end
-
diff --git a/scilab/modules/randlib/tests/unit_tests/grand.dia.ref b/scilab/modules/randlib/tests/unit_tests/grand.dia.ref
deleted file mode 100644 (file)
index c2d483e..0000000
+++ /dev/null
@@ -1,363 +0,0 @@
-// =============================================================================
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) ????-2008 - INRIA
-//
-//  This file is distributed under the same license as the Scilab package.
-// =============================================================================
-// <-- TEST WITH GRAPHIC -->
-//---------------------Tests added by Sabine Gaüzère----------------------------
-//Same tests as below but with loops in order to have more examples.
-// test for grand
-prec = 1
- prec  =
-    1.  
-// test for exp
-for i=0.1:0.1:50,
-  N=10000;A=i;
-  Rdev=grand(1,N,'exp',A);
-  RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-  PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-  P=1-exp(-RdevS/A);
-//plot2d(RdevS,P,2,"000")
-  if norm(P-PS) > prec then bugmes();quit;end
-end
-// test for gamma
-for i=1:1:15,
-  for j=1:1:15,
-    N=10000;A=i;B=j;
-    Rdev=grand(1,N,'gam',A,B);
-    RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-    PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-    [P]=cdfgam("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-    if norm(P-PS)> prec then bugmes();quit;end
-  end
-end
-// test for beta random deviate
-for i=1:1:20,
-  for j=1:1:20,
-    N=10000;A=i;B=j;
-    Rdev=grand(1,N,'bet',A,B);
-    RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-    PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-    [P]=cdfbet("PQ",RdevS,1-RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-    if norm(P-PS)> prec then bugmes();quit;end
-  end
-end
-// test for poi
-for i=50:1:70,
-  N=10000;A=i;
-  Rdev=grand(1,N,'poi',A);
-  RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-  PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-  [P]=cdfpoi("PQ",RdevS,A*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-// idem need an other test P is piecewize linear and PS
-// linear
-//if norm(P-PS) > prec then bugmes();quit;end
-end
-//Tests to verify the compatibility with a matrix
-N=100;A=1;B=3;
-Rdev=grand(N,N,'bet',A,B);
-Rdev=matrix(Rdev,1,N^2);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:(N^2))'/(N^2);
-[P]=cdfbet("PQ",RdevS,1-RdevS,A*ones(RdevS),B*ones(RdevS));
-if norm(P-PS) > prec then bugmes();quit;end
-N=100;A=1;B=3;
-Rdev=grand(N,N,'gam',A,B);
-Rdev=matrix(Rdev,1,N^2);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:(N^2))'/(N^2);
-[P]=cdfgam("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-if norm(P-PS) > prec then bugmes();quit;end
-N=100;A=5;B=0.7;
-Rdev=grand(N,N,'bin',A,B);
-Rdev=matrix(Rdev,1,N^2);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:(N^2))'/(N^2);
-[P]=cdfbin("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
-//if norm(P-PS) > prec then bugmes();quit;end
-N=100;A=50;
-Rdev=grand(N,N,'poi',A);
-Rdev=matrix(Rdev,1,N^2);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:(N^2))'/(N^2);
-[P]=cdfpoi("PQ",RdevS,A*ones(RdevS));
-//if norm(P-PS) > prec then bugmes();quit;end
-N=100;A=2;
-Rdev=grand(N,N,'exp',A);
-Rdev=matrix(Rdev,1,N^2);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:(N^2))'/(N^2);
-P=1-exp(-RdevS/A);
-if norm(P-PS) > prec then bugmes();quit;end
-//Tests with graphic
-//Comparison of pseudo-random numbers following an exponential distribution
-//and the density of this distribution
-//Parameter of the distribution which can be modified
-lambda=1.6;
-// Number of random variable generated
-N=100000;
-//Generation of a vector of numbers following an exponential distribution
-X = grand(1,N,"exp",lambda);
-clf();
-//Discretisation of the abscisses in classes
-classes = linspace(0,12,25);
-//Draw in histogram
-histplot(classes,X)
-//Draw the density
-x=linspace(0,12,25);
-y = (1/lambda)*exp(-(1/lambda)*x);
-plot2d(x,y,3);
-f=gcf();
-delete(f);
-//Comparison of pseudo-random numbers following a beta distribution
-//and the density of this distribution
-//Parameters of the distribution which can be modified
-A=1;B=3;
-// Number of random variable generated
-N=100000;
-//Generation of a vector of numbers following a beta distribution
-X = grand(1,N,"bet",A,B);
-clf();
-//Discretisation of the abscisses in classes
-classes = linspace(0,1,50);
-//Draw in histogram
-histplot(classes,X)
-//Draw the density
-x=linspace(0,1,50);
-y = (1/(beta(A,B))).*(x^(A-1)).*((1-x)^(B-1)) ;
-plot2d(x,y,2);
-f=gcf();
-delete(f);
-//Comparison of pseudo-random numbers following a gamma distribution
-//and the density of this distribution
-//Parameters of the distribution which can be modified
-A=2;B=1;
-// Number of random variable generated
-N=100000;
-//Generation of a vector of numbers following a gamma distribution
-X = grand(1,N,"gam",A,B);
-clf();
-//Discretisation of the abscisses in classes
-classes = linspace(0,2,50);
-//Draw in histogram
-histplot(classes,X)
-//Draw the density
-x=linspace(0,2,50);
-y = (B/(gamma(A))).*exp(-B*x).*(B*x)^(A-1);
-plot2d(x,y,2);
-f=gcf();
-delete(f);
-//Comparison of pseudo-random numbers following a binomial distribution
-//and the density of this distribution
-//Parameters of the distribution which can be modified
-n=50;p=0.3;
-// Number of random variable generated
-N=100000;
-//Generation of a vector of numbers following a binomial distribution
-X = grand(1,N,"bin",n,p);
-clf();
-//Discretisation of the abscisses in classes
-classes = linspace(0,n,n+1);
-//Draw in histogram
-histplot(classes,X)
-//Draw the density
-x=linspace(0,n,n+1);
-y = binomial(p,n);
-plot2d(x,y,2);
-f=gcf();
-delete(f);
-//Comparison of pseudo-random numbers following a poisson distribution
-//and the density of this distribution
-//Parameters of the distribution which can be modified
-mu=50;
-// Number of random variable generated
-N=100000;
-//Generation of a vector of numbers following a poisson distribution
-X = grand(1,N,"poi",mu);
-clf();
-//Discretisation of the abscisses in classes
-classes = linspace(0,2*mu,101);
-//Draw in histogram
-histplot(classes,X)
-//Draw the density
-[x]=linspace(0,2*mu,101);
-y = exp(-mu).*(mu^x)./factorial(x);
-plot2d(x,y,2);
-f=gcf();
-delete(f);
-//---------------------------------------------------------------------------
-// test for beta random deviate
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'bet',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfbet("PQ",RdevS,1-RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then bugmes();quit;end
-// test for f
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'f',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdff("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then bugmes();quit;end
-// test for mul
-// test for gamma
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'gam',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfgam("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then bugmes();quit;end
-// test for nor
-N=10000;A=1;B=2;
-Rdev=grand(1,N,'nor',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfnor("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then bugmes();quit;end
-// test for unf
-N=10000;A=1;B=2;
-Rdev=grand(1,N,'unf',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then bugmes();quit;end
-// test for uin ( a finir )
-N=10000;A=1;B=10;
-Rdev=grand(1,N,'uin',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-//need an other test XXX
-//if norm(P-PS) > prec then bugmes();quit;end
-// test for lgi
-N=10000;
-Rdev=grand(1,N,'lgi');
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-//XXXX need an other test
-//if norm(P-PS) > prec then bugmes();quit;end
-// test fo perm
-N=1000;
-Mat=grand(N,'prm',[1:10]');
-if sum([1:10]')/10 - sum(Mat,'c')/N > 0 then bugmes();quit;end
-// test for nbn
-N=10000;A=5;B=0.7;
-Rdev=grand(1,N,'nbn',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfnbn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-//XXXX need an other test
-//if norm(P-PS) > prec then bugmes();quit;end
-// test for bin
-N=10000;A=5;B=0.7;
-Rdev=grand(1,N,'bin',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfbin("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-//XXX need to change test
-//if norm(P-PS) > prec then bugmes();quit;end
-// test for mn
-// test for 'def'
-N=10000;
-Rdev=grand(1,N,'def');
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=RdevS;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then bugmes();quit;end
-// test for nch or chn
-N=10000;A=5;B=4;
-Rdev=grand(1,N,'nch',A,B);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfchn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then bugmes();quit;end
-// test for nf or fnc
-N=10000;A=5;B=4;C=10;
-Rdev=grand(1,N,'nf',A,B,C);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdffnc("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),C*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then bugmes();quit;end
-// test for chi
-N=10000;A=5;
-Rdev=grand(1,N,'chi',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfchi("PQ",RdevS,A*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then bugmes();quit;end
-// test for poi
-N=10000;A=50;
-Rdev=grand(1,N,'poi',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-[P]=cdfpoi("PQ",RdevS,A*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-// idem need an other test P is piecewize linear and PS
-// linear
-//if norm(P-PS) > prec then bugmes();quit;end
-// test for exp
-N=10000;A=2;
-Rdev=grand(1,N,'exp',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result
-P=1-exp(-RdevS/A);
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then bugmes();quit;end
diff --git a/scilab/modules/randlib/tests/unit_tests/grand.tst b/scilab/modules/randlib/tests/unit_tests/grand.tst
deleted file mode 100644 (file)
index 36ab678..0000000
+++ /dev/null
@@ -1,424 +0,0 @@
-// =============================================================================
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) ????-2008 - INRIA
-//
-//  This file is distributed under the same license as the Scilab package.
-// =============================================================================
-// <-- TEST WITH GRAPHIC -->
-
-//---------------------Tests added by Sabine Gaüzère----------------------------
-
-
-//Same tests as below but with loops in order to have more examples.
-// test for grand
-prec = 1
-
-// test for exp 
-
-for i=0.1:0.1:50,
-  N=10000;A=i;
-  Rdev=grand(1,N,'exp',A);
-  RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-  PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-  P=1-exp(-RdevS/A);
-//plot2d(RdevS,P,2,"000")
-  if norm(P-PS) > prec then pause,end
-end
-
-
-// test for gamma 
-for i=1:1:15,
-  for j=1:1:15,
-    N=10000;A=i;B=j;
-    Rdev=grand(1,N,'gam',A,B); 
-    RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-    PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-    [P]=cdfgam("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-    if norm(P-PS)> prec then pause,end
-  end
-end
-
-
-// test for beta random deviate 
-for i=1:1:20,
-  for j=1:1:20,
-    N=10000;A=i;B=j;
-    Rdev=grand(1,N,'bet',A,B); 
-    RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-    PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-    [P]=cdfbet("PQ",RdevS,1-RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-    if norm(P-PS)> prec then pause,end
-  end
-end
-
-// test for poi 
-for i=50:1:70,
-  N=10000;A=i;
-  Rdev=grand(1,N,'poi',A);
-  RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-  PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-  [P]=cdfpoi("PQ",RdevS,A*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-// idem need an other test P is piecewize linear and PS 
-// linear 
-//if norm(P-PS) > prec then pause,end
-end
-
-//Tests to verify the compatibility with a matrix
-  
-N=100;A=1;B=3;
-Rdev=grand(N,N,'bet',A,B); 
-Rdev=matrix(Rdev,1,N^2);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:(N^2))'/(N^2);
-[P]=cdfbet("PQ",RdevS,1-RdevS,A*ones(RdevS),B*ones(RdevS));
-if norm(P-PS) > prec then pause,end
-  
-N=100;A=1;B=3;
-Rdev=grand(N,N,'gam',A,B); 
-Rdev=matrix(Rdev,1,N^2);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:(N^2))'/(N^2);
-[P]=cdfgam("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-if norm(P-PS) > prec then pause,end
-  
-N=100;A=5;B=0.7;
-Rdev=grand(N,N,'bin',A,B); 
-Rdev=matrix(Rdev,1,N^2);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:(N^2))'/(N^2);
-[P]=cdfbin("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
-//if norm(P-PS) > prec then pause,end
-
-N=100;A=50;
-Rdev=grand(N,N,'poi',A); 
-Rdev=matrix(Rdev,1,N^2);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:(N^2))'/(N^2);
-[P]=cdfpoi("PQ",RdevS,A*ones(RdevS));
-//if norm(P-PS) > prec then pause,end
-
-N=100;A=2;
-Rdev=grand(N,N,'exp',A); 
-Rdev=matrix(Rdev,1,N^2);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:(N^2))'/(N^2);
-P=1-exp(-RdevS/A);
-if norm(P-PS) > prec then pause,end
-
-//Tests with graphic
-
-//Comparison of pseudo-random numbers following an exponential distribution 
-//and the density of this distribution
-//Parameter of the distribution which can be modified
-lambda=1.6;
-// Number of random variable generated
-N=100000;
-//Generation of a vector of numbers following an exponential distribution
-X = grand(1,N,"exp",lambda);
-clf();
-//Discretisation of the abscisses in classes
-classes = linspace(0,12,25);
-//Draw in histogram
-histplot(classes,X)
-//Draw the density 
-x=linspace(0,12,25);
-y = (1/lambda)*exp(-(1/lambda)*x);
-plot2d(x,y,3);
-f=gcf();
-delete(f);
-
-//Comparison of pseudo-random numbers following a beta distribution 
-//and the density of this distribution
-//Parameters of the distribution which can be modified
-A=1;B=3;
-// Number of random variable generated
-N=100000;
-//Generation of a vector of numbers following a beta distribution
-X = grand(1,N,"bet",A,B);
-clf();
-//Discretisation of the abscisses in classes
-classes = linspace(0,1,50);
-//Draw in histogram
-histplot(classes,X)
-//Draw the density 
-x=linspace(0,1,50);
-y = (1/(beta(A,B))).*(x^(A-1)).*((1-x)^(B-1)) ;
-plot2d(x,y,2);
-f=gcf();
-delete(f);
-
-//Comparison of pseudo-random numbers following a gamma distribution 
-//and the density of this distribution
-//Parameters of the distribution which can be modified
-A=2;B=1;
-// Number of random variable generated
-N=100000;
-//Generation of a vector of numbers following a gamma distribution
-X = grand(1,N,"gam",A,B);
-clf();
-//Discretisation of the abscisses in classes
-classes = linspace(0,2,50);
-//Draw in histogram
-histplot(classes,X)
-//Draw the density 
-x=linspace(0,2,50);
-y = (B/(gamma(A))).*exp(-B*x).*(B*x)^(A-1);
-plot2d(x,y,2);
-f=gcf();
-delete(f);
-
-
-//Comparison of pseudo-random numbers following a binomial distribution 
-//and the density of this distribution
-//Parameters of the distribution which can be modified
-n=50;p=0.3;
-// Number of random variable generated
-N=100000;
-//Generation of a vector of numbers following a binomial distribution
-X = grand(1,N,"bin",n,p);
-clf();
-//Discretisation of the abscisses in classes
-classes = linspace(0,n,n+1);
-//Draw in histogram
-histplot(classes,X)
-//Draw the density
-x=linspace(0,n,n+1);
-y = binomial(p,n);
-plot2d(x,y,2);
-f=gcf();
-delete(f);
-
-//Comparison of pseudo-random numbers following a poisson distribution 
-//and the density of this distribution
-//Parameters of the distribution which can be modified
-mu=50;
-// Number of random variable generated
-N=100000;
-//Generation of a vector of numbers following a poisson distribution
-X = grand(1,N,"poi",mu);
-clf();
-//Discretisation of the abscisses in classes
-classes = linspace(0,2*mu,101);
-//Draw in histogram
-histplot(classes,X)
-//Draw the density
-[x]=linspace(0,2*mu,101);
-y = exp(-mu).*(mu^x)./factorial(x);
-plot2d(x,y,2);
-f=gcf();
-delete(f);
-
-//---------------------------------------------------------------------------
-
-// test for beta random deviate 
-
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'bet',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfbet("PQ",RdevS,1-RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then pause,end
-
-// test for f 
-
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'f',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdff("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then pause,end
-
-// test for mul
-
-// test for gamma 
-
-N=10000;A=1;B=3;
-Rdev=grand(1,N,'gam',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfgam("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then pause,end
-
-// test for nor 
-
-N=10000;A=1;B=2;
-Rdev=grand(1,N,'nor',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfnor("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then pause,end
-
-// test for unf 
-
-N=10000;A=1;B=2;
-Rdev=grand(1,N,'unf',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then pause,end
-
-// test for uin ( a finir ) 
-
-N=10000;A=1;B=10;
-Rdev=grand(1,N,'uin',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-//need an other test XXX
-//if norm(P-PS) > prec then pause,end
-
-// test for lgi 
-
-N=10000;
-Rdev=grand(1,N,'lgi');
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=RdevS-A;
-//plot2d(RdevS,P,2,"000")
-//XXXX need an other test 
-//if norm(P-PS) > prec then pause,end
-
-
-// test fo perm 
-
-N=1000;
-Mat=grand(N,'prm',[1:10]');
-if sum([1:10]')/10 - sum(Mat,'c')/N > 0 then pause;end 
-
-// test for nbn 
-
-N=10000;A=5;B=0.7;
-Rdev=grand(1,N,'nbn',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfnbn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-//XXXX need an other test 
-//if norm(P-PS) > prec then pause,end
-
-
-// test for bin 
-
-N=10000;A=5;B=0.7;
-Rdev=grand(1,N,'bin',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfbin("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-//XXX need to change test 
-//if norm(P-PS) > prec then pause,end
-
-// test for mn 
-
-// test for 'def'
-
-N=10000;
-Rdev=grand(1,N,'def');
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=RdevS;
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then pause,end
-
-// test for nch or chn 
-
-N=10000;A=5;B=4;
-Rdev=grand(1,N,'nch',A,B); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfchn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then pause,end
-
-// test for nf or fnc
-
-N=10000;A=5;B=4;C=10;
-Rdev=grand(1,N,'nf',A,B,C); 
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdffnc("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),C*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then pause,end
-
-// test for chi 
-
-N=10000;A=5;
-Rdev=grand(1,N,'chi',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfchi("PQ",RdevS,A*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then pause,end
-
-// test for poi 
-
-N=10000;A=50;
-Rdev=grand(1,N,'poi',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-[P]=cdfpoi("PQ",RdevS,A*ones(RdevS));
-//plot2d(RdevS,P,2,"000")
-// idem need an other test P is piecewize linear and PS 
-// linear 
-//if norm(P-PS) > prec then pause,end
-
-
-// test for exp 
-
-N=10000;A=2;
-Rdev=grand(1,N,'exp',A);
-RdevS=gsort(Rdev);RdevS=RdevS($:-1:1)';
-PS=(1:N)'/N;
-//plot2d(RdevS,PS);
-// theorical result 
-P=1-exp(-RdevS/A);
-//plot2d(RdevS,P,2,"000")
-if norm(P-PS) > prec then pause,end
-
-
@@ -1,7 +1,11 @@
-// Copyright INRIA
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) ????-2008 - INRIA
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
 grand('setgen','clcg4');
 // Low level test for grand
-// Copyright INRIA
 //**********************************************************************
 //     A test program for the bottom level routines
 //     Scilab implementation of tstbot.f
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_generators.dia.ref b/scilab/modules/randlib/tests/unit_tests/grand_generators.dia.ref
new file mode 100644 (file)
index 0000000..e49e1cd
--- /dev/null
@@ -0,0 +1,549 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008 - INRIA - Sabine Gaüzere
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+//
+// <-- ENGLISH IMPOSED -->
+//  
+//
+// assert_close --
+//   Returns 1 if the two real matrices computed and expected are close,
+//   i.e. if the relative distance between computed and expected is lesser than epsilon.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_close ( computed, expected, epsilon )
+    if expected==0.0 then
+        shift = norm(computed-expected);
+    else
+        shift = norm(computed-expected)/norm(expected);
+    end
+    if shift < epsilon then
+        flag = 1;
+    else
+        flag = 0;
+    end
+    if flag <> 1 then bugmes();quit;end
+endfunction
+//
+// assert_equal --
+//   Returns 1 if the two real matrices computed and expected are equal.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_equal ( computed , expected )
+    if computed==expected then
+        flag = 1;
+    else
+        flag = 0;
+    end
+    if flag <> 1 then bugmes();quit;end
+endfunction
+function flag = assert_true ( computed )
+    if and(computed) then
+        flag = 1;
+    else
+        flag = 0;
+    end
+    if flag <> 1 then bugmes();quit;end
+endfunction
+function checkMeanVariance2arg ( m , n , name , A , B , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // A : a 1-by-1 matrix of doubles, the value of the 1st parameter
+  // B : a 1-by-1 matrix of doubles, the value of the 2nd parameter
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  R=grand(m,n,name,A,B);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+function checkMeanVariance0arg ( m , n , name , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  R=grand(m,n,name);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+function checkLaw0arg ( name , cdffun , N , NC , rtol )
+  //
+  // Check the random number generator for a continuous distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  R = grand(1,N,name);
+  [X,EmpiricalPDF] = histcompute(NC,R);
+  CDF = cdffun(X)
+  TheoricPDF = diff(CDF);
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+    if ( %f ) then
+      plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+      plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+    end
+endfunction
+function checkPieceLaw0arg ( name , cdffun , N , NC , rtol )
+  //
+  // Check the random number generator for a piecewise distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  //  The classes of the histogram are computed from the random samples, 
+  //  from which the unique entries are extracted.
+  R=grand(N,1,name);
+  X = unique(R);
+  for k = 1 : size(X,"*")
+    EmpiricalPDF(k) = length(find(R==X(k)));
+  end
+  EmpiricalPDF = EmpiricalPDF./N;
+  CDF = cdffun(X)
+  TheoricPDF=[CDF(1);diff(CDF)];
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+  if ( %f ) then
+    plot(X,EmpiricalPDF,"bo-"); // Empirical Histogram
+    plot(X,TheoricPDF,"rox-"); // Theoretical Histogram
+  end
+endfunction
+function checkPieceLaw2arg ( name , cdffun , N , NC , A , B , rtol )
+  //
+  // Check the random number generator for a piecewise distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  //  The classes of the histogram are computed from the random samples, 
+  //  from which the unique entries are extracted.
+  R=grand(N,1,name,A,B);
+  X = unique(R);
+  for k = 1 : size(X,"*")
+    EmpiricalPDF(k) = length(find(R==X(k)));
+  end
+  EmpiricalPDF = EmpiricalPDF./N;
+  CDF = cdffun(X,A,B)
+  TheoricPDF=[CDF(1);diff(CDF)];
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+  if ( %f ) then
+    plot(X,EmpiricalPDF,"bo-"); // Empirical Histogram
+    plot(X,TheoricPDF,"rox-"); // Theoretical Histogram
+  end
+endfunction
+function [x,y] = histcompute(n,data)
+   //
+   // Computes the histogram of a data.
+   //
+   // Parameters
+   // n : a 1-by-1 matrix of floating point integers, the number of classes.
+   // data : a matrix of doubles, the data
+   // x : 1-by-n+1 matrix of doubles, the classes of the histogram
+   // y : 1-by-n+1 matrix of doubles, the empirical probability that one value in data which fall in each class
+   x = linspace(min(data), max(data), n+1);
+   [ind , y] = dsearch(data, x)
+   y = y./length(data)
+endfunction
+function p = mycdfdef (X)
+  p = X
+endfunction
+function p = mycdfuin (X,A,B)
+  p = (floor(X)-A+1)/(B-A+1)
+endfunction
+function p = mycdflgi (X)
+  // Here, A and B are read from the environment
+  p = (floor(X)-A+1)/(B-A+1)
+endfunction
+//
+// These tests makes checks that all uniform generators are correct.
+// We run the following actions : 'setgen', 'getgen', 'setsd','getsd'
+// We also check the first ten uniform numbers from each generator with a known seed.
+// seedsize : size of the state for each generator
+// MinInt : minimum of the uniform integer interval for random number generation
+// MaxInt : maximum of the uniform integer interval for random number generation
+//
+NGen = 6;
+generators = ["mt"   "kiss" "clcg2"    "clcg4" "fsultra" "urand"];
+seedsize =   [625    4      2          4       40        1];
+MinInt =     [0      0      0          0       0         0];
+MaxInt =     [2^32-1 2^32-1 2147483561 2^31-2  2^32-1    2^31-1];
+rtol = 1.e-2;
+// The number of classes in the histogram
+// NC must be even.
+NC = 2*12;
+N=10000;
+//
+// The default generator must be Mersenne-Twister
+S=grand('getgen');
+assert_equal ( S , "mt" );
+// The maximum integer generable with uin option
+UinMax = 2147483560;
+////////////////////////////////////////////////////////////////////
+//
+// "mt"
+//
+kgen = 1;
+gen = "mt";
+sdsize = seedsize(kgen);
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',0);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+grand('setsd',123456);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+// Check numbers
+expected = [
+0.5488135    0.6027634    0.4236548    0.4375872    0.9636628    0.7917250  
+0.5928446    0.8579456    0.6235637    0.2975346    0.2726563    0.8121687  
+0.7151894    0.5448832    0.6458941    0.891773     0.3834415    0.5288949  
+0.8442657    0.8472517    0.3843817    0.0567130    0.4776651    0.4799772  
+];
+grand('setsd',0);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    2357136044.    2588848963.    1819583497.    1879422756.    4138900056.    3400433126.  
+    2546248239.    3684848379.    2678185683.    1277901399.    1171049868.    3488238119.  
+    3071714933.    2340255427.    2774094101.    3830135878.    1646868794.    2271586391.  
+    3626093760.    3638918503.    1650906866.    243580376.     2051556033.    2061486254.  
+];
+grand('setsd',0);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+////////////////////////////////////////////////////////////////////
+//
+// "kiss"
+//
+kgen = 2;
+gen = "kiss";
+sdsize = seedsize(kgen);
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',0,0,0,0);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+grand('setsd',123456,123456,123456,123456);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+// Check numbers
+expected = [
+0.0002874    0.9423555    0.0770725    0.0207832    0.4746445    0.1895302  
+0.8538282    0.5493145    0.3200836    0.4775516    0.2245108    0.6637360  
+0.0581523    0.6006782    0.8569004    0.0123565    0.7357421    0.5837571  
+0.5196679    0.2448867    0.2568304    0.4503826    0.9680347    0.5214808  
+];
+grand('setsd',0,0,0,0);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    1234567.       4047385867.    331023823.     89263315.      2038582807.    814026139.   
+    3667164066.    2359287638.    1374748746.    2051068542.    964266482.     2850724518.  
+    249762113.     2579893349.    3680359369.    53070701.      3159988049.    2507217781.  
+    2231956628.    1051780200.    1103078268.    1934378448.    4157677412.    2239743032.  
+];
+grand('setsd',0,0,0,0);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+////////////////////////////////////////////////////////////////////
+//
+// "clcg2"
+//
+kgen = 3;
+gen = "clcg2";
+sdsize = seedsize(kgen);
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',1,1);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+grand('setsd',123456,123456);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+// Check numbers
+expected = [
+0.9999997    0.0369445    0.2041364    0.9100817    0.6998243    0.9596867  
+0.9745196    0.1617119    0.1673069    0.1117162    0.9502824    0.9149753  
+0.6474839    0.6646450    0.6549574    0.2990212    0.0918107    0.4411791  
+0.3330856    0.0846729    0.1288161    0.2654475    0.9023415    0.0735483  
+];
+grand('setsd',1,1);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    2147482884.    79337801.      438379562.     1954385533.    1502861091.    2060911403.  
+    2092764894.    347273588.     359288887.     239908781.     2040715732.    1964894377.  
+    1390461064.    1427314282.    1406510214.    642143055.     197161966.     947424871.   
+    715295839.     181833602.     276630551.     570044126.     1937763493.    157943826.   
+];
+grand('setsd',1,1);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+////////////////////////////////////////////////////////////////////
+//
+// "clcg4"
+//
+kgen = 4;
+gen = "clcg4";
+sdsize = seedsize(kgen);
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',1,1,1,1);
+
+=> be aware that you have may lost synchronization
+    between the virtual gen 0 and the others !
+    use grand("setall", s1, s2, s3, s4) if you want recover it.S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+grand('setsd',123456,123456,123456,123456);
+
+=> be aware that you have may lost synchronization
+    between the virtual gen 0 and the others !
+    use grand("setall", s1, s2, s3, s4) if you want recover it.S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+// Check numbers
+expected = [
+0.9999661    0.0552914    0.6345306    0.0640227    0.2885048    0.2781458  
+0.6852419    0.1806991    0.8665501    0.0981421    0.2660715    0.4279616  
+0.4370514    0.4956021    0.6870544    0.8501209    0.1271038    0.4554926  
+0.4202952    0.2903676    0.5712601    0.4764120    0.1818799    0.3121748  
+];
+grand('setsd',1,1,1,1);
+
+=> be aware that you have may lost synchronization
+    between the virtual gen 0 and the others !
+    use grand("setall", s1, s2, s3, s4) if you want recover it.computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    2147410798.    118737467.     1362644105.    137487708.     619559402.    597313629.  
+    1471545799.    388048305.     1860902184.    210758531.     571384155.    919040470.  
+    938560647.     1064297484.    1475437993.    1825620628.    272953383.    978162913.  
+    902576998.     623559632.     1226771622.    1023086907.    390584072.    670390361.  
+];
+grand('setsd',1,1,1,1);
+
+=> be aware that you have may lost synchronization
+    between the virtual gen 0 and the others !
+    use grand("setall", s1, s2, s3, s4) if you want recover it.computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+////////////////////////////////////////////////////////////////////
+//
+// "fsultra"
+//
+kgen = 5;
+gen = "fsultra";
+sdsize = seedsize(kgen);
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',1,1);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+grand('setsd',123456,123456);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+// Check numbers
+expected = [
+0.3314877    0.3699260    0.4383216    0.99706      0.0577929    0.4836669  
+0.5826624    0.9600475    0.2037475    0.6774254    0.4450278    0.3082941  
+0.1630857    0.2033307    0.4214824    0.6372521    0.0782678    0.4409892  
+0.7211611    0.1833922    0.8065496    0.6375251    0.2572713    0.8039582  
+];
+grand('setsd',1,1);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    1423728774.    1588820113.    1882577034.    4282340079.    248218608.     2077333598.  
+    2502516061.    4123372468.    875088704.     2909519830.    1911379739.    1324113135.  
+    700447838.     873298853.     1810253313.    2736976953.    336157762.     1894034123.  
+    3097363227.    787663378.     3464104206.    2738149622.    1104971606.    3452974260.  
+];
+grand('setsd',1,1);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+////////////////////////////////////////////////////////////////////
+//
+// "urand"
+//
+kgen = 6;
+gen = "urand";
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',1);
+S=grand('getsd');
+assert_equal ( S , 1 );
+//
+grand('setsd',123456);
+S=grand('getsd');
+assert_equal ( S , 123456 );
+//
+// Check numbers
+expected = [
+0.6040239    0.5321420    0.2276811    0.8979351    0.8925854    0.6928366  
+0.0079647    0.4138784    0.6656067    0.8274020    0.0848163    0.6776849  
+0.6643966    0.5036204    0.9694369    0.0664231    0.2566682    0.4284010  
+0.9832111    0.6850569    0.0775390    0.1099766    0.6507795    0.3725794  
+];
+grand('setsd',1);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    1297131554.    1142766270.    488941338.     1928300854.    1916812562.    1487855278.  
+    17103983.      888797147.     1429379591.    1776832243.    182141599.     1455317259.  
+    1426780792.    1081516660.    2081849904.    142642604.     551190760.     919984100.   
+    2111429773.    1471148505.    166513637.     236172977.     1397538365.    800108169.   
+];
+grand('setsd',1);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_generators.tst b/scilab/modules/randlib/tests/unit_tests/grand_generators.tst
new file mode 100644 (file)
index 0000000..dcd3cc4
--- /dev/null
@@ -0,0 +1,561 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008 - INRIA - Sabine Gaüzere
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+//
+// <-- ENGLISH IMPOSED -->
+//  
+//
+// assert_close --
+//   Returns 1 if the two real matrices computed and expected are close,
+//   i.e. if the relative distance between computed and expected is lesser than epsilon.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_close ( computed, expected, epsilon )
+    if expected==0.0 then
+        shift = norm(computed-expected);
+    else
+        shift = norm(computed-expected)/norm(expected);
+    end
+    if shift < epsilon then
+        flag = 1;
+    else
+        flag = 0;
+    end
+    if flag <> 1 then pause,end
+endfunction
+//
+// assert_equal --
+//   Returns 1 if the two real matrices computed and expected are equal.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_equal ( computed , expected )
+    if computed==expected then
+        flag = 1;
+    else
+        flag = 0;
+    end
+    if flag <> 1 then pause,end
+endfunction
+
+function flag = assert_true ( computed )
+    if and(computed) then
+        flag = 1;
+    else
+        flag = 0;
+    end
+    if flag <> 1 then pause,end
+endfunction
+
+function checkMeanVariance2arg ( m , n , name , A , B , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // A : a 1-by-1 matrix of doubles, the value of the 1st parameter
+  // B : a 1-by-1 matrix of doubles, the value of the 2nd parameter
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  
+  R=grand(m,n,name,A,B);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+
+function checkMeanVariance0arg ( m , n , name , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  
+  R=grand(m,n,name);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+
+function checkLaw0arg ( name , cdffun , N , NC , rtol )
+  //
+  // Check the random number generator for a continuous distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+
+  R = grand(1,N,name);
+  [X,EmpiricalPDF] = histcompute(NC,R);
+  CDF = cdffun(X)
+  TheoricPDF = diff(CDF);
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+    if ( %f ) then
+      plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+      plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+    end
+endfunction
+
+function checkPieceLaw0arg ( name , cdffun , N , NC , rtol )
+  //
+  // Check the random number generator for a piecewise distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  //  The classes of the histogram are computed from the random samples, 
+  //  from which the unique entries are extracted.
+
+  R=grand(N,1,name);
+  X = unique(R);
+  for k = 1 : size(X,"*")
+    EmpiricalPDF(k) = length(find(R==X(k)));
+  end
+  EmpiricalPDF = EmpiricalPDF./N;
+  CDF = cdffun(X)
+  TheoricPDF=[CDF(1);diff(CDF)];
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+  if ( %f ) then
+    plot(X,EmpiricalPDF,"bo-"); // Empirical Histogram
+    plot(X,TheoricPDF,"rox-"); // Theoretical Histogram
+  end
+endfunction
+
+function checkPieceLaw2arg ( name , cdffun , N , NC , A , B , rtol )
+  //
+  // Check the random number generator for a piecewise distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  //  The classes of the histogram are computed from the random samples, 
+  //  from which the unique entries are extracted.
+
+  R=grand(N,1,name,A,B);
+  X = unique(R);
+  for k = 1 : size(X,"*")
+    EmpiricalPDF(k) = length(find(R==X(k)));
+  end
+  EmpiricalPDF = EmpiricalPDF./N;
+  CDF = cdffun(X,A,B)
+  TheoricPDF=[CDF(1);diff(CDF)];
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+  if ( %f ) then
+    plot(X,EmpiricalPDF,"bo-"); // Empirical Histogram
+    plot(X,TheoricPDF,"rox-"); // Theoretical Histogram
+  end
+endfunction
+
+function [x,y] = histcompute(n,data)
+   //
+   // Computes the histogram of a data.
+   //
+   // Parameters
+   // n : a 1-by-1 matrix of floating point integers, the number of classes.
+   // data : a matrix of doubles, the data
+   // x : 1-by-n+1 matrix of doubles, the classes of the histogram
+   // y : 1-by-n+1 matrix of doubles, the empirical probability that one value in data which fall in each class
+   x = linspace(min(data), max(data), n+1);
+   [ind , y] = dsearch(data, x)
+   y = y./length(data)
+endfunction
+
+function p = mycdfdef (X)
+  p = X
+endfunction
+
+function p = mycdfuin (X,A,B)
+  p = (floor(X)-A+1)/(B-A+1)
+endfunction
+
+function p = mycdflgi (X)
+  // Here, A and B are read from the environment
+  p = (floor(X)-A+1)/(B-A+1)
+endfunction
+
+
+//
+// These tests makes checks that all uniform generators are correct.
+// We run the following actions : 'setgen', 'getgen', 'setsd','getsd'
+// We also check the first ten uniform numbers from each generator with a known seed.
+// seedsize : size of the state for each generator
+// MinInt : minimum of the uniform integer interval for random number generation
+// MaxInt : maximum of the uniform integer interval for random number generation
+//
+NGen = 6;
+generators = ["mt"   "kiss" "clcg2"    "clcg4" "fsultra" "urand"];
+seedsize =   [625    4      2          4       40        1];
+MinInt =     [0      0      0          0       0         0];
+MaxInt =     [2^32-1 2^32-1 2147483561 2^31-2  2^32-1    2^31-1];
+
+rtol = 1.e-2;
+
+// The number of classes in the histogram
+// NC must be even.
+NC = 2*12;
+N=10000;
+
+//
+// The default generator must be Mersenne-Twister
+S=grand('getgen');
+assert_equal ( S , "mt" );
+
+// The maximum integer generable with uin option
+UinMax = 2147483560;
+
+////////////////////////////////////////////////////////////////////
+//
+// "mt"
+//
+kgen = 1;
+gen = "mt";
+sdsize = seedsize(kgen);
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',0);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+grand('setsd',123456);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+// Check numbers
+expected = [
+0.5488135    0.6027634    0.4236548    0.4375872    0.9636628    0.7917250  
+0.5928446    0.8579456    0.6235637    0.2975346    0.2726563    0.8121687  
+0.7151894    0.5448832    0.6458941    0.891773     0.3834415    0.5288949  
+0.8442657    0.8472517    0.3843817    0.0567130    0.4776651    0.4799772  
+];
+grand('setsd',0);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    2357136044.    2588848963.    1819583497.    1879422756.    4138900056.    3400433126.  
+    2546248239.    3684848379.    2678185683.    1277901399.    1171049868.    3488238119.  
+    3071714933.    2340255427.    2774094101.    3830135878.    1646868794.    2271586391.  
+    3626093760.    3638918503.    1650906866.    243580376.     2051556033.    2061486254.  
+];
+grand('setsd',0);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+
+////////////////////////////////////////////////////////////////////
+//
+// "kiss"
+//
+kgen = 2;
+gen = "kiss";
+sdsize = seedsize(kgen);
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',0,0,0,0);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+grand('setsd',123456,123456,123456,123456);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+// Check numbers
+expected = [
+0.0002874    0.9423555    0.0770725    0.0207832    0.4746445    0.1895302  
+0.8538282    0.5493145    0.3200836    0.4775516    0.2245108    0.6637360  
+0.0581523    0.6006782    0.8569004    0.0123565    0.7357421    0.5837571  
+0.5196679    0.2448867    0.2568304    0.4503826    0.9680347    0.5214808  
+];
+grand('setsd',0,0,0,0);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    1234567.       4047385867.    331023823.     89263315.      2038582807.    814026139.   
+    3667164066.    2359287638.    1374748746.    2051068542.    964266482.     2850724518.  
+    249762113.     2579893349.    3680359369.    53070701.      3159988049.    2507217781.  
+    2231956628.    1051780200.    1103078268.    1934378448.    4157677412.    2239743032.  
+];
+grand('setsd',0,0,0,0);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+////////////////////////////////////////////////////////////////////
+//
+// "clcg2"
+//
+kgen = 3;
+gen = "clcg2";
+sdsize = seedsize(kgen);
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',1,1);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+grand('setsd',123456,123456);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+// Check numbers
+expected = [
+0.9999997    0.0369445    0.2041364    0.9100817    0.6998243    0.9596867  
+0.9745196    0.1617119    0.1673069    0.1117162    0.9502824    0.9149753  
+0.6474839    0.6646450    0.6549574    0.2990212    0.0918107    0.4411791  
+0.3330856    0.0846729    0.1288161    0.2654475    0.9023415    0.0735483  
+];
+grand('setsd',1,1);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    2147482884.    79337801.      438379562.     1954385533.    1502861091.    2060911403.  
+    2092764894.    347273588.     359288887.     239908781.     2040715732.    1964894377.  
+    1390461064.    1427314282.    1406510214.    642143055.     197161966.     947424871.   
+    715295839.     181833602.     276630551.     570044126.     1937763493.    157943826.   
+];
+grand('setsd',1,1);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+////////////////////////////////////////////////////////////////////
+//
+// "clcg4"
+//
+kgen = 4;
+gen = "clcg4";
+sdsize = seedsize(kgen);
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',1,1,1,1);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+grand('setsd',123456,123456,123456,123456);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+// Check numbers
+expected = [
+0.9999661    0.0552914    0.6345306    0.0640227    0.2885048    0.2781458  
+0.6852419    0.1806991    0.8665501    0.0981421    0.2660715    0.4279616  
+0.4370514    0.4956021    0.6870544    0.8501209    0.1271038    0.4554926  
+0.4202952    0.2903676    0.5712601    0.4764120    0.1818799    0.3121748  
+];
+grand('setsd',1,1,1,1);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    2147410798.    118737467.     1362644105.    137487708.     619559402.    597313629.  
+    1471545799.    388048305.     1860902184.    210758531.     571384155.    919040470.  
+    938560647.     1064297484.    1475437993.    1825620628.    272953383.    978162913.  
+    902576998.     623559632.     1226771622.    1023086907.    390584072.    670390361.  
+];
+grand('setsd',1,1,1,1);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+////////////////////////////////////////////////////////////////////
+//
+// "fsultra"
+//
+kgen = 5;
+gen = "fsultra";
+sdsize = seedsize(kgen);
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',1,1);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+grand('setsd',123456,123456);
+S=grand('getsd');
+assert_equal ( typeof(S) , "constant" );
+assert_equal ( size(S) , [sdsize 1] );
+//
+// Check numbers
+expected = [
+0.3314877    0.3699260    0.4383216    0.99706      0.0577929    0.4836669  
+0.5826624    0.9600475    0.2037475    0.6774254    0.4450278    0.3082941  
+0.1630857    0.2033307    0.4214824    0.6372521    0.0782678    0.4409892  
+0.7211611    0.1833922    0.8065496    0.6375251    0.2572713    0.8039582  
+];
+grand('setsd',1,1);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    1423728774.    1588820113.    1882577034.    4282340079.    248218608.     2077333598.  
+    2502516061.    4123372468.    875088704.     2909519830.    1911379739.    1324113135.  
+    700447838.     873298853.     1810253313.    2736976953.    336157762.     1894034123.  
+    3097363227.    787663378.     3464104206.    2738149622.    1104971606.    3452974260.  
+];
+grand('setsd',1,1);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+////////////////////////////////////////////////////////////////////
+//
+// "urand"
+//
+kgen = 6;
+gen = "urand";
+grand('setgen',gen);
+S=grand('getgen');
+assert_equal ( S , gen );
+//
+grand('setsd',1);
+S=grand('getsd');
+assert_equal ( S , 1 );
+//
+grand('setsd',123456);
+S=grand('getsd');
+assert_equal ( S , 123456 );
+//
+// Check numbers
+expected = [
+0.6040239    0.5321420    0.2276811    0.8979351    0.8925854    0.6928366  
+0.0079647    0.4138784    0.6656067    0.8274020    0.0848163    0.6776849  
+0.6643966    0.5036204    0.9694369    0.0664231    0.2566682    0.4284010  
+0.9832111    0.6850569    0.0775390    0.1099766    0.6507795    0.3725794  
+];
+grand('setsd',1);
+computed = grand(4,6,"def");
+assert_close ( computed , expected, 1.e-7 );
+//
+// Check integers
+expected = [
+    1297131554.    1142766270.    488941338.     1928300854.    1916812562.    1487855278.  
+    17103983.      888797147.     1429379591.    1776832243.    182141599.     1455317259.  
+    1426780792.    1081516660.    2081849904.    142642604.     551190760.     919984100.   
+    2111429773.    1471148505.    166513637.     236172977.     1397538365.    800108169.   
+];
+grand('setsd',1);
+computed = grand(4,6,"lgi");
+assert_equal ( computed , expected );
+//
+// Check distribution of uniform numbers in [0,1[
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+//
+// Check distribution of uniform integers in [A,B]
+A = MinInt(kgen);
+B = MaxInt(kgen);
+checkMeanVariance0arg ( 400 , 800 , "lgi" , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , 0 , UinMax , rtol );
+checkPieceLaw0arg ( "lgi" , mycdflgi , N , NC , rtol );
+
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_laws.dia.ref b/scilab/modules/randlib/tests/unit_tests/grand_laws.dia.ref
new file mode 100644 (file)
index 0000000..2660e85
--- /dev/null
@@ -0,0 +1,638 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008 - INRIA - Sabine Gaüzere
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+//
+// assert_close --
+//   Returns 1 if the two real matrices computed and expected are close,
+//   i.e. if the relative distance between computed and expected is lesser than epsilon.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_close ( computed, expected, epsilon )
+  if expected==0.0 then
+    shift = norm(computed-expected);
+  else
+    shift = norm(computed-expected)/norm(expected);
+  end
+  if shift < epsilon then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then bugmes();quit;end
+endfunction
+//
+// assert_equal --
+//   Returns 1 if the two real matrices computed and expected are equal.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_equal ( computed , expected )
+  if computed==expected then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then bugmes();quit;end
+endfunction
+function flag = assert_true ( computed )
+  if and(computed) then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then bugmes();quit;end
+endfunction
+function [x,y] = histcompute(n,data)
+   //
+   // Computes the histogram of a data.
+   //
+   // Parameters
+   // n : a 1-by-1 matrix of floating point integers, the number of classes.
+   // data : a matrix of doubles, the data
+   // x : 1-by-n+1 matrix of doubles, the classes of the histogram
+   // y : 1-by-n+1 matrix of doubles, the empirical probability that one value in data which fall in each class
+   x = linspace(min(data), max(data), n+1);
+   [ind , y] = dsearch(data, x)
+   y = y./length(data)
+endfunction
+function checkLaw0arg ( name , cdffun , N , NC , rtol )
+  //
+  // Check the random number generator for a continuous distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  R = grand(1,N,name);
+  [X,EmpiricalPDF] = histcompute(NC,R);
+  CDF = cdffun(X)
+  TheoricPDF = diff(CDF);
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+    if ( %f ) then
+      plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+      plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+    end
+endfunction
+function checkLaw1arg ( name , cdffun , N , NC , A , rtol )
+  //
+  // Check the random number generator for a continuous distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  R = grand(1,N,name,A);
+  [X,EmpiricalPDF] = histcompute(NC,R);
+  CDF = cdffun(X,A)
+  TheoricPDF = diff(CDF);
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+    if ( %f ) then
+      plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+      plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+    end
+endfunction
+function checkLaw2arg ( name , cdffun , N , NC , A , B , rtol )
+  //
+  // Check the random number generator for a continuous distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the 1st parameter
+  // B : a 1-by-1 matrix of doubles, the value of the 2nd parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  R = grand(1,N,name,A,B);
+  [X,EmpiricalPDF] = histcompute(NC,R);
+  CDF = cdffun(X,A,B)
+  TheoricPDF = diff(CDF);
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+    if ( %f ) then
+      plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+      plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+    end
+endfunction
+function checkLaw3arg ( name , cdffun , N , NC , A , B , C , rtol )
+  //
+  // Check the random number generator for a continuous distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the 1st parameter
+  // B : a 1-by-1 matrix of doubles, the value of the 2nd parameter
+  // C : a 1-by-1 matrix of doubles, the value of the 3d parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  R = grand(1,N,name,A,B,C);
+  [X,EmpiricalPDF] = histcompute(NC,R);
+  CDF = cdffun(X,A,B,C)
+  TheoricPDF = diff(CDF);
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+    if ( %f ) then
+      plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+      plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+    end
+endfunction
+function checkPieceLaw1arg ( name , cdffun , N , NC , A , rtol )
+  //
+  // Check the random number generator for a piecewise distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  //  The classes of the histogram are computed from the random samples, 
+  //  from which the unique entries are extracted.
+  R=grand(N,1,name,A);
+  X = unique(R);
+  for k = 1 : size(X,"*")
+    EmpiricalPDF(k) = length(find(R==X(k)));
+  end
+  EmpiricalPDF = EmpiricalPDF./N;
+  CDF = cdffun(X,A)
+  TheoricPDF=[CDF(1);diff(CDF)];
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+  if ( %f ) then
+    plot(X,EmpiricalPDF,"bo-"); // Empirical Histogram
+    plot(X,TheoricPDF,"rox-"); // Theoretical Histogram
+  end
+endfunction
+function checkPieceLaw2arg ( name , cdffun , N , NC , A , B , rtol )
+  //
+  // Check the random number generator for a piecewise distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  //  The classes of the histogram are computed from the random samples, 
+  //  from which the unique entries are extracted.
+  R=grand(N,1,name,A,B);
+  X = unique(R);
+  for k = 1 : size(X,"*")
+    EmpiricalPDF(k) = length(find(R==X(k)));
+  end
+  EmpiricalPDF = EmpiricalPDF./N;
+  CDF = cdffun(X,A,B)
+  TheoricPDF=[CDF(1);diff(CDF)];
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+  if ( %f ) then
+    plot(X,EmpiricalPDF,"bo-"); // Empirical Histogram
+    plot(X,TheoricPDF,"rox-"); // Theoretical Histogram
+  end
+endfunction
+function checkMeanVariance0arg ( m , n , name , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  R=grand(m,n,name);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+function checkMeanVariance1arg ( m , n , name , A , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // A : a 1-by-1 matrix of doubles, the value of the parameter
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  R=grand(m,n,name,A);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+function checkMeanVariance2arg ( m , n , name , A , B , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // A : a 1-by-1 matrix of doubles, the value of the 1st parameter
+  // B : a 1-by-1 matrix of doubles, the value of the 2nd parameter
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  R=grand(m,n,name,A,B);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+function checkMeanVariance3arg ( m , n , name , A , B , C , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // A : a 1-by-1 matrix of doubles, the value of the 1st parameter
+  // B : a 1-by-1 matrix of doubles, the value of the 2nd parameter
+  // C : a 1-by-1 matrix of doubles, the value of the 3d parameter
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  R=grand(m,n,name,A,B,C);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+//
+// Calling sequences
+//
+// Y=grand(m,n,'nor',Av,Sd)       : OK
+// Y=grand(m,n,'poi',mu)          : OK
+// Y=grand(m,n,'exp',Av)          : OK
+// Y=grand(m,n,'bet',A,B)         : OK
+// Y=grand(m,n,'bin',N,p)         : OK
+// Y=grand(m,n,'gam',shape,scale) : OK
+// Y=grand(m,n,'f',Dfn,Dfd)       : OK
+// Y=grand(m,n,'chi', Df)         : OK
+// Y=grand(m,n,'nbn',N,p)         : OK
+// Y=grand(m,n,'nch',Df,Xnon)     : OK
+// Y=grand(m,n,'nf',Dfn,Dfd,Xnon) : OK
+// Y=grand(n,'mn',Mean,Cov)       : OK
+// Y=grand(m,n,'geom', p)         : OK
+// Y=grand(m,n,'def')             : OK
+// Y=grand(m,n,'unf',Low,High)    : OK
+// Y=grand(m,n,'uin',Low,High)    : OK
+// Y=grand(n,'markov',P,x0)       : TODO
+// Y=grand(n,'mul',nb,P)          : TODO
+// Y=grand(n,'prm',vect)          : in grand_prm.tst
+// Y=grand(m,n,'lgi')  : in grand_generators.tst
+// S=grand('getgen')   : in grand_generators.tst
+// grand('setgen',gen) : in grand_generators.tst
+// S=grand('getsd')    : in grand_generators.tst
+// grand('setsd',S)    : in grand_generators.tst
+// For CLCG4 only:
+// grand('setcgn',G)           : in grand_clcg4.tst
+// S=grand('getcgn')           : TODO
+// grand('initgn',I)           : in grand_clcg4.tst
+// grand('setall',s1,s2,s3,s4) : in grand_clcg4.tst
+// grand('advnst',K)           : TODO
+//
+// Rationale for the unit tests of random number generators.
+//
+// There are several ways to check the output of random number generators.
+//
+// 1. Uniform random number generators are based on deterministic integer sequences.
+// These integers are then scaled into the [0,1[ interval.
+// When we set the seed to a constant (e.g. seed = 0, or seed=123456),
+// the doubles which are produced are always the same.
+// This does not check the quality of the generator.
+// But it does check that the generator under evaluation is, indeed, the 
+// expected generator.
+//
+// 2. Non-uniform random numbers have a given mean and a variance which 
+// can be predicted by there associated distribution function.
+// The problem is there to set the relative tolerance. 
+// The convergence of the sample mean to the expectation is driven by the
+// law of large numbers. 
+// The standard deviation of the sample mean is sigma/sqrt(n), 
+// meaning that to reduce the shift by a factor 2, we have to use 4x more points. 
+//
+// 3. The quality of a random number generator can be assessed by 
+// statistical tests. 
+// The Kolmogorov-Smirnov test is based on the comparison between the 
+// empirical CDF and the theoretical CDF. The difference between the two is 
+// a random variable, which must evolve according to the Normal distribution function. 
+// Then, the sum of the squares of the differences should evolve according to the 
+// Chi-square distribution function. By inverting this last distribution, we can 
+// compute the probability that the empirical distribution matches the theoretical distribution.
+//
+// 4. The empirical histogram must match the theoretical histogram. 
+// The number of classes is NC.
+// The classes XC are computed from NC and the actual output ; X has NC+1 entries.
+// The empirical histogram is the probability that X is the intervals defined by X.
+// The theoretical histogram is computed by differences 
+// of the cumulated probability distribution function.
+// The histograms can be graphically compared with the statements:
+// plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+// plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+//
+//
+// In this script, we check the non-uniform random numbers.
+// We use the strategies #2 and #4.
+// The strategy #3 should be used in a future version of the tests (it requires to 
+// develop the kstest function).
+//
+rtol = 1.e-2;
+// The number of classes in the histogram
+// NC must be even.
+NC = 2*12;
+N=10000;
+// Set the seed to always get the same random numbers
+grand("setsd",0);
+/////////////////////////////////////////////////////////////
+//
+// 'exp'
+//
+function p = mycdfexp(X,A)
+  p = 1 - exp(-(1/A)*X);
+endfunction
+A = 20;
+checkMeanVariance1arg ( 400 , 800 , 'exp' , A , A , A^2 , rtol );
+//
+for A = linspace(0.1,50,10)
+  checkLaw1arg ( "exp" , mycdfexp , N , NC , A , 2*rtol );
+end
+/////////////////////////////////////////////////////////////
+//
+// 'gam'
+//
+function p = mycdfgam (X,A,B)
+  p = cdfgam("PQ",X,A*ones(X),B*ones(X));
+endfunction
+A = 5;
+B = 3;
+checkMeanVariance2arg ( 400 , 800 , 'gam' , A , B , A/B , A/(B^2) , rtol );
+//
+for A = linspace(1,15,4)
+  for B = linspace(1,15,4)
+    checkLaw2arg ( 'gam' , mycdfgam , N , NC , A , B , rtol );
+  end
+end
+/////////////////////////////////////////////////////////////
+//
+// 'bet'
+//
+function p = mycdfbet (X,A,B)
+  p = cdfbet("PQ",X,1-X,A*ones(X),B*ones(X));
+endfunction
+A=3;
+B=10;
+checkMeanVariance2arg ( 400 , 800 , 'bet' , A , B , A/(A+B) , (A*B)/((A+B)^2*(A+B+1)) , rtol );
+//
+for A = linspace(1,20,4)
+  for B = linspace(1,20,4)
+    checkLaw2arg ( 'bet' , mycdfbet , N , NC , A , B , 2*rtol );
+  end
+end
+/////////////////////////////////////////////////////////////
+//
+// 'poi'
+//
+// Caution : this is a piecewise distribution
+function p = mycdfpoi (X,A)
+  p = cdfpoi("PQ",X,A*ones(X));
+endfunction
+A = 10;
+checkMeanVariance1arg ( 400 , 800 , 'poi' , A , A , A , rtol );
+//
+for A = floor(linspace(50,70,10))
+  checkPieceLaw1arg ( 'poi' , mycdfpoi , N , NC , A , rtol );
+end
+/////////////////////////////////////////////////////////////
+//
+// 'bin'
+//
+// Caution : this is a piecewise distribution
+function p = mycdfbin (X,A,B)
+  p = cdfbin("PQ",X,A*ones(X),B*ones(X),(1-B)*ones(X));
+endfunction
+A = 10;
+B = 0.4;
+checkMeanVariance2arg ( 400 , 800 , 'bin' , A , B , A*B , A*B*(1-B) , rtol );
+//
+for A = floor(linspace(10,50,4))
+for B = linspace(0.1,0.9,4)
+  checkPieceLaw2arg ( 'bin' , mycdfbin , N , NC , A , B , rtol );
+end
+end
+/////////////////////////////////////////////////////////////
+//
+// 'nor'
+//
+function p = mycdfnor (X,A,B)
+  p = cdfnor("PQ",X,A*ones(X),B*ones(X));
+endfunction
+A = 7;
+B = 12;
+checkMeanVariance2arg ( 400 , 800 , 'nor' , A , B , A , B^2 , rtol );
+//
+//
+for A = linspace(1,20,4)
+  for B = linspace(1,20,4)
+    checkLaw2arg ( 'nor' , mycdfnor , N , NC , A , B , rtol );
+  end
+end
+/////////////////////////////////////////////////////////////
+//
+// 'f'
+//
+function p = mycdff (X,A,B)
+  p = cdff("PQ",X,A*ones(X),B*ones(X));
+endfunction
+//
+// Increase the tolerance for this test.
+A = 7;
+B = 12;
+checkMeanVariance2arg ( 400 , 800 , 'f' , A , B , B/(B-2) , (2*B^2*(A+B-2))/(A*(B-2)^2*(B-4)) , 4*rtol );
+//
+for A = linspace(1,20,4)
+  for B = floor(linspace(5,20,4))
+    checkLaw2arg ( 'f' , mycdff , N , NC , A , B , 2*rtol );
+  end
+end
+/////////////////////////////////////////////////////////////
+//
+// 'chi'
+//
+function p = mycdfchi (X,A)
+  p = cdfchi("PQ",X,A*ones(X));
+endfunction
+A = 7;
+checkMeanVariance1arg ( 400 , 800 , 'chi' , A , A , 2*A , rtol );
+// Increase the tolerance for this test.
+for A = floor(linspace(1,20,10))
+    checkLaw1arg ( 'chi' , mycdfchi , N , NC , A , 2*rtol );
+end
+/////////////////////////////////////////////////////////////
+//
+// 'nbn'
+//
+// This is a piecewise function.
+function p = mycdfnbn (X,A,B)
+  p = cdfnbn("PQ",X,A*ones(X),B*ones(X),(1-B)*ones(X));
+endfunction
+A = 7;
+B = 0.1;
+checkMeanVariance2arg ( 400 , 800 , 'nbn' , A , B , A*(1-B)/B , A*(1-B)/B^2 , rtol );
+// Increase the tolerance for this test.
+for A = floor(linspace(1,20,4))
+for B = linspace(0.1,0.9,4)
+    checkPieceLaw2arg ( 'nbn' , mycdfnbn , N , NC , A , B , 2*rtol );
+end
+end
+/////////////////////////////////////////////////////////////
+//
+// 'nch'
+//
+function p = mycdfnch (X,A,B)
+  p = cdfchn("PQ",X,A*ones(X),B*ones(X));
+endfunction
+A = 4;
+B = 3;
+checkMeanVariance2arg ( 400 , 800 , 'nch' , A , B , A+B , 2*(A+2*B) , rtol );
+for A = floor(linspace(1,20,4))
+for B = floor(linspace(1,20,4))
+    checkLaw2arg ( 'nch' , mycdfnch , N , NC , A , B , 2*rtol );
+end
+end
+/////////////////////////////////////////////////////////////
+//
+// 'nf'
+// http://mathworld.wolfram.com/NoncentralF-Distribution.html
+//
+function p = mycdfnf (X,A,B,C)
+  p = cdffnc("PQ",X,A*ones(X),B*ones(X),C*ones(X));
+endfunction
+A = 4;
+B = 3;
+C = 10;
+checkMeanVariance3arg ( 400 , 800 , 'nf' , A , B , C , ((C+A)*B)/(A*(B-2)) , [] , 4*rtol );
+for A = floor(linspace(1,20,4))
+for B = floor(linspace(1,20,4))
+for C = floor(linspace(1,20,4))
+    checkLaw3arg ( 'nf' , mycdfnf , N , NC , A , B , C , 2*rtol );
+end
+end
+end
+/////////////////////////////////////////////////////////////
+//
+// "mn"
+//
+n = 2^16;
+A = [1;2;3];
+// The covariance matrix B is symetric, positive definite.
+// Its diagonal entries are [4;6;5], the variances.
+B = [4,2,3;2,6,4;3,4,5];
+  R=grand(n,"mn",A,B);
+  assert_equal ( size(R) , [3,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R,"c") , A , rtol );
+  assert_close ( variance(R,"c") , [4;6;5] , rtol );
+//
+// No CDF for this function => no histogram test. 
+/////////////////////////////////////////////////////////////
+//
+// "geom"
+// http://en.wikipedia.org/wiki/Geometric_distribution
+//
+A = 0.1;
+checkMeanVariance1arg ( 400 , 800 , "geom" , A , 1/A , (1-A)/A^2 , rtol );
+function p = mycdfgeom (X,A)
+  p = 1 -(1-A)^X
+endfunction
+//
+for A = linspace(0.1,0.9,10)
+   checkPieceLaw1arg ( "geom" , mycdfgeom , N , NC , A , 2*rtol );
+end
+/////////////////////////////////////////////////////////////
+//
+// "unf"
+// http://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
+//
+A = 0.1;
+B = 2.3;
+checkMeanVariance2arg ( 400 , 800 , "unf" , A , B , (A+B)/2 , (B-A)^2/12 , rtol );
+function p = mycdfunf (X,A,B)
+  p = (X-A)/(B-A)
+endfunction
+//
+for A = linspace(0.1,0.9,4)
+for B = linspace(2.5,4.2,4)
+   checkLaw2arg ( "unf" , mycdfunf , N , NC , A , B , rtol );
+end
+end
+/////////////////////////////////////////////////////////////
+//
+// "uin"
+// http://en.wikipedia.org/wiki/Uniform_distribution_(discrete)
+//
+// Piecewise.
+A = 10;
+B = 20;
+checkMeanVariance2arg ( 400 , 800 , "uin" , A , B , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+function p = mycdfuin (X,A,B)
+  p = (floor(X)-A+1)/(B-A+1)
+endfunction
+//
+for A = floor(linspace(10,20,4))
+for B = floor(linspace(30,40,4))
+   checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , A , B , rtol );
+end
+end
+/////////////////////////////////////////////////////////////
+//
+// "def"
+// http://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
+//
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+function p = mycdfdef (X)
+  p = X
+endfunction
+//
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_laws.tst b/scilab/modules/randlib/tests/unit_tests/grand_laws.tst
new file mode 100644 (file)
index 0000000..7cae2ba
--- /dev/null
@@ -0,0 +1,723 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008 - INRIA - Sabine Gaüzere
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+
+//
+// assert_close --
+//   Returns 1 if the two real matrices computed and expected are close,
+//   i.e. if the relative distance between computed and expected is lesser than epsilon.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_close ( computed, expected, epsilon )
+  if expected==0.0 then
+    shift = norm(computed-expected);
+  else
+    shift = norm(computed-expected)/norm(expected);
+  end
+  if shift < epsilon then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then pause,end
+endfunction
+//
+// assert_equal --
+//   Returns 1 if the two real matrices computed and expected are equal.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_equal ( computed , expected )
+  if computed==expected then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then pause,end
+endfunction
+
+function flag = assert_true ( computed )
+  if and(computed) then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then pause,end
+endfunction
+
+function [x,y] = histcompute(n,data)
+   //
+   // Computes the histogram of a data.
+   //
+   // Parameters
+   // n : a 1-by-1 matrix of floating point integers, the number of classes.
+   // data : a matrix of doubles, the data
+   // x : 1-by-n+1 matrix of doubles, the classes of the histogram
+   // y : 1-by-n+1 matrix of doubles, the empirical probability that one value in data which fall in each class
+   x = linspace(min(data), max(data), n+1);
+   [ind , y] = dsearch(data, x)
+   y = y./length(data)
+endfunction
+
+function checkLaw0arg ( name , cdffun , N , NC , rtol )
+  //
+  // Check the random number generator for a continuous distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+
+  R = grand(1,N,name);
+  [X,EmpiricalPDF] = histcompute(NC,R);
+  CDF = cdffun(X)
+  TheoricPDF = diff(CDF);
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+    if ( %f ) then
+      plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+      plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+    end
+endfunction
+
+function checkLaw1arg ( name , cdffun , N , NC , A , rtol )
+  //
+  // Check the random number generator for a continuous distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+
+  R = grand(1,N,name,A);
+  [X,EmpiricalPDF] = histcompute(NC,R);
+  CDF = cdffun(X,A)
+  TheoricPDF = diff(CDF);
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+    if ( %f ) then
+      plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+      plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+    end
+endfunction
+
+function checkLaw2arg ( name , cdffun , N , NC , A , B , rtol )
+  //
+  // Check the random number generator for a continuous distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the 1st parameter
+  // B : a 1-by-1 matrix of doubles, the value of the 2nd parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+
+  R = grand(1,N,name,A,B);
+  [X,EmpiricalPDF] = histcompute(NC,R);
+  CDF = cdffun(X,A,B)
+  TheoricPDF = diff(CDF);
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+    if ( %f ) then
+      plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+      plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+    end
+endfunction
+
+function checkLaw3arg ( name , cdffun , N , NC , A , B , C , rtol )
+  //
+  // Check the random number generator for a continuous distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the 1st parameter
+  // B : a 1-by-1 matrix of doubles, the value of the 2nd parameter
+  // C : a 1-by-1 matrix of doubles, the value of the 3d parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+
+  R = grand(1,N,name,A,B,C);
+  [X,EmpiricalPDF] = histcompute(NC,R);
+  CDF = cdffun(X,A,B,C)
+  TheoricPDF = diff(CDF);
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+    if ( %f ) then
+      plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+      plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+    end
+endfunction
+
+function checkPieceLaw1arg ( name , cdffun , N , NC , A , rtol )
+  //
+  // Check the random number generator for a piecewise distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  //  The classes of the histogram are computed from the random samples, 
+  //  from which the unique entries are extracted.
+
+  R=grand(N,1,name,A);
+  X = unique(R);
+  for k = 1 : size(X,"*")
+    EmpiricalPDF(k) = length(find(R==X(k)));
+  end
+  EmpiricalPDF = EmpiricalPDF./N;
+  CDF = cdffun(X,A)
+  TheoricPDF=[CDF(1);diff(CDF)];
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+  if ( %f ) then
+    plot(X,EmpiricalPDF,"bo-"); // Empirical Histogram
+    plot(X,TheoricPDF,"rox-"); // Theoretical Histogram
+  end
+endfunction
+
+function checkPieceLaw2arg ( name , cdffun , N , NC , A , B , rtol )
+  //
+  // Check the random number generator for a piecewise distribution function.
+  //
+  // Parameters
+  // name: a 1-by-1 string, the name of the distribution function
+  // cdffun : a function, the Cumulated Distribution Function
+  // NC : a 1-by-1 matrix of floating point integers, the number of classes
+  // N : a 1-by-1 matrix of floating point integers, the number of random values to test
+  // A : a 1-by-1 matrix of doubles, the value of the parameter
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  //
+  // Description
+  //  Compare the empirical histogram with the theoretical histogram.
+  //  The classes of the histogram are computed from the random samples, 
+  //  from which the unique entries are extracted.
+
+  R=grand(N,1,name,A,B);
+  X = unique(R);
+  for k = 1 : size(X,"*")
+    EmpiricalPDF(k) = length(find(R==X(k)));
+  end
+  EmpiricalPDF = EmpiricalPDF./N;
+  CDF = cdffun(X,A,B)
+  TheoricPDF=[CDF(1);diff(CDF)];
+  assert_true( abs(EmpiricalPDF-TheoricPDF) < rtol );
+  if ( %f ) then
+    plot(X,EmpiricalPDF,"bo-"); // Empirical Histogram
+    plot(X,TheoricPDF,"rox-"); // Theoretical Histogram
+  end
+endfunction
+
+function checkMeanVariance0arg ( m , n , name , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  
+  R=grand(m,n,name);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+
+
+function checkMeanVariance1arg ( m , n , name , A , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // A : a 1-by-1 matrix of doubles, the value of the parameter
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  
+  R=grand(m,n,name,A);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+
+function checkMeanVariance2arg ( m , n , name , A , B , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // A : a 1-by-1 matrix of doubles, the value of the 1st parameter
+  // B : a 1-by-1 matrix of doubles, the value of the 2nd parameter
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  
+  R=grand(m,n,name,A,B);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+  
+
+function checkMeanVariance3arg ( m , n , name , A , B , C , mu , va , rtol )
+  // Check the mean and variance of random numbers.
+  //
+  // Parameters
+  // m : a 1-by-1 matrix of floating point integers, the number of rows
+  // n : a 1-by-1 matrix of floating point integers, the number of columns
+  // name: a 1-by-1 string, the name of the distribution function
+  // A : a 1-by-1 matrix of doubles, the value of the 1st parameter
+  // B : a 1-by-1 matrix of doubles, the value of the 2nd parameter
+  // C : a 1-by-1 matrix of doubles, the value of the 3d parameter
+  // mu : a 1-by-1 matrix of doubles, the expected mean
+  // va : a 1-by-1 matrix of doubles, the expected variance. If va==[], then the variance is not checked.
+  // rtol : a 1-by-1 matrix of doubles, the relative tolerance
+  
+  R=grand(m,n,name,A,B,C);
+  assert_equal ( size(R) , [m,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R) , mu , rtol );
+  if ( va<>[] ) then
+    assert_close ( variance(R) , va , rtol );
+  end
+endfunction
+
+//
+// Calling sequences
+//
+// Y=grand(m,n,'nor',Av,Sd)       : OK
+// Y=grand(m,n,'poi',mu)          : OK
+// Y=grand(m,n,'exp',Av)          : OK
+// Y=grand(m,n,'bet',A,B)         : OK
+// Y=grand(m,n,'bin',N,p)         : OK
+// Y=grand(m,n,'gam',shape,scale) : OK
+// Y=grand(m,n,'f',Dfn,Dfd)       : OK
+// Y=grand(m,n,'chi', Df)         : OK
+// Y=grand(m,n,'nbn',N,p)         : OK
+// Y=grand(m,n,'nch',Df,Xnon)     : OK
+// Y=grand(m,n,'nf',Dfn,Dfd,Xnon) : OK
+// Y=grand(n,'mn',Mean,Cov)       : OK
+// Y=grand(m,n,'geom', p)         : OK
+// Y=grand(m,n,'def')             : OK
+// Y=grand(m,n,'unf',Low,High)    : OK
+// Y=grand(m,n,'uin',Low,High)    : OK
+// Y=grand(n,'markov',P,x0)       : TODO
+// Y=grand(n,'mul',nb,P)          : TODO
+// Y=grand(n,'prm',vect)          : in grand_prm.tst
+// Y=grand(m,n,'lgi')  : in grand_generators.tst
+// S=grand('getgen')   : in grand_generators.tst
+// grand('setgen',gen) : in grand_generators.tst
+// S=grand('getsd')    : in grand_generators.tst
+// grand('setsd',S)    : in grand_generators.tst
+
+// For CLCG4 only:
+// grand('setcgn',G)           : in grand_clcg4.tst
+// S=grand('getcgn')           : TODO
+// grand('initgn',I)           : in grand_clcg4.tst
+// grand('setall',s1,s2,s3,s4) : in grand_clcg4.tst
+// grand('advnst',K)           : TODO
+
+//
+// Rationale for the unit tests of random number generators.
+//
+// There are several ways to check the output of random number generators.
+//
+// 1. Uniform random number generators are based on deterministic integer sequences.
+// These integers are then scaled into the [0,1[ interval.
+// When we set the seed to a constant (e.g. seed = 0, or seed=123456),
+// the doubles which are produced are always the same.
+// This does not check the quality of the generator.
+// But it does check that the generator under evaluation is, indeed, the 
+// expected generator.
+//
+// 2. Non-uniform random numbers have a given mean and a variance which 
+// can be predicted by there associated distribution function.
+// The problem is there to set the relative tolerance. 
+// The convergence of the sample mean to the expectation is driven by the
+// law of large numbers. 
+// The standard deviation of the sample mean is sigma/sqrt(n), 
+// meaning that to reduce the shift by a factor 2, we have to use 4x more points. 
+//
+// 3. The quality of a random number generator can be assessed by 
+// statistical tests. 
+// The Kolmogorov-Smirnov test is based on the comparison between the 
+// empirical CDF and the theoretical CDF. The difference between the two is 
+// a random variable, which must evolve according to the Normal distribution function. 
+// Then, the sum of the squares of the differences should evolve according to the 
+// Chi-square distribution function. By inverting this last distribution, we can 
+// compute the probability that the empirical distribution matches the theoretical distribution.
+//
+// 4. The empirical histogram must match the theoretical histogram. 
+// The number of classes is NC.
+// The classes XC are computed from NC and the actual output ; X has NC+1 entries.
+// The empirical histogram is the probability that X is the intervals defined by X.
+// The theoretical histogram is computed by differences 
+// of the cumulated probability distribution function.
+// The histograms can be graphically compared with the statements:
+// plot(X(1:$-1),EmpiricalPDF,"bo-"); // Empirical Histogram
+// plot(X(1:$-1),TheoricPDF,"rox-"); // Theoretical Histogram
+//
+
+//
+// In this script, we check the non-uniform random numbers.
+// We use the strategies #2 and #4.
+// The strategy #3 should be used in a future version of the tests (it requires to 
+// develop the kstest function).
+//
+
+rtol = 1.e-2;
+
+// The number of classes in the histogram
+// NC must be even.
+NC = 2*12;
+N=10000;
+
+// Set the seed to always get the same random numbers
+grand("setsd",0);
+
+/////////////////////////////////////////////////////////////
+//
+// 'exp'
+//
+
+function p = mycdfexp(X,A)
+  p = 1 - exp(-(1/A)*X);
+endfunction
+
+A = 20;
+checkMeanVariance1arg ( 400 , 800 , 'exp' , A , A , A^2 , rtol );
+//
+for A = linspace(0.1,50,10)
+  checkLaw1arg ( "exp" , mycdfexp , N , NC , A , 2*rtol );
+end
+
+
+/////////////////////////////////////////////////////////////
+//
+// 'gam'
+//
+
+function p = mycdfgam (X,A,B)
+  p = cdfgam("PQ",X,A*ones(X),B*ones(X));
+endfunction
+
+A = 5;
+B = 3;
+checkMeanVariance2arg ( 400 , 800 , 'gam' , A , B , A/B , A/(B^2) , rtol );
+//
+for A = linspace(1,15,4)
+  for B = linspace(1,15,4)
+    checkLaw2arg ( 'gam' , mycdfgam , N , NC , A , B , rtol );
+  end
+end
+/////////////////////////////////////////////////////////////
+//
+// 'bet'
+//
+
+function p = mycdfbet (X,A,B)
+  p = cdfbet("PQ",X,1-X,A*ones(X),B*ones(X));
+endfunction
+
+A=3;
+B=10;
+checkMeanVariance2arg ( 400 , 800 , 'bet' , A , B , A/(A+B) , (A*B)/((A+B)^2*(A+B+1)) , rtol );
+//
+for A = linspace(1,20,4)
+  for B = linspace(1,20,4)
+    checkLaw2arg ( 'bet' , mycdfbet , N , NC , A , B , 2*rtol );
+  end
+end
+
+/////////////////////////////////////////////////////////////
+//
+// 'poi'
+//
+// Caution : this is a piecewise distribution
+
+function p = mycdfpoi (X,A)
+  p = cdfpoi("PQ",X,A*ones(X));
+endfunction
+
+A = 10;
+checkMeanVariance1arg ( 400 , 800 , 'poi' , A , A , A , rtol );
+//
+for A = floor(linspace(50,70,10))
+  checkPieceLaw1arg ( 'poi' , mycdfpoi , N , NC , A , rtol );
+end
+
+/////////////////////////////////////////////////////////////
+//
+// 'bin'
+//
+// Caution : this is a piecewise distribution
+
+function p = mycdfbin (X,A,B)
+  p = cdfbin("PQ",X,A*ones(X),B*ones(X),(1-B)*ones(X));
+endfunction
+
+A = 10;
+B = 0.4;
+checkMeanVariance2arg ( 400 , 800 , 'bin' , A , B , A*B , A*B*(1-B) , rtol );
+//
+for A = floor(linspace(10,50,4))
+for B = linspace(0.1,0.9,4)
+  checkPieceLaw2arg ( 'bin' , mycdfbin , N , NC , A , B , rtol );
+end
+end
+
+/////////////////////////////////////////////////////////////
+//
+// 'nor'
+//
+
+function p = mycdfnor (X,A,B)
+  p = cdfnor("PQ",X,A*ones(X),B*ones(X));
+endfunction
+
+A = 7;
+B = 12;
+checkMeanVariance2arg ( 400 , 800 , 'nor' , A , B , A , B^2 , rtol );
+//
+//
+for A = linspace(1,20,4)
+  for B = linspace(1,20,4)
+    checkLaw2arg ( 'nor' , mycdfnor , N , NC , A , B , rtol );
+  end
+end
+
+/////////////////////////////////////////////////////////////
+//
+// 'f'
+//
+
+function p = mycdff (X,A,B)
+  p = cdff("PQ",X,A*ones(X),B*ones(X));
+endfunction
+
+//
+// Increase the tolerance for this test.
+A = 7;
+B = 12;
+checkMeanVariance2arg ( 400 , 800 , 'f' , A , B , B/(B-2) , (2*B^2*(A+B-2))/(A*(B-2)^2*(B-4)) , 4*rtol );
+//
+for A = linspace(1,20,4)
+  for B = floor(linspace(5,20,4))
+    checkLaw2arg ( 'f' , mycdff , N , NC , A , B , 2*rtol );
+  end
+end
+
+/////////////////////////////////////////////////////////////
+//
+// 'chi'
+//
+
+function p = mycdfchi (X,A)
+  p = cdfchi("PQ",X,A*ones(X));
+endfunction
+
+A = 7;
+checkMeanVariance1arg ( 400 , 800 , 'chi' , A , A , 2*A , rtol );
+
+// Increase the tolerance for this test.
+for A = floor(linspace(1,20,10))
+    checkLaw1arg ( 'chi' , mycdfchi , N , NC , A , 2*rtol );
+end
+
+/////////////////////////////////////////////////////////////
+//
+// 'nbn'
+//
+// This is a piecewise function.
+
+function p = mycdfnbn (X,A,B)
+  p = cdfnbn("PQ",X,A*ones(X),B*ones(X),(1-B)*ones(X));
+endfunction
+
+A = 7;
+B = 0.1;
+checkMeanVariance2arg ( 400 , 800 , 'nbn' , A , B , A*(1-B)/B , A*(1-B)/B^2 , rtol );
+
+// Increase the tolerance for this test.
+for A = floor(linspace(1,20,4))
+for B = linspace(0.1,0.9,4)
+    checkPieceLaw2arg ( 'nbn' , mycdfnbn , N , NC , A , B , 2*rtol );
+end
+end
+
+/////////////////////////////////////////////////////////////
+//
+// 'nch'
+//
+
+function p = mycdfnch (X,A,B)
+  p = cdfchn("PQ",X,A*ones(X),B*ones(X));
+endfunction
+
+A = 4;
+B = 3;
+checkMeanVariance2arg ( 400 , 800 , 'nch' , A , B , A+B , 2*(A+2*B) , rtol );
+
+for A = floor(linspace(1,20,4))
+for B = floor(linspace(1,20,4))
+    checkLaw2arg ( 'nch' , mycdfnch , N , NC , A , B , 2*rtol );
+end
+end
+/////////////////////////////////////////////////////////////
+//
+// 'nf'
+// http://mathworld.wolfram.com/NoncentralF-Distribution.html
+//
+
+function p = mycdfnf (X,A,B,C)
+  p = cdffnc("PQ",X,A*ones(X),B*ones(X),C*ones(X));
+endfunction
+
+A = 4;
+B = 3;
+C = 10;
+checkMeanVariance3arg ( 400 , 800 , 'nf' , A , B , C , ((C+A)*B)/(A*(B-2)) , [] , 4*rtol );
+
+for A = floor(linspace(1,20,4))
+for B = floor(linspace(1,20,4))
+for C = floor(linspace(1,20,4))
+    checkLaw3arg ( 'nf' , mycdfnf , N , NC , A , B , C , 2*rtol );
+end
+end
+end
+
+/////////////////////////////////////////////////////////////
+//
+// "mn"
+//
+
+n = 2^16;
+A = [1;2;3];
+// The covariance matrix B is symetric, positive definite.
+// Its diagonal entries are [4;6;5], the variances.
+B = [4,2,3;2,6,4;3,4,5];
+  R=grand(n,"mn",A,B);
+  assert_equal ( size(R) , [3,n] );
+  assert_equal ( typeof(R) , "constant" );
+  assert_close ( mean(R,"c") , A , rtol );
+  assert_close ( variance(R,"c") , [4;6;5] , rtol );
+//
+// No CDF for this function => no histogram test. 
+
+/////////////////////////////////////////////////////////////
+//
+// "geom"
+// http://en.wikipedia.org/wiki/Geometric_distribution
+//
+
+A = 0.1;
+checkMeanVariance1arg ( 400 , 800 , "geom" , A , 1/A , (1-A)/A^2 , rtol );
+
+function p = mycdfgeom (X,A)
+  p = 1 -(1-A)^X
+endfunction
+//
+for A = linspace(0.1,0.9,10)
+   checkPieceLaw1arg ( "geom" , mycdfgeom , N , NC , A , 2*rtol );
+end
+
+/////////////////////////////////////////////////////////////
+//
+// "unf"
+// http://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
+//
+
+A = 0.1;
+B = 2.3;
+checkMeanVariance2arg ( 400 , 800 , "unf" , A , B , (A+B)/2 , (B-A)^2/12 , rtol );
+
+function p = mycdfunf (X,A,B)
+  p = (X-A)/(B-A)
+endfunction
+//
+for A = linspace(0.1,0.9,4)
+for B = linspace(2.5,4.2,4)
+   checkLaw2arg ( "unf" , mycdfunf , N , NC , A , B , rtol );
+end
+end
+
+/////////////////////////////////////////////////////////////
+//
+// "uin"
+// http://en.wikipedia.org/wiki/Uniform_distribution_(discrete)
+//
+// Piecewise.
+
+A = 10;
+B = 20;
+checkMeanVariance2arg ( 400 , 800 , "uin" , A , B , (A+B)/2 , ((B-A+1)^2-1)/12 , rtol );
+
+function p = mycdfuin (X,A,B)
+  p = (floor(X)-A+1)/(B-A+1)
+endfunction
+//
+for A = floor(linspace(10,20,4))
+for B = floor(linspace(30,40,4))
+   checkPieceLaw2arg ( "uin" , mycdfuin , N , NC , A , B , rtol );
+end
+end
+
+/////////////////////////////////////////////////////////////
+//
+// "def"
+// http://en.wikipedia.org/wiki/Uniform_distribution_(continuous)
+//
+
+checkMeanVariance0arg ( 400 , 800 , "def" , 1/2 , 1/12 , rtol );
+
+function p = mycdfdef (X)
+  p = X
+endfunction
+//
+checkLaw0arg ( "def" , mycdfdef , N , NC , rtol );
+
+
+
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_laws2.dia.ref b/scilab/modules/randlib/tests/unit_tests/grand_laws2.dia.ref
new file mode 100644 (file)
index 0000000..a995601
--- /dev/null
@@ -0,0 +1,154 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008 - INRIA - Sabine Gaüzere
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+//
+// These tests makes comparisons between the empirical cumulated 
+// distribution function and the theoretical distribution function.
+// They do not make use of the Chi-square distribution function,
+// and, therefore, are not Kolmogorov-Smirnov tests.
+//
+// For each test, we can compare the two plots with the statements :
+// plot(RdevS,PS,"b-"); // Empirical distribution
+// plot(RdevS,P,"ro-"); // Theoretical distribution
+// 
+// Not all distribution functions are tested.
+// Moreover, the comparison is not done for integer-based (piecewise) 
+// distribution functions.
+// This work is to be updated.
+//
+// Set the seed to always get the same random numbers
+grand("setsd",0);
+prec = 1;
+// test for exp 
+for i=linspace(0.1,50,10)
+  N=10000;A=i;
+  Rdev=grand(1,N,'exp',A);
+  RdevS=gsort(Rdev,"g","i")';
+  PS=(1:N)'/N;
+  P=1-exp(-RdevS/A);
+  if norm(P-PS) > 2*prec then bugmes();quit;end
+end
+// test for gamma 
+for i=linspace(1,15,4)
+  for j=linspace(1,15,4)
+    N=10000;A=i;B=j;
+    Rdev=grand(1,N,'gam',A,B); 
+    RdevS=gsort(Rdev,"g","i")';
+    PS=(1:N)'/N;
+    [P]=cdfgam("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
+    if norm(P-PS)> 2*prec then bugmes();quit;end
+  end
+end
+// test for beta random deviate 
+for i=linspace(1,20,4)
+  for j=linspace(1,20,4)
+    N=10000;A=i;B=j;
+    Rdev=grand(1,N,'bet',A,B); 
+    RdevS=gsort(Rdev,"g","i")';
+    PS=(1:N)'/N;
+    [P]=cdfbet("PQ",RdevS,1-RdevS,A*ones(RdevS),B*ones(RdevS));
+    if norm(P-PS)> 2*prec then bugmes();quit;end
+  end
+end
+// test for poi 
+for i=floor(linspace(50,70,10))
+  N=10000;A=i;
+  Rdev=grand(1,N,'poi',A);
+  RdevS=gsort(Rdev,"g","i")';
+  PS=(1:N)'/N;
+  [P]=cdfpoi("PQ",RdevS,A*ones(RdevS));
+  // Need an other test P is piecewize linear and PS
+  // linear
+  //if norm(P-PS) > prec then bugmes();quit;end
+end
+N=100;A=5;B=0.7;
+Rdev=grand(N,N,'bin',A,B); 
+Rdev=matrix(Rdev,1,N^2);
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:(N^2))'/(N^2);
+[P]=cdfbin("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
+//if norm(P-PS) > prec then bugmes();quit;end
+// test for f 
+N=10000;A=1;B=3;
+Rdev=grand(1,N,'f',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdff("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
+if norm(P-PS) > prec then bugmes();quit;end
+// test for mul
+// TODO 
+// test for nor 
+N=10000;A=1;B=2;
+Rdev=grand(1,N,'nor',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdfnor("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
+if norm(P-PS) > prec then bugmes();quit;end
+// test for unf 
+N=10000;A=1;B=2;
+Rdev=grand(1,N,'unf',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=RdevS-A;
+if norm(P-PS) > prec then bugmes();quit;end
+// test for uin ( a finir ) 
+N=10000;A=1;B=10;
+Rdev=grand(1,N,'uin',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=RdevS-A;
+//TODO need an other test
+//if norm(P-PS) > prec then bugmes();quit;end
+// test for lgi 
+// This is a completely wrong test:
+// The output depends on the random number generator...
+N=10000;
+Rdev=grand(1,N,'lgi');
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=RdevS-A;
+//TODO need an other test 
+//if norm(P-PS) > prec then bugmes();quit;end
+// test for nbn 
+N=10000;A=5;B=0.7;
+Rdev=grand(1,N,'nbn',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdfnbn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
+//TODO need an other test 
+//if norm(P-PS) > prec then bugmes();quit;end
+// test for mn 
+// TODO
+// test for 'def'
+N=10000;
+Rdev=grand(1,N,'def');
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=RdevS;
+if norm(P-PS) > prec then bugmes();quit;end
+// test for nch or chn 
+N=10000;A=5;B=4;
+Rdev=grand(1,N,'nch',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdfchn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
+if norm(P-PS) > prec then bugmes();quit;end
+// test for nf or fnc
+N=10000;A=5;B=4;C=10;
+Rdev=grand(1,N,'nf',A,B,C); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdffnc("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),C*ones(RdevS));
+if norm(P-PS) > prec then bugmes();quit;end
+// test for chi 
+N=10000;A=5;
+Rdev=grand(1,N,'chi',A);
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdfchi("PQ",RdevS,A*ones(RdevS));
+if norm(P-PS) > prec then bugmes();quit;end
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_laws2.tst b/scilab/modules/randlib/tests/unit_tests/grand_laws2.tst
new file mode 100644 (file)
index 0000000..8336fe2
--- /dev/null
@@ -0,0 +1,194 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008 - INRIA - Sabine Gaüzere
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+
+//
+// These tests makes comparisons between the empirical cumulated 
+// distribution function and the theoretical distribution function.
+// They do not make use of the Chi-square distribution function,
+// and, therefore, are not Kolmogorov-Smirnov tests.
+//
+// For each test, we can compare the two plots with the statements :
+// plot(RdevS,PS,"b-"); // Empirical distribution
+// plot(RdevS,P,"ro-"); // Theoretical distribution
+// 
+// Not all distribution functions are tested.
+// Moreover, the comparison is not done for integer-based (piecewise) 
+// distribution functions.
+// This work is to be updated.
+//
+
+
+// Set the seed to always get the same random numbers
+grand("setsd",0);
+
+prec = 1;
+
+// test for exp 
+
+for i=linspace(0.1,50,10)
+  N=10000;A=i;
+  Rdev=grand(1,N,'exp',A);
+  RdevS=gsort(Rdev,"g","i")';
+  PS=(1:N)'/N;
+  P=1-exp(-RdevS/A);
+  if norm(P-PS) > 2*prec then pause,end
+end
+
+
+// test for gamma 
+for i=linspace(1,15,4)
+  for j=linspace(1,15,4)
+    N=10000;A=i;B=j;
+    Rdev=grand(1,N,'gam',A,B); 
+    RdevS=gsort(Rdev,"g","i")';
+    PS=(1:N)'/N;
+    [P]=cdfgam("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
+    if norm(P-PS)> 2*prec then pause,end
+  end
+end
+
+
+// test for beta random deviate 
+for i=linspace(1,20,4)
+  for j=linspace(1,20,4)
+    N=10000;A=i;B=j;
+    Rdev=grand(1,N,'bet',A,B); 
+    RdevS=gsort(Rdev,"g","i")';
+    PS=(1:N)'/N;
+    [P]=cdfbet("PQ",RdevS,1-RdevS,A*ones(RdevS),B*ones(RdevS));
+    if norm(P-PS)> 2*prec then pause,end
+  end
+end
+
+// test for poi 
+for i=floor(linspace(50,70,10))
+  N=10000;A=i;
+  Rdev=grand(1,N,'poi',A);
+  RdevS=gsort(Rdev,"g","i")';
+  PS=(1:N)'/N;
+  [P]=cdfpoi("PQ",RdevS,A*ones(RdevS));
+  // Need an other test P is piecewize linear and PS
+  // linear
+  //if norm(P-PS) > prec then pause,end
+end
+
+
+N=100;A=5;B=0.7;
+Rdev=grand(N,N,'bin',A,B); 
+Rdev=matrix(Rdev,1,N^2);
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:(N^2))'/(N^2);
+[P]=cdfbin("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
+//if norm(P-PS) > prec then pause,end
+
+// test for f 
+
+N=10000;A=1;B=3;
+Rdev=grand(1,N,'f',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdff("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
+if norm(P-PS) > prec then pause,end
+
+// test for mul
+// TODO 
+
+// test for nor 
+
+N=10000;A=1;B=2;
+Rdev=grand(1,N,'nor',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdfnor("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
+if norm(P-PS) > prec then pause,end
+
+// test for unf 
+
+N=10000;A=1;B=2;
+Rdev=grand(1,N,'unf',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=RdevS-A;
+if norm(P-PS) > prec then pause,end
+
+// test for uin ( a finir ) 
+
+N=10000;A=1;B=10;
+Rdev=grand(1,N,'uin',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=RdevS-A;
+//TODO need an other test
+//if norm(P-PS) > prec then pause,end
+
+// test for lgi 
+// This is a completely wrong test:
+// The output depends on the random number generator...
+N=10000;
+Rdev=grand(1,N,'lgi');
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=RdevS-A;
+//TODO need an other test 
+//if norm(P-PS) > prec then pause,end
+
+
+
+// test for nbn 
+
+N=10000;A=5;B=0.7;
+Rdev=grand(1,N,'nbn',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdfnbn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),(1-B)*ones(RdevS));
+//TODO need an other test 
+//if norm(P-PS) > prec then pause,end
+
+
+
+// test for mn 
+// TODO
+
+// test for 'def'
+
+N=10000;
+Rdev=grand(1,N,'def');
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=RdevS;
+if norm(P-PS) > prec then pause,end
+
+// test for nch or chn 
+
+N=10000;A=5;B=4;
+Rdev=grand(1,N,'nch',A,B); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdfchn("PQ",RdevS,A*ones(RdevS),B*ones(RdevS));
+if norm(P-PS) > prec then pause,end
+
+// test for nf or fnc
+
+N=10000;A=5;B=4;C=10;
+Rdev=grand(1,N,'nf',A,B,C); 
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdffnc("PQ",RdevS,A*ones(RdevS),B*ones(RdevS),C*ones(RdevS));
+if norm(P-PS) > prec then pause,end
+
+// test for chi 
+
+N=10000;A=5;
+Rdev=grand(1,N,'chi',A);
+RdevS=gsort(Rdev,"g","i")';
+PS=(1:N)'/N;
+[P]=cdfchi("PQ",RdevS,A*ones(RdevS));
+if norm(P-PS) > prec then pause,end
+
+
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_plot.dia.ref b/scilab/modules/randlib/tests/unit_tests/grand_plot.dia.ref
new file mode 100644 (file)
index 0000000..f9edc0a
--- /dev/null
@@ -0,0 +1,111 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008 - INRIA - Sabine Gaüzere
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- TEST WITH GRAPHIC -->
+//
+// These tests makes comparisons between the empirical cumulated 
+// distribution function and the theoretical distribution function.
+// They do not make use of the Chi-square distribution function,
+// and, therefore, are not Kolmogorov-Smirnov tests.
+// The tester is asked to visually compare the two plots, which 
+// cannot be automated.
+//
+//Comparison of pseudo-random numbers following an exponential distribution 
+//and the density of this distribution
+//Parameter of the distribution which can be modified
+lambda=1.6;
+// Number of random variable generated
+N=100000;
+//Generation of a vector of numbers following an exponential distribution
+X = grand(1,N,"exp",lambda);
+clf();
+//Discretisation of the abscisses in classes
+classes = linspace(0,12,25);
+//Draw in histogram
+histplot(classes,X)
+//Draw the density 
+x=linspace(0,12,25);
+y = (1/lambda)*exp(-(1/lambda)*x);
+plot2d(x,y,3);
+f=gcf();
+delete(f);
+//Comparison of pseudo-random numbers following a beta distribution 
+//and the density of this distribution
+//Parameters of the distribution which can be modified
+A=1;B=3;
+// Number of random variable generated
+N=100000;
+//Generation of a vector of numbers following a beta distribution
+X = grand(1,N,"bet",A,B);
+clf();
+//Discretisation of the abscisses in classes
+classes = linspace(0,1,50);
+//Draw in histogram
+histplot(classes,X)
+//Draw the density 
+x=linspace(0,1,50);
+y = (1/(beta(A,B))).*(x^(A-1)).*((1-x)^(B-1)) ;
+plot2d(x,y,2);
+f=gcf();
+delete(f);
+//Comparison of pseudo-random numbers following a gamma distribution 
+//and the density of this distribution
+//Parameters of the distribution which can be modified
+A=2;B=1;
+// Number of random variable generated
+N=100000;
+//Generation of a vector of numbers following a gamma distribution
+X = grand(1,N,"gam",A,B);
+clf();
+//Discretisation of the abscisses in classes
+classes = linspace(0,2,50);
+//Draw in histogram
+histplot(classes,X)
+//Draw the density 
+x=linspace(0,2,50);
+y = (B/(gamma(A))).*exp(-B*x).*(B*x)^(A-1);
+plot2d(x,y,2);
+f=gcf();
+delete(f);
+//Comparison of pseudo-random numbers following a binomial distribution 
+//and the density of this distribution
+//Parameters of the distribution which can be modified
+n=50;p=0.3;
+// Number of random variable generated
+N=100000;
+//Generation of a vector of numbers following a binomial distribution
+X = grand(1,N,"bin",n,p);
+clf();
+//Discretisation of the abscisses in classes
+classes = linspace(0,n,n+1);
+//Draw in histogram
+histplot(classes,X)
+//Draw the density
+x=linspace(0,n,n+1);
+y = binomial(p,n);
+plot2d(x,y,2);
+f=gcf();
+delete(f);
+//Comparison of pseudo-random numbers following a poisson distribution 
+//and the density of this distribution
+//Parameters of the distribution which can be modified
+mu=50;
+// Number of random variable generated
+N=100000;
+//Generation of a vector of numbers following a poisson distribution
+X = grand(1,N,"poi",mu);
+clf();
+//Discretisation of the abscisses in classes
+classes = linspace(0,2*mu,101);
+//Draw in histogram
+histplot(classes,X)
+//Draw the density
+[x]=linspace(0,2*mu,101);
+y = exp(-mu).*(mu^x)./factorial(x);
+plot2d(x,y,2);
+f=gcf();
+delete(f);
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_plot.tst b/scilab/modules/randlib/tests/unit_tests/grand_plot.tst
new file mode 100644 (file)
index 0000000..1c07902
--- /dev/null
@@ -0,0 +1,120 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008 - INRIA - Sabine Gaüzere
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- TEST WITH GRAPHIC -->
+
+//
+// These tests makes comparisons between the empirical cumulated 
+// distribution function and the theoretical distribution function.
+// They do not make use of the Chi-square distribution function,
+// and, therefore, are not Kolmogorov-Smirnov tests.
+// The tester is asked to visually compare the two plots, which 
+// cannot be automated.
+//
+
+//Comparison of pseudo-random numbers following an exponential distribution 
+//and the density of this distribution
+//Parameter of the distribution which can be modified
+lambda=1.6;
+// Number of random variable generated
+N=100000;
+//Generation of a vector of numbers following an exponential distribution
+X = grand(1,N,"exp",lambda);
+clf();
+//Discretisation of the abscisses in classes
+classes = linspace(0,12,25);
+//Draw in histogram
+histplot(classes,X)
+//Draw the density 
+x=linspace(0,12,25);
+y = (1/lambda)*exp(-(1/lambda)*x);
+plot2d(x,y,3);
+f=gcf();
+delete(f);
+
+//Comparison of pseudo-random numbers following a beta distribution 
+//and the density of this distribution
+//Parameters of the distribution which can be modified
+A=1;B=3;
+// Number of random variable generated
+N=100000;
+//Generation of a vector of numbers following a beta distribution
+X = grand(1,N,"bet",A,B);
+clf();
+//Discretisation of the abscisses in classes
+classes = linspace(0,1,50);
+//Draw in histogram
+histplot(classes,X)
+//Draw the density 
+x=linspace(0,1,50);
+y = (1/(beta(A,B))).*(x^(A-1)).*((1-x)^(B-1)) ;
+plot2d(x,y,2);
+f=gcf();
+delete(f);
+
+//Comparison of pseudo-random numbers following a gamma distribution 
+//and the density of this distribution
+//Parameters of the distribution which can be modified
+A=2;B=1;
+// Number of random variable generated
+N=100000;
+//Generation of a vector of numbers following a gamma distribution
+X = grand(1,N,"gam",A,B);
+clf();
+//Discretisation of the abscisses in classes
+classes = linspace(0,2,50);
+//Draw in histogram
+histplot(classes,X)
+//Draw the density 
+x=linspace(0,2,50);
+y = (B/(gamma(A))).*exp(-B*x).*(B*x)^(A-1);
+plot2d(x,y,2);
+f=gcf();
+delete(f);
+
+
+//Comparison of pseudo-random numbers following a binomial distribution 
+//and the density of this distribution
+//Parameters of the distribution which can be modified
+n=50;p=0.3;
+// Number of random variable generated
+N=100000;
+//Generation of a vector of numbers following a binomial distribution
+X = grand(1,N,"bin",n,p);
+clf();
+//Discretisation of the abscisses in classes
+classes = linspace(0,n,n+1);
+//Draw in histogram
+histplot(classes,X)
+//Draw the density
+x=linspace(0,n,n+1);
+y = binomial(p,n);
+plot2d(x,y,2);
+f=gcf();
+delete(f);
+
+//Comparison of pseudo-random numbers following a poisson distribution 
+//and the density of this distribution
+//Parameters of the distribution which can be modified
+mu=50;
+// Number of random variable generated
+N=100000;
+//Generation of a vector of numbers following a poisson distribution
+X = grand(1,N,"poi",mu);
+clf();
+//Discretisation of the abscisses in classes
+classes = linspace(0,2*mu,101);
+//Draw in histogram
+histplot(classes,X)
+//Draw the density
+[x]=linspace(0,2*mu,101);
+y = exp(-mu).*(mu^x)./factorial(x);
+plot2d(x,y,2);
+f=gcf();
+delete(f);
+
+
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_prm.dia.ref b/scilab/modules/randlib/tests/unit_tests/grand_prm.dia.ref
new file mode 100644 (file)
index 0000000..1e3505b
--- /dev/null
@@ -0,0 +1,124 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+//
+// assert_close --
+//   Returns 1 if the two real matrices computed and expected are close,
+//   i.e. if the relative distance between computed and expected is lesser than epsilon.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_close ( computed, expected, epsilon )
+  if expected==0.0 then
+    shift = norm(computed-expected);
+  else
+    shift = norm(computed-expected)/norm(expected);
+  end
+  if shift < epsilon then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then bugmes();quit;end
+endfunction
+//
+// assert_equal --
+//   Returns 1 if the two real matrices computed and expected are equal.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_equal ( computed , expected )
+  if computed==expected then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then bugmes();quit;end
+endfunction
+function flag = assert_true ( computed )
+  if and(computed) then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then bugmes();quit;end
+endfunction
+rtol = 1.e-2;
+// Set the seed to always get the same random numbers
+grand("setsd",0);
+//
+// 1. Permute some vectors, and check that the output is basically correct.
+//
+X = (2:10)';
+P = grand(1,"prm",X);
+assert_equal ( typeof(P) , "constant" );
+assert_equal ( size(P) , size(X) );
+assert_equal ( gsort(P,"g","i") , X );
+//
+X = (10:100)';
+P = grand(1,"prm",X);
+assert_equal ( typeof(P) , "constant" );
+assert_equal ( size(P) , size(X) );
+assert_equal ( gsort(P,"g","i") , X );
+//
+X = [-12 4 9 365]';
+P = grand(1,"prm",X);
+assert_equal ( typeof(P) , "constant" );
+assert_equal ( size(P) , size(X) );
+assert_equal ( gsort(P,"g","i") , X );
+//
+X = (2:11)';
+P = grand(5,"prm",X);
+assert_equal ( typeof(P) , "constant" );
+assert_equal ( size(P) , [10 5] );
+assert_equal ( gsort(P,"r","i") , X * ones(1,5) );
+//
+// 2. Check that the produced permutations are uniformly chosen in the 
+// set of all possible permutations.
+//
+X = [-12 4 9 365]';
+S = perms(X);
+// Total number of permutations : F = 4! = 24
+F = size(S,"r");
+// Number of random permutations : N
+N = 10000;
+P = grand(N,"prm",X);
+// Set in R(k), k=1,2,...,N the index i of the permutation, with i=1,2,...,F.
+// R must be a random variable uniformly distributed in the interval [1,2,...,F].
+R = zeros(N,1);
+for k = 1:N
+  permk = P(:,k);
+  // Search the index i of the permutation permk
+  for i = 1 : F
+    permi = S(i,:);
+    if ( permi'==permk ) then
+      R(k) = i;
+      break
+    end
+  end
+end
+assert_close ( mean(R) , (1+F)/2 , 0.01 );
+assert_close ( variance(R) , (F^2-1)/12 , 0.1 );
+//
+// Check the distribution of R
+function p = mycdfuin (X,A,B)
+  p = (floor(X)-A+1)/(B-A+1)
+endfunction
+X = (1:F)';
+for k = 1 : size(X,"*")
+    EmpicicalPDF(k) = length(find(R==X(k)));
+end
+EmpicicalPDF = EmpicicalPDF./N;
+CDF = mycdfuin(X,1,F);
+TheoricPDF=[CDF(1);diff(CDF)];
+assert_true( abs(EmpicicalPDF-TheoricPDF) < rtol );
+  if ( %f ) then
+    plot(X,EmpicicalPDF,"bo-"); // Empirical PDF
+    plot(X,TheoricPDF,"rox-"); // Theoretical PDF
+  end
diff --git a/scilab/modules/randlib/tests/unit_tests/grand_prm.tst b/scilab/modules/randlib/tests/unit_tests/grand_prm.tst
new file mode 100644 (file)
index 0000000..07f7ac9
--- /dev/null
@@ -0,0 +1,131 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+
+//
+// assert_close --
+//   Returns 1 if the two real matrices computed and expected are close,
+//   i.e. if the relative distance between computed and expected is lesser than epsilon.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_close ( computed, expected, epsilon )
+  if expected==0.0 then
+    shift = norm(computed-expected);
+  else
+    shift = norm(computed-expected)/norm(expected);
+  end
+  if shift < epsilon then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then pause,end
+endfunction
+//
+// assert_equal --
+//   Returns 1 if the two real matrices computed and expected are equal.
+// Arguments
+//   computed, expected : the two matrices to compare
+//   epsilon : a small number
+//
+function flag = assert_equal ( computed , expected )
+  if computed==expected then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then pause,end
+endfunction
+
+function flag = assert_true ( computed )
+  if and(computed) then
+    flag = 1;
+  else
+    flag = 0;
+  end
+  if flag <> 1 then pause,end
+endfunction
+
+rtol = 1.e-2;
+
+// Set the seed to always get the same random numbers
+grand("setsd",0);
+
+//
+// 1. Permute some vectors, and check that the output is basically correct.
+//
+X = (2:10)';
+P = grand(1,"prm",X);
+assert_equal ( typeof(P) , "constant" );
+assert_equal ( size(P) , size(X) );
+assert_equal ( gsort(P,"g","i") , X );
+//
+X = (10:100)';
+P = grand(1,"prm",X);
+assert_equal ( typeof(P) , "constant" );
+assert_equal ( size(P) , size(X) );
+assert_equal ( gsort(P,"g","i") , X );
+//
+X = [-12 4 9 365]';
+P = grand(1,"prm",X);
+assert_equal ( typeof(P) , "constant" );
+assert_equal ( size(P) , size(X) );
+assert_equal ( gsort(P,"g","i") , X );
+//
+X = (2:11)';
+P = grand(5,"prm",X);
+assert_equal ( typeof(P) , "constant" );
+assert_equal ( size(P) , [10 5] );
+assert_equal ( gsort(P,"r","i") , X * ones(1,5) );
+//
+// 2. Check that the produced permutations are uniformly chosen in the 
+// set of all possible permutations.
+//
+X = [-12 4 9 365]';
+S = perms(X);
+// Total number of permutations : F = 4! = 24
+F = size(S,"r");
+// Number of random permutations : N
+N = 10000;
+P = grand(N,"prm",X);
+// Set in R(k), k=1,2,...,N the index i of the permutation, with i=1,2,...,F.
+// R must be a random variable uniformly distributed in the interval [1,2,...,F].
+R = zeros(N,1);
+for k = 1:N
+  permk = P(:,k);
+  // Search the index i of the permutation permk
+  for i = 1 : F
+    permi = S(i,:);
+    if ( permi'==permk ) then
+      R(k) = i;
+      break
+    end
+  end
+end
+assert_close ( mean(R) , (1+F)/2 , 0.01 );
+assert_close ( variance(R) , (F^2-1)/12 , 0.1 );
+//
+// Check the distribution of R
+function p = mycdfuin (X,A,B)
+  p = (floor(X)-A+1)/(B-A+1)
+endfunction
+X = (1:F)';
+for k = 1 : size(X,"*")
+    EmpicicalPDF(k) = length(find(R==X(k)));
+end
+EmpicicalPDF = EmpicicalPDF./N;
+CDF = mycdfuin(X,1,F);
+TheoricPDF=[CDF(1);diff(CDF)];
+assert_true( abs(EmpicicalPDF-TheoricPDF) < rtol );
+  if ( %f ) then
+    plot(X,EmpicicalPDF,"bo-"); // Empirical PDF
+    plot(X,TheoricPDF,"rox-"); // Theoretical PDF
+  end
+
+
diff --git a/scilab/modules/randlib/tests/unit_tests/grandb.sci b/scilab/modules/randlib/tests/unit_tests/grandb.sci
deleted file mode 100644 (file)
index c339ae7..0000000
+++ /dev/null
@@ -1,59 +0,0 @@
-function tstbot()
-       // Copyright INRIA
-       //**********************************************************************
-       //     A test program for the bottom level routines
-       //     Scilab implementation of tstbot.f 
-       //**********************************************************************
-       NB=10
-       NR=1000
-       answer=ones(NB,NR);
-       genlst=[1,5,10,20,32]
-       nbad = 0
-       str=['For five virtual generators of the 101';...
-       ' This test generates'+string(NB)+' numbers then resets the block';...
-       '      and does it again';...
-       ' Any disagreements are reported -- there should be none'];
-       write (%io(2),str)
-       //
-       //     Set up Generators
-       //
-       grand('setall',12345,54321,6789,9876);
-       //
-       //     For a selected set of generators
-       //
-       for ixgen = 1:5
-       igen = genlst(ixgen)
-       grand('setcgn',igen);
-       write(%io(2),' Testing generator '+string(igen));
-       //
-       //     Use NB blocks
-       //
-       grand('initgn',-1);
-       SD=grand('getsd');iseed1=SD(1);iseed2=SD(2);
-       for iblock = 1:NB
-               //     Generate NR numbers
-               answer(iblock,1:NR)= grand(1,NR,'lgi');
-               grand('initgn',1);
-       end 
-       grand('initgn',-1);
-       //
-       //     Do it again and compare answers
-       //
-       SD=grand('getsd');iseed1=SD(1);iseed2=SD(2);
-       //
-       //     Use NB blocks
-       //
-       for iblock = 1:NB
-               //     Generate NR numbers
-               itmp = grand(1,NR,'lgi');
-               if itmp<>answer(iblock,:) then 
-                       str=[' Disagreement on regeneration of numbers';...
-                       ' Block '+string(iblock)+' N within Block '];
-                       write(%io(2),str);
-               end
-               grand('initgn',1);
-       end
-       write (%io(2), ' Finished testing generator '+string(igen));
-       write (%io(2), ' Test completed successfully');
-       end
-endfunction
\ No newline at end of file