.. _program_listing_file_include_gwmodelpp_GWAverage.h:

Program Listing for File GWAverage.h
====================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_gwmodelpp_GWAverage.h>` (``include/gwmodelpp/GWAverage.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef GWAVERAGE_H
   #define GWAVERAGE_H
   
   #include "SpatialMonoscaleAlgorithm.h"
   #include "IMultivariableAnalysis.h"
   #include "IParallelizable.h"
   
   namespace gwm
   {
   
   class GWAverage : public SpatialMonoscaleAlgorithm, public IMultivariableAnalysis, public IParallelizable, public IParallelOpenmpEnabled
   {
   public:
   
       static arma::vec del(arma::vec x, arma::uword rowcount);
   
       static arma::vec rank(arma::vec x)
       {
           arma::vec n = arma::linspace(0.0, (double)x.n_rows - 1, x.n_rows);
           arma::vec res = n(sort_index(x));
           return n(sort_index(res)) + 1.0;
       }
   
       typedef void (GWAverage::*SummaryCalculator)();  
   
   protected:
       static arma::vec findq(const arma::mat& x, const arma::vec& w);
   
   public:
       
       GWAverage() {}
       
       GWAverage(const arma::mat x, const arma::mat coords, const SpatialWeight& spatialWeight)
           : SpatialMonoscaleAlgorithm(spatialWeight, coords)
       {
           mX = x;
       }
   
       ~GWAverage() {}
   
   public:
   
       bool quantile() const { return mQuantile; }
   
       void setQuantile(bool quantile) { mQuantile = quantile; }
   
       const arma::mat& localMean() const { return mLocalMean; }
       
       const arma::mat& localSDev() const { return mStandardDev; }
       
       const arma::mat& localSkewness() const { return mLocalSkewness; }
       
       const arma::mat& localCV() const { return mLCV; }
       
       const arma::mat& localVar() const { return mLVar; }
   
       
       const arma::mat& localMedian() const { return mLocalMedian; }
       
       const arma::mat& iqr() const { return mIQR; }
       
       const arma::mat& qi() const { return mQI; }
   
   public:     // SpatialAlgorithm interface
       bool isValid() override;
   
   public:     // IMultivariableAnalysis
       const arma::mat& variables() const override { return mX; }
       
       void setVariables(const arma::mat& x) override { mX = x; }
   
       void run() override;
       
       void calibration(const arma::mat& locations, const arma::mat& x);
   
       void createCalibrationDistanceParameter(const arma::mat& locations);
   
   public:     // IParallelizable
       int parallelAbility() const override
       {
           return ParallelType::SerialOnly
   #ifdef ENABLE_OPENMP
               | ParallelType::OpenMP
   #endif        
               ;
       }
       ParallelType parallelType() const override { return mParallelType; }
   
       void setParallelType(const ParallelType& type) override;
   
   public:     // IParallelOpenmpEnabled
   
       void setOmpThreadNum(const int threadNum) override { mOmpThreadNum = threadNum; }
   
       void updateCalculator();
   
   private:
       void GWAverageSerial();
   
   #ifdef ENABLE_OPENMP
       void GWAverageOmp();
   #endif
   
   
   private:
       bool mQuantile = false;             
   
       arma::mat mX;             
       arma::mat mLocalMean;     
       arma::mat mStandardDev;   
       arma::mat mLocalSkewness; 
       arma::mat mLCV;           
       arma::mat mLVar;          
       arma::mat mLocalMedian;   
       arma::mat mIQR;           
       arma::mat mQI;            
   
       SummaryCalculator mSummaryFunction = &GWAverage::GWAverageSerial;  
       ParallelType mParallelType = ParallelType::SerialOnly;  
       int mOmpThreadNum = 8;                                  
   };
   
   }
   
   
   #endif  // GWAVERAGE_H