Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include "CUDADefines.h"
       4             : #include <utility>
       5             : #include <thrust/complex.h>
       6             : 
       7             : namespace elsa
       8             : {
       9             :     // Arithmetic operations
      10             :     // negate
      11             :     struct negate {
      12             :         template <class T>
      13             :         __host__ __device__ constexpr auto operator()(const T& arg)
      14             :             -> decltype(-std::declval<T>()) const
      15             :         {
      16             :             return -arg;
      17             :         }
      18             :     };
      19             : 
      20             :     // identity
      21             :     struct identity {
      22             :         template <class T>
      23             :         __host__ __device__ constexpr auto operator()(const T& arg)
      24             :             -> decltype(std::declval<T>()) const
      25             :         {
      26             :             return arg;
      27             :         }
      28             :     };
      29             : 
      30             :     // plus
      31             :     struct plus {
      32             :         template <class T, class U = T>
      33             :         __host__ __device__ constexpr auto operator()(const T& lhs, const U& rhs)
      34             :             -> decltype(std::declval<T>() + std::declval<U>()) const
      35      859227 :         {
      36      859227 :             return lhs + rhs;
      37      859227 :         }
      38             :     };
      39             : 
      40             :     // minus
      41             :     struct minus {
      42             :         template <class T, class U = T>
      43             :         __host__ __device__ constexpr auto operator()(const T& lhs, const U& rhs)
      44             :             -> decltype(std::declval<T>() - std::declval<U>()) const
      45      439722 :         {
      46      439722 :             return lhs - rhs;
      47      439722 :         }
      48             :     };
      49             : 
      50             :     // multiplies
      51             :     struct multiplies {
      52             :         template <class T, class U = T>
      53             :         __host__ __device__ constexpr auto operator()(const T& lhs, const U& rhs)
      54             :             -> decltype(std::declval<T>() * std::declval<U>()) const
      55      652736 :         {
      56      652736 :             return lhs * rhs;
      57      652736 :         }
      58             :     };
      59             : 
      60             :     // divides
      61             :     struct divides {
      62             :         template <class T, class U = T>
      63             :         __host__ __device__ constexpr auto operator()(const T& lhs, const U& rhs)
      64             :             -> decltype(std::declval<T>() / std::declval<U>()) const
      65       25744 :         {
      66       25744 :             return lhs / rhs;
      67       25744 :         }
      68             :     };
      69             : 
      70             :     // modulus
      71             :     struct modulus {
      72             :         template <class T, class U = T>
      73             :         __host__ __device__ constexpr auto operator()(const T& lhs, const U& rhs)
      74             :             -> decltype(std::declval<T>() % std::declval<U>()) const
      75             :         {
      76             :             return lhs % rhs;
      77             :         }
      78             :     };
      79             : } // namespace elsa