Distribution.h

#ifndef UTIL_DISTRIBUTION_H
#define UTIL_DISTRIBUTION_H

/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include <util/param/ParamComposite.h>  // base class
#include <util/containers/DArray.h>     // member template
#include <util/math/feq.h>              // Used in serialize template

namespace Util
{

   class Distribution : public ParamComposite 
   {
   
   public:
  
      Distribution();
   
      Distribution(const Distribution& other);
   
      Distribution& operator = (const Distribution& other);
   
      virtual ~Distribution();
   
      virtual void readParameters(std::istream& in);
  
      void setParam(double min, double max, int nBin);
   
      virtual void loadParameters(Serializable::IArchive &ar);
   
      virtual void save(Serializable::OArchive &ar);
   
      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);

      void sample(double value);
   
      virtual void clear();
   
      void output(std::ostream& out);
  
      int binIndex(double value) const;
  
      double min() const;
  
      double max() const;
    
      double binWidth() const;
  
      int nBin() const;

      #ifdef UTIL_MPI

      void reduce(MPI::Intracomm& communicator, int root);
      #endif
        
   protected:
   
      DArray<long> histogram_;  
      double  min_;             
      double  max_;             
      double  binWidth_;        
      int     nBin_;            
      int     nSample_;         
      int     nReject_;         
   
   };

   // inline method definitions 
  
   /*
   * Return the index of the bin for a value.
   */
   inline int Distribution::binIndex(double value) const
   { return int( (value - min_)/binWidth_ ); }
  
   /*
   * Get minimum value in range of histogram.
   */
   inline double Distribution::min() const
   {  return min_; }
  
   /*
   * Get maximum value in range of histogram.
   */
   inline double Distribution::max() const
   {  return max_; }
 
   /*
   * Get binWidth, the width of each bin.
   */
   inline double Distribution::binWidth() const
   {  return binWidth_; }
  
   /*
   * Get the number of bins
   */
   inline int Distribution::nBin() const
   {  return nBin_; }

   /*
   * Serialize this Distribution.
   */
   template <class Archive>
   void Distribution::serialize(Archive& ar, const unsigned int version)
   {
      ar & min_;        
      ar & max_;    
      ar & nBin_;     
      ar & nSample_;   
      ar & nReject_;    
      ar & binWidth_;  
      ar & histogram_; 

      // Validate
      if (histogram_.capacity() != nBin_) {
         UTIL_THROW("Inconsistent histogram capacity");
      }
      if (!feq(binWidth_, (max_ - min_)/double(nBin_))) {
         UTIL_THROW("Inconsistent binWidth");
      }
   }

}
#endif