Distribution.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2014 by Federico Marulli and Alfonso Veropalumbo  *
 *  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 __DISTR__
#define __DISTR__
 
#include "Data2D_extra.h"
#include "Func.h"
 
 
// ===================================================================================================
 
 
namespace cbl {
 
  namespace glob {
 
    enum class DistributionType {
 
      _Constant_,
 
      _Uniform_,
 
      _Gaussian_,
 
      _Poisson_,
 
      _Custom_,
 
      _Interpolated_,
 
      _Discrete_
 
    };
 
    inline std::vector<std::string> DistributionTypeNames () { return {"Constant", "Uniform", "Gaussian", "Poisson", "Custom", "Interpolated", "Discrete"}; }
 
    inline DistributionType DistributionTypeCast (const int distributionTypeIndex) { return castFromValue<DistributionType>(distributionTypeIndex); }
 
    inline DistributionType DistributionTypeCast (const std::string distributionTypeName) { return castFromName<DistributionType>(distributionTypeName, DistributionTypeNames()); }
 
    inline std::vector<DistributionType> DistributionTypeCast (const std::vector<int> distributionTypeIndeces) { return castFromValues<DistributionType>(distributionTypeIndeces); } 
 
    inline std::vector<DistributionType> DistributionTypeCast (const std::vector<std::string> distributionTypeNames) { return castFromNames<DistributionType>(distributionTypeNames, DistributionTypeNames()); }
 
    
    class Distribution {
          
    protected:
 
      DistributionType m_distributionType;
 
      distribution_func m_func;
 
      std::shared_ptr<random::RandomNumbers> m_distribution_random;
 
      double m_xmin;
 
      double m_xmax;
 
      std::vector<double> m_distribution_func_pars;
 
      std::shared_ptr<void> m_distribution_func_fixed_pars;
 
      double m_distribution_normalization;
      
      double m_log_distribution_normalization;
 
      double m_mean;
 
      double m_variance;
      
      double m_sigma;
 
      int m_seed;
 
      void m_set_distribution_normalization ();
 
      double m_moments_integrator (const double xx, const unsigned int order)
      { return this->operator()(xx)*pow(xx, order); }
 
      double m_central_moments_integrator (const double xx, const unsigned int order)
      { return this->operator()(xx)*pow(xx-m_mean, order); }
 
      double m_percentile_integrator (const double xx);
 
    public:
 
 
      Distribution () : Distribution (DistributionType::_Uniform_, 0., 0.) {}
 
      Distribution (const DistributionType distributionType, const double value);
 
      Distribution (const DistributionType distributionType, const double xmin, const double xmax, const int seed=3213);
 
      Distribution (const DistributionType distributionType, const std::vector<double> distribution_params, const double xmin, const double xmax, const int seed=1);
 
      Distribution (const DistributionType distributionType, const distribution_func func, const std::shared_ptr<void> distribution_fixed_pars, const std::vector<double> distribution_pars, const double xmin, const double xmax, const int seed=1);
 
      Distribution (const DistributionType distributionType, const std::vector<double> discrete_values, const std::vector<double> weights, const int seed=1);
 
      Distribution (const DistributionType distributionType, const std::vector<double> var, const std::vector<double> dist, const int nbin, const std::string interpolationType, const int seed=1);
 
      ~Distribution () = default;
 
 
      DistributionType distributionType () const
      {
    return m_distributionType;
      }
 
      double operator () (double xx);
 
      double log_distribution (double xx);
 
      void set_seed (const int seed) {m_distribution_random->set_seed(seed);}
 
      void set_limits (const double xmin, const double xmax);
 
      void set_constant_distribution (const double value);
 
      void set_uniform_distribution (const double xmin, const double xmax, const int seed=1);
 
      void set_gaussian_distribution (const double mean, const double sigma, const int seed=1);
 
      void set_poisson_distribution (const double mean, const int seed=1);
 
      void set_custom_distribution (const distribution_func func, const std::shared_ptr<void> distribution_fixed_pars, const std::vector<double> distribution_pars, const int seed=1);
 
      void set_discrete_values (const std::vector<double> discrete_values, const std::vector<double> weights, const int seed=1);
 
      void set_binned_distribution (const std::vector<double> var, const std::vector<double> dist, const std::string interpolationType="Spline", const int seed=1);
 
      double xmin () const { return m_xmin; }
 
      double xmax () const { return m_xmax; }
 
      double get_mean () const { return m_mean; }
 
      double get_sigma () const { return m_sigma; }
 
      double get_seed () const { return m_seed; }
 
      double distribution_range () const {return (xmax()-xmin());}
 
      bool isIncluded (const double value) const;
 
      double sample () const;
 
      double sample (const int seed);
 
      std::vector<double> sample_vector (const int nvalues);
 
      double mean ();
 
      double variance ();
 
      double std ();
 
      double skewness ();
 
      double kurtosis ();
 
      std::vector<double> moments ();
 
      double median () { return percentile(50); }
 
      double percentile (const unsigned int i);
 
      double mode ();
 
      void get_distribution (std::vector<double> &xx, std::vector<double> &fx, std::vector<double> &err, const std::vector<double> FF, const std::vector<double> WW, const int nbin, const bool linear=true, const std::string file_out=par::defaultString, const double fact=1., const double V1=par::defaultDouble, const double V2=par::defaultDouble, const bool bin_type=true, const bool conv=false, const double sigma=0.);
 
    };
  }
}
 
#endif