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