RandomNumbers.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2010 by Federico Marulli                          *
 *  federico.marulli3@unibo.it                                      *
 *                                                                  *
 *  This program is free software; you can redistribute it and/or   *
 *  modify it under the terms of the GNU 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 General Public License for more details.                    *
 *                                                                  *
 *  You should have received a copy of the GNU 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.       *
 ********************************************************************/
 
#ifndef __RANNUM__
#define __RANNUM__ 
 
 
#include "FFTlog.h"
 
 
// =====================================================================================
 
 
namespace cbl {
 
  typedef std::function<double(double, std::shared_ptr<void>, std::vector<double>)> distribution_func;
 
  typedef std::function<double(std::vector<double>, std::shared_ptr<void>)> nDim_distribution_func;
 
  namespace random {
 
    class RandomNumbers
    {
    protected:
 
      std::mt19937_64 m_generator;
 
      int m_seed;
 
      double m_MinVal;
 
      double m_MaxVal;
 
    public:
 
      RandomNumbers () = default;
      
      RandomNumbers (const int seed, const double MinVal = par::defaultDouble, const double MaxVal = -par::defaultDouble);
 
      virtual ~RandomNumbers () = default;
 
 
      virtual double operator () () = 0;
 
      void set_seed (const int seed);
 
      void set_range (const double MinVal, const double MaxVal);
 
      void set_value (const double value) 
      { (void)value; ErrorCBL("error!", "set_value", "RandomNumbers.h"); }
 
      virtual void set_mean (const double mean)
      { (void)mean; ErrorCBL("error!", "set_mean", "RandomNumbers.h"); }
 
      virtual void set_mean_sigma (const double mean, const double sigma)
      { (void)mean; (void)sigma; ErrorCBL("error!", "set_mean_sigma", "RandomNumbers.h"); }
 
      virtual void set_discrete_values (const std::vector<double> values, const std::vector<double> weights)
      { (void)values; (void)weights; ErrorCBL("error!", "set_discrete_values", "RandomNumbers.h"); }
 
      virtual void set_interpolated_distribution (const std::vector<double> values, const std::vector<double> weights)
      { (void)values; (void)weights; ErrorCBL("error!", "set_interpolated_distribution", "RandomNumbers.h"); }
 
      virtual void set_custom_distribution (const distribution_func func, const std::shared_ptr<void> modelInput, const std::vector<double> parameter)
      { (void)func; (void)modelInput; (void)parameter; ErrorCBL("error!", "set_custom_distribution", "RandomNumbers.h"); }
 
    };
 
    class ConstantRandomNumbers : public RandomNumbers
    {
    protected:
 
      double m_value;
 
    public:
 
      ConstantRandomNumbers (const double value) : RandomNumbers(1)
      {
    m_value = value;
      }
 
      ~ConstantRandomNumbers () = default; 
 
      void set_value(const double value)
      { m_value = value; }
 
      double operator () ()
      {
    return m_value;
      }
 
    };
 
    
    class UniformRandomNumbers : public RandomNumbers
    {
    protected:
 
      std::shared_ptr<std::uniform_real_distribution<double>> m_distribution;
 
    public:
 
      UniformRandomNumbers (double MinVal, const double MaxVal, const int seed);
 
      ~UniformRandomNumbers () = default; 
 
      double operator () ();
    };
 
    
    class UniformRandomNumbers_Int : public RandomNumbers
    {
    protected:
 
      std::shared_ptr<std::uniform_int_distribution<int>> m_distribution;
 
    public:
 
      UniformRandomNumbers_Int (double MinVal, const double MaxVal, const int seed);
 
      ~UniformRandomNumbers_Int () = default; 
 
      double operator () ();
    };
 
    
    class PoissonRandomNumbers : public RandomNumbers
    {
      
    protected:
 
      double m_mean;
 
      std::shared_ptr<std::poisson_distribution<int> > m_distribution;
 
    public:
      
      PoissonRandomNumbers (const double mean, const int seed, const double MinVal = par::defaultDouble, const double MaxVal = -par::defaultDouble);
 
      ~PoissonRandomNumbers () = default;
 
      void set_mean (const double mean);
 
      double operator () ();
    };
 
    
    class NormalRandomNumbers : public RandomNumbers
    {
      
    protected:
 
      double m_mean;
 
      double m_sigma;
 
      std::shared_ptr<std::normal_distribution<double>> m_distribution;
 
    public:
 
      NormalRandomNumbers (const double mean, const double sigma, const int seed, const double MinVal = par::defaultDouble, const double MaxVal = -par::defaultDouble);
 
      ~NormalRandomNumbers () = default;
 
      void set_mean_sigma (const double mean, const double sigma);
 
      double operator () ();
    };
 
    
    class DiscreteRandomNumbers : public RandomNumbers
    {
      
    protected:
      
      std::vector<double> m_values;
 
      std::vector<double> m_weights;
 
      std::shared_ptr<std::discrete_distribution<int>> m_distribution;
 
    public:
 
      DiscreteRandomNumbers (const std::vector<double> values, const std::vector<double> weights, const int seed, const double MinVal = par::defaultDouble, const double MaxVal = -par::defaultDouble);
 
      ~DiscreteRandomNumbers () = default;
 
      void set_discrete_values (const std::vector<double> values, const std::vector<double> weights);
 
      double operator () ();
      
    };
 
    
    class DistributionRandomNumbers : public RandomNumbers
    {
 
    protected:
 
      std::shared_ptr<UniformRandomNumbers> m_uniform_generator;
 
      std::shared_ptr<glob::FuncGrid> m_distribution;
 
    public:
 
      DistributionRandomNumbers (const std::vector<double> xx, const std::vector<double> distribution_function, const std::string interpolation_method, const int seed);
 
      ~DistributionRandomNumbers () = default;
 
      void set_seed (const int seed);
 
      void set_interpolated_distribution (const std::vector<double> xx, const std::vector<double> distribution_function, const std::string interpolation_method);
 
      double operator () ();
    };
 
    class CustomDistributionRandomNumbers : public RandomNumbers
    {
 
    protected:
 
      std::shared_ptr<UniformRandomNumbers> m_uniform_generator;
 
      distribution_func m_func;
 
      std::vector<double> m_func_parameter;
      
      std::shared_ptr<void> m_func_modelInput;
 
      double m_normalization;
 
    public:
 
      CustomDistributionRandomNumbers (const distribution_func func, const std::shared_ptr<void> modelInput, const std::vector<double> parameter, const int seed, const double MinVal = par::defaultDouble, const double MaxVal = -par::defaultDouble);
 
      ~CustomDistributionRandomNumbers () = default;
 
      void set_seed (const int seed);
 
      void set_custom_distribution (const distribution_func func, const std::shared_ptr<void> modelInput, const std::vector<double> parameter);
 
      double operator () ();
 
    };
 
  }
}
 
#endif