.. _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 std::unique_ptr<Weight>& weight, const std::unique_ptr<Distance>& distance):
           mWeight(weight->clone()),
           mDistance(distance->clone())
       {}
   
       SpatialWeight(std::unique_ptr<Weight>&& weight, std::unique_ptr<Distance>&& distance):
           mWeight(std::move(weight)),
           mDistance(std::move(distance))
       {}
   
       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(std::move(other.mWeight)),
           mDistance(std::move(other.mDistance))
       {}
   
       virtual ~SpatialWeight() {};
   
       const std::unique_ptr<Weight>& weight() const
       {
           return mWeight;
       }
   
       void setWeight(const Weight *weight)
       {
           if (weight && weight != mWeight.get())
           {
               mWeight = weight->clone();
           }
       }
   
       void setWeight(const Weight& weight)
       {
           mWeight = weight.clone();
       }
   
       void setWeight(Weight&& weight)
       {
           mWeight = weight.clone();
       }
   
       void setWeight(std::unique_ptr<Weight>&& weight)
       {
           mWeight = std::move(weight);
       }
   
       template<typename T>
       T& weight() const { return nullptr; }
   
       const std::unique_ptr<Distance>& distance() const
       {
           return mDistance;
       }
   
       void setDistance(const Distance *distance)
       {
           if (distance && distance != mDistance.get())
           {
               mDistance = distance->clone();
           }
       }
   
       void setDistance(const Distance& distance)
       {
           mDistance = distance.clone();
       }
   
       void setDistance(Distance&& distance)
       {
           mDistance = distance.clone();
       }
   
       void setDistance(std::unique_ptr<Distance>&& distance)
       {
           mDistance = std::move(distance);
       }
   
       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:
       std::unique_ptr<Weight> mWeight = nullptr;      
       std::unique_ptr<Distance> mDistance = nullptr;  
   };
   
   template<>
   inline BandwidthWeight& SpatialWeight::weight<BandwidthWeight>() const
   {
       return static_cast<BandwidthWeight&>(*mWeight.get());
   }
   
   template<>
   inline CRSDistance& SpatialWeight::distance<CRSDistance>() const
   {
       return static_cast<CRSDistance&>(*mDistance.get());
   }
   
   template<>
   inline CRSSTDistance& SpatialWeight::distance<CRSSTDistance>() const
   {
       return static_cast<CRSSTDistance&>(*mDistance.get());
   }
   
   template<>
   inline MinkwoskiDistance& SpatialWeight::distance<MinkwoskiDistance>() const
   {
       return static_cast<MinkwoskiDistance&>(*mDistance.get());
   }
   
   template<>
   inline DMatDistance& SpatialWeight::distance<DMatDistance>() const
   {
       return static_cast<DMatDistance&>(*mDistance.get());
   }
   
   template<>
   inline OneDimDistance& SpatialWeight::distance<OneDimDistance>() const
   {
       return static_cast<OneDimDistance&>(*mDistance.get());
   }
   
   }
   
   #endif // SPATIALWEIGHT_H