.. _program_listing_file_include_gwmodelpp_spatialweight_BandwidthWeight.h:

Program Listing for File BandwidthWeight.h
==========================================

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

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

.. code-block:: cpp

   #ifndef BANDWIDTHWEIGHT_H
   #define BANDWIDTHWEIGHT_H
   
   #include <unordered_map>
   #include <string>
   #include "Weight.h"
   
   #ifdef ENABLE_CUDA
   #include "gwmodelpp/utils/CudaUtils.h"
   #include "gwmodelpp/spatialweight/cuda/BandwidthWeightKernel.h"
   #endif // ENABLE_CUDA
   
   namespace gwm
   {
   
   class BandwidthWeight : public Weight
   {
   public:
   
       enum KernelFunctionType
       {
           Gaussian,       
           Exponential,    
           Bisquare,       
           Tricube,        
           Boxcar          
       };
       static std::unordered_map<KernelFunctionType, std::string> KernelFunctionTypeNameMapper;
       static std::unordered_map<bool, std::string> BandwidthTypeNameMapper;
   
       typedef arma::vec (*KernelFunction)(arma::vec, double); 
   
       static KernelFunction Kernel[];
   
       static arma::vec GaussianKernelFunction(arma::vec dist, double bw)
       {
           return exp((dist % dist) / ((-2.0) * (bw * bw)));
       }
       
       static arma::vec ExponentialKernelFunction(arma::vec dist, double bw)
       {
           return exp(-dist / bw);
       }
       
       static arma::vec BisquareKernelFunction(arma::vec dist, double bw)
       {
           arma::vec d2_d_b2 = 1.0 - (dist % dist) / (bw * bw);
           return (dist < bw) % (d2_d_b2 % d2_d_b2);
       }
       
       static arma::vec TricubeKernelFunction(arma::vec dist, double bw)
       {
           arma::vec d3_d_b3 = 1.0 - (dist % dist % dist) / (bw * bw * bw);
           return (dist < bw) % (d3_d_b3 % d3_d_b3 % d3_d_b3);
       }
       
       static arma::vec BoxcarKernelFunction(arma::vec dist, double bw)
       {
           return (dist < bw) % arma::vec(arma::size(dist), arma::fill::ones);
       }
   
   public:
   
       BandwidthWeight() {}
   
       BandwidthWeight(double size, bool adaptive, KernelFunctionType kernel)
       {
           mBandwidth = size;
           mAdaptive = adaptive;
           mKernel = kernel;
       }
   
       BandwidthWeight(const BandwidthWeight& bandwidthWeight) : Weight(bandwidthWeight)
       {
           mBandwidth = bandwidthWeight.mBandwidth;
           mAdaptive = bandwidthWeight.mAdaptive;
           mKernel = bandwidthWeight.mKernel;
   #ifdef ENABLE_CUDA
           mUseCuda = bandwidthWeight.mUseCuda;
           if (mUseCuda)
           {
               prepareCuda(bandwidthWeight.mGpuID);
           }
   #endif // ENABLE_CUDA
       }
   
       BandwidthWeight(const BandwidthWeight* bandwidthWeight)
       {
           mBandwidth = bandwidthWeight->bandwidth();
           mAdaptive = bandwidthWeight->adaptive();
           mKernel = bandwidthWeight->kernel();
       }
   
       virtual Weight * clone() const override
       {
           return new BandwidthWeight(*this);
       }
   
   public:
       virtual arma::vec weight(arma::vec dist) override;
   
   #ifdef ENABLE_CUDA
       virtual cudaError_t weight(double* d_dists, double* d_weights, size_t elems) override;
   #endif // ENABLE_CUDA
   
       double bandwidth() const
       {
           return mBandwidth;
       }
   
       void setBandwidth(double bandwidth)
       {
           mBandwidth = bandwidth;
       }
   
       bool adaptive() const
       {
           return mAdaptive;
       }
   
       void setAdaptive(bool adaptive)
       {
           mAdaptive = adaptive;
       }
   
       KernelFunctionType kernel() const
       {
           return mKernel;
       }
   
       void setKernel(const KernelFunctionType &kernel)
       {
           mKernel = kernel;
       }
   
   #ifdef ENABLE_CUDA
       cudaError_t prepareCuda(size_t gpuId) override
       {
           checkCudaErrors(Weight::prepareCuda(gpuId));
           mCudaPrepared = true;
           return cudaSuccess;
       }
   #endif // ENABLE_CUDA
   
   private:
       double mBandwidth;          
       bool mAdaptive;             
       KernelFunctionType mKernel; 
   };
   
   }
   
   #endif // BANDWIDTHWEIGHT_H