.. _program_listing_file_include_gwmodelpp_spatialweight_CRSDistance.h:

Program Listing for File CRSDistance.h
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_gwmodelpp_spatialweight_CRSDistance.h>` (``include/gwmodelpp/spatialweight/CRSDistance.h``)

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

.. code-block:: cpp

   #ifndef CRSDISTANCE_H
   #define CRSDISTANCE_H
   
   #include "Distance.h"
   
   #ifdef ENABLE_CUDA
   #include "gwmodelpp/utils/cumat.hpp"
   #include "gwmodelpp/spatialweight/cuda/CRSDistanceKernel.h"
   #include "gwmodelpp/spatialweight/cuda/ISpatialCudaEnabled.h"
   #endif // ENABLE_CUDA
   
   namespace gwm
   {
   
   class CRSDistance : public Distance
   {
   public:
   
       struct Parameter : public Distance::Parameter
       {
           arma::mat focusPoints;
   
           arma::mat dataPoints;
   
           Parameter(const arma::mat& fp, const arma::mat& dp) : Distance::Parameter()
               , focusPoints(fp)
               , dataPoints(dp)
           {
               total = fp.n_rows;
           }
       };
   
   public:
   
       static arma::vec SpatialDistance(const arma::rowvec& out_loc, const arma::mat& in_locs);
   
       static arma::vec EuclideanDistance(const arma::rowvec& out_loc, const arma::mat& in_locs)
       {
           arma::mat diff = (in_locs.each_row() - out_loc);
           return sqrt(sum(diff % diff, 1));
       }
   
       static double SpGcdist(double lon1, double lon2, double lat1, double lat2);
   
   private:
       typedef arma::vec (*CalculatorType)(const arma::rowvec&, const arma::mat&);
   #ifdef ENABLE_CUDA
       typedef cudaError_t (*CalculatorCudaType)(const double*, const double*, size_t, size_t, double*);
   #endif
   
   public:
   
       CRSDistance() : mGeographic(false), mParameter(nullptr) {}
   
       explicit CRSDistance(bool isGeographic): mGeographic(isGeographic), mParameter(nullptr)
       {
           mCalculator = mGeographic ? &SpatialDistance : &EuclideanDistance;
   #ifdef ENABLE_CUDA
           mCalculatorCuda = mGeographic ? &sp_dist_cuda : eu_dist_cuda;
   #endif
       }
   
       CRSDistance(const CRSDistance& distance);
   
       virtual ~CRSDistance()
       {
       }
   
       virtual Distance * clone() const override
       {
           return new CRSDistance(*this);
       }
   
       DistanceType type() override { return DistanceType::CRSDistance; }
   
       bool geographic() const
       {
           return mGeographic;
       }
   
       void setGeographic(bool geographic)
       {
           mGeographic = geographic;
           mCalculator = mGeographic ? &SpatialDistance : &EuclideanDistance;
   #ifdef ENABLE_CUDA
           mCalculatorCuda = mGeographic ? &sp_dist_cuda : eu_dist_cuda;
   #endif
       }
   
   public:
   
       virtual void makeParameter(std::initializer_list<DistParamVariant> plist) override;
   
       virtual arma::vec distance(arma::uword focus) override;
       virtual double maxDistance() override;
       virtual double minDistance() override;
   
   #ifdef ENABLE_CUDA
       virtual cudaError_t prepareCuda(size_t gpuId) override;
   
       virtual cudaError_t distance(arma::uword focus, double* d_dists, size_t* elems) override;
   #endif
   
   protected:
       bool mGeographic;  
       std::unique_ptr<Parameter> mParameter;  
   
   private:
       CalculatorType mCalculator = &EuclideanDistance;  
   
   #ifdef ENABLE_CUDA
       cumat mCudaDp;    
       cumat mCudaFp;    
       CalculatorCudaType mCalculatorCuda = &eu_dist_cuda;  
   #endif
   
   };
   
   }
   
   #endif // CRSDISTANCE_H