.. _program_listing_file_include_gwmodelpp_GWDA.h:

Program Listing for File GWDA.h
===============================

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

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

.. code-block:: cpp

   #ifndef GWDA_H
   #define GWDA_H
   
   #include "SpatialMonoscaleAlgorithm.h"
   #include "IMultivariableAnalysis.h"
   #include "IParallelizable.h"
   
   
   namespace gwm
   {
   
       //template<class T>
       class GWDA : public SpatialMonoscaleAlgorithm, public IMultivariableAnalysis, public IParallelizable, public IParallelOpenmpEnabled
       {
       public:
   
           static arma::mat covwtmat(const arma::mat &x, const arma::vec &wt);
   
           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));
           }
   
           typedef void (GWDA::*DiscriminantAnalysisCalculator)(); 
   
       public:
           GWDA() {}
   
           GWDA(const arma::mat x, const arma::mat coords, const SpatialWeight &spatialWeight)
               : SpatialMonoscaleAlgorithm(spatialWeight, coords)
           {
               mX = x;
           }
   
           ~GWDA() {}
   
           
           bool isWqda() const { return mIsWqda; }
   
           void setIsWqda(bool iswqda)
           {
               mIsWqda = iswqda;
           }
   
           bool hasCov() const { return mHascov; }
   
           void setHascov(bool hascov)
           {
               mHascov = hascov;
           }
   
           bool hasMean() const { return mHasmean; }
   
           void setHasmean(bool hasmean)
           {
               mHasmean = hasmean;
           }
   
           bool hasPrior() const { return mHasprior; }
   
           void setHasprior(bool hasprior)
           {
               mHasprior = hasprior;
           }
   
           double correctRate() const { return mCorrectRate; }
   
           const arma::mat& res() const { return mRes; }
   
           const std::vector<std::string>& group() const { return mGroup; }
   
           const arma::mat& probs() const { return mProbs; }
   
           const arma::mat& pmax() const { return mPmax; }
   
           const arma::mat& entropy() const { return mEntropy; }
   
           arma::mat wqda(arma::mat &x, std::vector<std::string> &y, arma::mat &wt, arma::mat &xpr, bool hasCOv, bool hasMean, bool hasPrior);
   
           arma::mat wlda(arma::mat &x, std::vector<std::string> &y, arma::mat &wt, arma::mat &xpr, bool hasCOv, bool hasMean, bool hasPrior);
   
           std::vector<arma::mat> splitX(arma::mat &x, std::vector<std::string> &y);
   
           arma::mat wMean(arma::mat &x, arma::mat &wt);
   
           arma::cube wVarCov(arma::mat &x, arma::mat &wt);
   
           arma::vec wPrior(arma::mat &wt, double sumW);
   
           //arma::mat confusionMatrix(arma::mat &origin, arma::mat &classified);
   
           std::vector<std::string> levels(std::vector<std::string> &y);
   
           double shannonEntropy(arma::vec &p);
   
           arma::uvec findSameString(std::vector<std::string> &y,std::string s);
   
           std::unordered_map<std::string,arma::uword> ytable(std::vector<std::string> &y);
   
       public: // SpatialMonoscaleAlgorithm interface
           bool isValid() override;
   
       public: // IMultivariableAnalysis
           const arma::mat& variables() const override { return mX; }
           void setVariables(const arma::mat &x) override { mX = x; }
           void setGroup(std::vector<std::string> &y) { mY = y; }
           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 discriminantAnalysisSerial();
   
   #ifdef ENABLE_OPENMP
           void discriminantAnalysisOmp();
   #endif
   
       private:
           bool mIsWqda = false;        
           bool mHascov = true;  
           bool mHasmean = true; 
           bool mHasprior = true; 
   
           double mCorrectRate = 0; 
              
           arma::mat mX; 
           std::vector<std::string> mY; 
           bool mHasPredict; 
           arma::mat mprX; 
           std::vector<std::string> mprY; 
           arma::mat mRes; // !< \~english the result matrix of geographical weighted discriminant analysis \~chinese 地理加权判别分析结果矩阵
           std::vector<std::string> mGroup; 
           arma::mat mProbs; 
           arma::mat mPmax; 
           arma::mat mEntropy; 
   
           DiscriminantAnalysisCalculator mDiscriminantAnalysisFunction = &GWDA::discriminantAnalysisSerial; 
   
           ParallelType mParallelType = ParallelType::SerialOnly; 
           int mOmpThreadNum = 8;                                 
       };
   
   }
   
   #endif // GWDA_H