.. _program_listing_file_include_gwmodelpp_GWSS.h:

Program Listing for File GWSS.h
===============================

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

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

.. code-block:: cpp

   
   #ifndef GWSS_H
   #define GWSS_H
   
   #include "SpatialMonoscaleAlgorithm.h"
   #include "IMultivariableAnalysis.h"
   #include "IParallelizable.h"
   
   namespace gwm
   {
   
   class GWSS : public SpatialMonoscaleAlgorithm, public IMultivariableAnalysis, public IParallelizable, public IParallelOpenmpEnabled
   {
   public:
   
       static double covwt(const arma::mat &x1, const arma::mat &x2, const arma::vec &w)
       {
           return sum((sqrt(w) % (x1 - sum(x1 % w))) % (sqrt(w) % (x2 - sum(x2 % w)))) / (1 - sum(w % w));
       }
   
       static double corwt(const arma::mat &x1, const arma::mat &x2, const arma::vec &w)
       {
           return covwt(x1,x2,w)/sqrt(covwt(x1,x1,w)*covwt(x2,x2,w));
       }
   
       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 (GWSS::*SummaryCalculator)();  
   
   protected:
       static arma::vec findq(const arma::mat& x, const arma::vec& w);
   
   public:
       
       GWSS() {}
       
       GWSS(const arma::mat x, const arma::mat coords, const SpatialWeight& spatialWeight)
           : SpatialMonoscaleAlgorithm(spatialWeight, coords)
       {
           mX = x;
       }
   
       ~GWSS() {}
   
       bool quantile() const { return mQuantile; }
   
       void setQuantile(bool quantile) { mQuantile = quantile; }
   
       bool isCorrWithFirstOnly() const { return mIsCorrWithFirstOnly; }
   
       void setIsCorrWithFirstOnly(bool corrWithFirstOnly) { mIsCorrWithFirstOnly = corrWithFirstOnly; }
   
       arma::mat localMean() const { return mLocalMean; }
       
       arma::mat localSDev() const { return mStandardDev; }
       
       arma::mat localSkewness() const { return mLocalSkewness; }
       
       arma::mat localCV() const { return mLCV; }
       
       arma::mat localVar() const { return mLVar; }
   
       
       arma::mat localMedian() const { return mLocalMedian; }
       
       arma::mat iqr() const { return mIQR; }
       
       arma::mat qi() const { return mQI; }
   
       
       arma::mat localCov() const { return mCovmat; }
       
       arma::mat localCorr() const { return mCorrmat; }
       
       arma::mat localSCorr() const { return mSCorrmat; }
   
   public:     // SpatialAlgorithm interface
       bool isValid() override;
   
   public:     // IMultivariableAnalysis
       arma::mat variables() const override { return mX; }
       void setVariables(const arma::mat& x) override { mX = x; }
       void run() override;
   
   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; }
   
   private:
   
       void summarySerial();
   
   #ifdef ENABLE_OPENMP
   
       void summaryOmp();
   #endif
   
   private:
       bool mQuantile = false;             
       bool mIsCorrWithFirstOnly = 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;            
       arma::mat mCovmat;        
       arma::mat mCorrmat;       
       arma::mat mSCorrmat;      
       
       SummaryCalculator mSummaryFunction = &GWSS::summarySerial;  
       
       ParallelType mParallelType = ParallelType::SerialOnly;  
       int mOmpThreadNum = 8;                                  
   };
   
   }
   
   
   #endif  // GWSS_H