AverageStage.h

#ifndef UTIL_AVERAGE_STAGE_H
#define UTIL_AVERAGE_STAGE_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>
 
namespace Util
{
 
   class AverageStage
   {
 
   public:
 
      AverageStage(int blockFactor = 2);
 
      virtual ~AverageStage();
 
      void setBlockFactor(int blockFactor);
 
      virtual void clear();
 
      virtual void sample(double value);
 
      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
 
 
      double average() const;
 
      double variance() const;
 
      double stdDeviation() const;
 
      double error() const;
 
      long nSample() const;
 
      long stageInterval() const;
 
 
   protected:
 
      bool hasChild() const;
 
      AverageStage& child();
 
   private:
 
      double sum_;
 
      double sumSq_;
 
      double blockSum_;
 
      long nSample_;
 
      long nBlockSample_;
 
      long stageInterval_;
 
      AverageStage* childPtr_;
 
      AverageStage* rootPtr_;
 
      int stageId_;
 
      int blockFactor_;
 
      AverageStage(long stageInterval, int stageId, 
                   AverageStage* rootPtr, int blockFactor);
 
      AverageStage(const AverageStage& other);
 
      AverageStage& operator = (const AverageStage& other);
 
      virtual void registerDescendant(AverageStage* descendantPtr);
 
   };
 
   // Inline methods
 
   /*
   * Does this object have a child?  (protected)
   */
   inline bool AverageStage::hasChild() const
   { return bool(childPtr_); }
 
   /*
   * Return child object by reference. (protected)
   */
   inline AverageStage& AverageStage::child()
   { return *childPtr_; }
 
   // Method template
 
   /*
   * Serialize this stage.
   */
   template <class Archive>
   void AverageStage::serialize(Archive& ar, const unsigned int version)
   {
      ar & sum_;
      ar & sumSq_;
      ar & blockSum_;
      ar & nSample_;
      ar & nBlockSample_;
      ar & stageInterval_;
      ar & blockFactor_;
 
      // Does this stage have a child?
      int hasChild;
      if (Archive::is_saving()) {
         hasChild = (childPtr_ == 0) ? 0 : 1;
      }
      ar & hasChild;
 
      // Serialize child (if any)
      if (hasChild) {
         if (Archive::is_loading()) {
            long nextStageInterval = stageInterval_*blockFactor_;
            int  nextStageId = stageId_ + 1;
            childPtr_ = new AverageStage(nextStageInterval, nextStageId,
                                         rootPtr_, blockFactor_);
            rootPtr_->registerDescendant(childPtr_);
         }
         ar & (*childPtr_);
      } else {
         if (Archive::is_loading()) {
            childPtr_ = 0;
         }
      }
 
   }
 
}
#endif