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