Average.h

#ifndef UTIL_AVERAGE_H
#define UTIL_AVERAGE_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/global.h>
#include <util/accumulators/AverageStage.h>  // base class
#include <util/param/ParamComposite.h>       // base class
 
#include <vector>
 
namespace Util
{
 
   class Average : public AverageStage, public ParamComposite
   {
 
   public:
 
      Average(int blockFactor = 2);
 
      virtual ~Average();
 
      void readParameters(std::istream& in);
 
      void setNSamplePerBlock(int nSamplePerBlock);
 
      virtual void loadParameters(Serializable::IArchive &ar);
 
      virtual void save(Serializable::OArchive &ar);
 
      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
      void clear();
 
      void sample(double value);
 
      void sample(double value, std::ostream& out);
 
      void output(std::ostream& out) const;
 
      double blockingError() const;
 
      int nSamplePerBlock() const;
 
      int iBlock() const;
 
      bool isBlockComplete() const;
   
      /*
      * Get current block average value.
      *
      * \throw Exception if block is empty, or blocking disabled.
      */
      double blockAverage() const;
 
   private:
 
      virtual void registerDescendant(AverageStage* descendantPtr);
 
      std::vector<AverageStage*> descendants_;
 
      double blockSum_;
 
      int iBlock_;
 
      int nSamplePerBlock_;
 
      Average(const Average& other);
 
      Average& operator = (const Average& other);
 
   };
 
   // Inline method definitions
 
   #if 0
   /*
   * Add a sampled value to the ensemble, and output block averages.
   */
   inline void Average::sample(double value, std::ostream& out)
   {  sample(value, &out); }
   #endif
 
   /*
   * Get nSamplePerBlock, number of samples per block average.
   */
   inline int Average::nSamplePerBlock() const
   {  return nSamplePerBlock_; }
 
   /*
   * Get iBlock, number of samples in current block average.
   */
   inline int Average::iBlock() const
   {  return iBlock_; }
 
   /*
   * Is the current block average complete?
   */
   inline bool Average::isBlockComplete() const
   { 
      return (iBlock_ && (iBlock_ == nSamplePerBlock_));
   }
 
   /*
   * Get current block average.
   */
   inline double Average::blockAverage() const
   {
      if (iBlock_ == 0) {
         UTIL_THROW("Attempt to get block average with no data");
      }
      return blockSum_/double(iBlock_);
   }
 
   /*
   * Serialize this Average.
   */
   template <class Archive>
   void Average::serialize(Archive& ar, const unsigned int version)
   {
      AverageStage::serialize(ar, version);
      ar & blockSum_;
      ar & iBlock_;
      ar & nSamplePerBlock_;
   }
 
}
#endif