.. _program_listing_file_include_gwmodelpp_spatialweight_SpatialWeight.h:

Program Listing for File SpatialWeight.h
========================================

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

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

.. code-block:: cpp

   #ifndef SPATIALWEIGHT_H
   #define SPATIALWEIGHT_H
   
   #ifdef ENABLE_CUDA
   #include <cuda_runtime.h>
   #include "gwmodelpp/spatialweight/cuda/ISpatialCudaEnabled.h"
   #endif 
   
   #include "Weight.h"
   #include "Distance.h"
   
   #include "BandwidthWeight.h"
   
   #include "CRSDistance.h"
   #include "MinkwoskiDistance.h"
   #include "DMatDistance.h"
   #include "OneDimDistance.h"
   #include "CRSSTDistance.h"
   
   namespace gwm
   {
   
   class SpatialWeight
   #ifdef ENABLE_CUDA
       : public ISpatialCudaEnabled
   #endif
   {
   public:
   
       SpatialWeight() {}
   
       SpatialWeight(const Weight* weight, const Distance* distance)
       {
           mWeight = weight->clone();
           mDistance = distance->clone();
       }
   
       SpatialWeight(const Weight& weight, const Distance& distance)
       {
           mWeight = weight.clone();
           mDistance = distance.clone();
       }
   
       SpatialWeight(const SpatialWeight& spatialWeight)
       {
           mWeight = spatialWeight.mWeight->clone();
           mDistance = spatialWeight.mDistance->clone();
       }
   
       SpatialWeight(SpatialWeight&& other)
       {
           mWeight = other.mWeight;
           mDistance = other.mDistance;
           
           other.mWeight = nullptr;
           other.mDistance = nullptr;
       }
   
       virtual ~SpatialWeight();
   
       Weight *weight() const
       {
           return mWeight;
       }
   
       void setWeight(Weight *weight)
       {
           if (weight && weight != mWeight)
           {
               if (mWeight) delete mWeight;
               mWeight = weight->clone();
           }
       }
   
       void setWeight(Weight& weight)
       {
           if (mWeight) delete mWeight;
           mWeight = weight.clone();
       }
   
       void setWeight(Weight&& weight)
       {
           if (mWeight) delete mWeight;
           mWeight = weight.clone();
       }
   
       template<typename T>
       T* weight() const { return nullptr; }
   
       Distance *distance() const
       {
           return mDistance;
       }
   
       void setDistance(Distance *distance)
       {
           if (distance && distance != mDistance)
           {
               if (mDistance) delete mDistance;
               mDistance = distance->clone();
           }
       }
   
       void setDistance(Distance& distance)
       {
           if (mDistance) delete mDistance;
           mDistance = distance.clone();
       }
   
       void setDistance(Distance&& distance)
       {
           if (mDistance) delete mDistance;
           mDistance = distance.clone();
       }
   
       template<typename T>
       T* distance() const { return nullptr; }
   
   public:
   
       SpatialWeight& operator=(const SpatialWeight& spatialWeight);
   
       SpatialWeight& operator=(SpatialWeight&& spatialWeight);
   
   public:
   
       virtual arma::vec weightVector(arma::uword focus) const
       {
           return mWeight->weight(mDistance->distance(focus));
       }
   
   #ifdef ENABLE_CUDA
       virtual cudaError_t prepareCuda(size_t gpuId) override
       {
           cudaError_t error;
           error = mDistance->prepareCuda(gpuId);
           if (error != cudaSuccess) return error;
           error = mWeight->prepareCuda(gpuId);
           return error;
       }
   
       virtual bool useCuda()
       {
           return mWeight->useCuda() || mDistance->useCuda();
       }
   
       virtual void setUseCuda(bool isUseCuda)
       {
           mWeight->setUseCuda(isUseCuda);
           mDistance->setUseCuda(isUseCuda);
       }
   
       virtual cudaError_t weightVector(arma::uword focus, double* d_dists, double* d_weights) const
       {
           cudaError_t error;
           size_t elems = 0;
           error = mDistance->distance(focus, d_dists, &elems);
           if (error != cudaSuccess) return error;
           error = mWeight->weight(d_dists, d_weights, elems);
           return error;
       }
   #endif
   
       virtual bool isValid();
   
   private:
       Weight* mWeight = nullptr;      
       Distance* mDistance = nullptr;  
   };
   
   template<>
   inline BandwidthWeight* SpatialWeight::weight<BandwidthWeight>() const
   {
       return static_cast<BandwidthWeight*>(mWeight);
   }
   
   template<>
   inline CRSDistance* SpatialWeight::distance<CRSDistance>() const
   {
       return static_cast<CRSDistance*>(mDistance);
   }
   
   template<>
   inline CRSSTDistance* SpatialWeight::distance<CRSSTDistance>() const
   {
       return static_cast<CRSSTDistance*>(mDistance);
   }
   
   template<>
   inline MinkwoskiDistance* SpatialWeight::distance<MinkwoskiDistance>() const
   {
       return static_cast<MinkwoskiDistance*>(mDistance);
   }
   
   template<>
   inline DMatDistance* SpatialWeight::distance<DMatDistance>() const
   {
       return static_cast<DMatDistance*>(mDistance);
   }
   
   template<>
   inline OneDimDistance* SpatialWeight::distance<OneDimDistance>() const
   {
       return static_cast<OneDimDistance*>(mDistance);
   }
   
   }
   
   #endif // SPATIALWEIGHT_H