STK_RandBase.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2007  Serge Iovleff

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, write to the
    Free Software Foundation, Inc.,
    59 Temple Place,
    Suite 330,
    Boston, MA 02111-1307
    USA

    Contact : Serge.Iovleff@stkpp.org
*/

/*
 * Project:  Laws
 * Purpose:  Main pseudo-random uniform, gaussian and exponentiel
 *           generators.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 **/

#ifndef STK_RANDBASE_H
#define STK_RANDBASE_H

#include "../../STKernel/include/STK_Misc.h"
#include "../../STKernel/include/STK_Integer.h"
#include "../../STKernel/include/STK_Real.h"

#include "../../Sdk/include/STK_ITContainer1D.h"

// MersenneTwister header.
#include "MersenneTwister.h"

namespace STK
{
class RandBase : protected MTRand
{
  private:

    /*  Gauss parameters.                                             */
    const Integer gsize_;

    const Real    glimit_;

    const Real    gvol_;

    Real *kn, *wn, *fn;

  public:
    RandBase( const Real    &glimit = 3.442619855899
            , const Real    &gvol   = 9.91256303526217e-3
            , Integer const& gsize  = 128
            );

    RandBase( Integer const& oneSeed
            , const Real    &glimit = 3.442619855899
            , const Real    &gvol   = 9.91256303526217e-3
            , Integer const& gsize  = 128
            );

    template< class TContainer1D>
    RandBase( const ITContainer1D<Integer, TContainer1D> &bigSeed
            , const Real    &glimit = 3.442619855899
            , const Real    &gvol   = 9.91256303526217e-3
            , Integer const& gsize  = 128
            )
            : gsize_(gsize)
            , glimit_(glimit)
            , gvol_(gvol)
    {
      // dimension
      Integer first = bigSeed.first(), last = bigSeed.last()
            , size = bigSeed.size();
      uint32 arraySeed[size];
      // cast Integer in uint32
      for (Integer i=first; i<=last; i++)
      {
        arraySeed[i-first] = uint32(bigSeed[i]);
      }
      // Re-seeding functions with same behavior as initializers
      seed(arraySeed, size);
      // initialize zigourat method for gaussian random generator
      gaussInit();
    }

    ~RandBase();

    inline Integer randDiscreteUnif()
    { return Integer(randInt());}

    inline Real randUnif()
    { return Real(randDblExc());}

   inline Real operator()()
   { return randUnif(); }

    Real randGauss(Real const& mu = 0, Real const& sigma = 1);

    Real randExp();

    template< class TContainer1D>
    inline void randDiscreteUnif(ITContainer1D<Integer, TContainer1D>& A)
    { for (Integer i=A.first(); i<=A.last(); i++)
        A[i] = randDiscreteUnif();
    }

    template< class TContainer1D>
    inline void randUnif(ITContainer1D<Real, TContainer1D>& A)
    { for (Integer i=A.first(); i<=A.last(); i++)
        A[i] = randUnif();
    }

    template< class TContainer1D>
    inline void randGauss(ITContainer1D<Real , TContainer1D>& A)
    { for (Integer i=A.first(); i<=A.last(); i++)
        A[i] = randGauss();
    }

    template< class TContainer1D>
    inline void randExp(ITContainer1D<Real , TContainer1D>& A)
    { for (Integer i=A.first(); i<=A.last(); i++)
        A[i] = randExp();
    }

  private:
    void gaussInit();
};

} // namespace STK

#endif //STK_RANDBASE_H