vec_math.hpp File Reference


#include " vec_traits.hpp "
#include " saturate_cast.hpp "

struct   cv::cudev::vec_math_detail::SatCastHelper< cn, VecD >
 
struct   cv::cudev::vec_math_detail::SatCastHelper< 1, VecD >
 
struct   cv::cudev::vec_math_detail::SatCastHelper< 2, VecD >
 
struct   cv::cudev::vec_math_detail::SatCastHelper< 3, VecD >
 
struct   cv::cudev::vec_math_detail::SatCastHelper< 4, VecD >
 

名称空间

  cv
  "black box" representation of the file storage associated with a file on disk.
 
  cv::cudev
 
  cv::cudev::vec_math_detail
 

#define  CV_CUDEV_IMPLEMENT_SCALAR_BINARY_FUNC (func_name, func, input_type, scalar_type, output_type)
 
#define  CV_CUDEV_IMPLEMENT_SCALAR_BINARY_OP (op, input_type, scalar_type, output_type)
 
#define  CV_CUDEV_IMPLEMENT_VEC_BINARY_FUNC (func_name, func, input_type, output_type)
 
#define  CV_CUDEV_IMPLEMENT_VEC_BINARY_OP (op, input_type, output_type)
 
#define  CV_CUDEV_IMPLEMENT_VEC_UNARY_FUNC (func_name, func, input_type, output_type)
 
#define  CV_CUDEV_IMPLEMENT_VEC_UNARY_OP (op, input_type, output_type)
 
#define  OPENCV_CUDEV_UTIL_VEC_MATH_HPP
 

函数

__device__ __forceinline__ uchar1  cv::cudev::abs (const uchar1 &a)
 
__device__ __forceinline__ uchar2  cv::cudev::abs (const uchar2 &a)
 
__device__ __forceinline__ uchar3  cv::cudev::abs (const uchar3 &a)
 
__device__ __forceinline__ uchar4  cv::cudev::abs (const uchar4 &a)
 
__device__ __forceinline__ char1  cv::cudev::abs (const char1 &a)
 
__device__ __forceinline__ char2  cv::cudev::abs (const char2 &a)
 
__device__ __forceinline__ char3  cv::cudev::abs (const char3 &a)
 
__device__ __forceinline__ char4  cv::cudev::abs (const char4 &a)
 
__device__ __forceinline__ ushort1  cv::cudev::abs (const ushort1 &a)
 
__device__ __forceinline__ ushort2  cv::cudev::abs (const ushort2 &a)
 
__device__ __forceinline__ ushort3  cv::cudev::abs (const ushort3 &a)
 
__device__ __forceinline__ ushort4  cv::cudev::abs (const ushort4 &a)
 
__device__ __forceinline__ short1  cv::cudev::abs (const short1 &a)
 
__device__ __forceinline__ short2  cv::cudev::abs (const short2 &a)
 
__device__ __forceinline__ short3  cv::cudev::abs (const short3 &a)
 
__device__ __forceinline__ short4  cv::cudev::abs (const short4 &a)
 
__device__ __forceinline__ int2  cv::cudev::abs (const int2 &a)
 
__device__ __forceinline__ int3  cv::cudev::abs (const int3 &a)
 
__device__ __forceinline__ int4  cv::cudev::abs (const int4 &a)
 
__device__ __forceinline__ int1  cv::cudev::abs (const int1 &a)
 
__device__ __forceinline__ uint1  cv::cudev::abs (const uint1 &a)
 
__device__ __forceinline__ uint2  cv::cudev::abs (const uint2 &a)
 
__device__ __forceinline__ uint3  cv::cudev::abs (const uint3 &a)
 
__device__ __forceinline__ uint4  cv::cudev::abs (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::abs (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::abs (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::abs (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::abs (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::abs (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::abs (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::abs (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::abs (const double4 &a)
 
__device__ __forceinline__ schar   cv::cudev::vec_math_detail::abs_ ( schar val)
 
__device__ __forceinline__ short  cv::cudev::vec_math_detail::abs_ (short val)
 
__device__ __forceinline__ float1  cv::cudev::acos (const uchar1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acos (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acos (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acos (const uchar4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acos (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acos (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acos (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acos (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acos (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acos (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acos (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acos (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acos (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acos (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acos (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acos (const short4 &a)
 
__device__ __forceinline__ float2  cv::cudev::acos (const int2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acos (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acos (const int4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acos (const int1 &a)
 
__device__ __forceinline__ float1  cv::cudev::acos (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acos (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acos (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acos (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acos (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acos (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acos (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acos (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::acos (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::acos (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::acos (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::acos (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acosh (const uchar1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acosh (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acosh (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acosh (const uchar4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acosh (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acosh (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acosh (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acosh (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acosh (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acosh (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acosh (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acosh (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acosh (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acosh (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acosh (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acosh (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acosh (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acosh (const int2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acosh (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acosh (const int4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acosh (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acosh (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acosh (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acosh (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::acosh (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::acosh (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::acosh (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::acosh (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::acosh (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::acosh (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::acosh (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::acosh (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asin (const uchar1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asin (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asin (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asin (const uchar4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asin (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asin (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asin (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asin (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asin (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asin (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asin (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asin (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asin (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asin (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asin (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asin (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asin (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asin (const int2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asin (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asin (const int4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asin (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asin (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asin (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asin (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asin (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asin (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asin (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asin (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::asin (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::asin (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::asin (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::asin (const double4 &a)
 
__device__ __forceinline__ float3  cv::cudev::asinh (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asinh (const uchar4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asinh (const uchar1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asinh (const uchar2 &a)
 
__device__ __forceinline__ float1  cv::cudev::asinh (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asinh (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asinh (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asinh (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asinh (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asinh (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asinh (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asinh (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asinh (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asinh (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asinh (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asinh (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asinh (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asinh (const int2 &a)
 
__device__ __forceinline__ float4  cv::cudev::asinh (const int4 &a)
 
__device__ __forceinline__ float3  cv::cudev::asinh (const int3 &a)
 
__device__ __forceinline__ float1  cv::cudev::asinh (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::asinh (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::asinh (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asinh (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::asinh (const float1 &a)
 
__device__ __forceinline__ float3  cv::cudev::asinh (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::asinh (const float4 &a)
 
__device__ __forceinline__ float2  cv::cudev::asinh (const float2 &a)
 
__device__ __forceinline__ double1  cv::cudev::asinh (const double1 &a)
 
__device__ __forceinline__ double3  cv::cudev::asinh (const double3 &a)
 
__device__ __forceinline__ double2  cv::cudev::asinh (const double2 &a)
 
__device__ __forceinline__ double4  cv::cudev::asinh (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atan (const uchar1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atan (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atan (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atan (const uchar4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atan (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atan (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atan (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atan (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atan (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atan (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atan (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atan (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atan (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atan (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atan (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atan (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atan (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atan (const int2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atan (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atan (const int4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atan (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atan (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atan (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atan (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atan (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atan (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atan (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atan (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::atan (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::atan (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::atan (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::atan (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const uchar1 &a, const uchar1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const uchar2 &a, const uchar2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const uchar3 &a, const uchar3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const uchar4 &a, const uchar4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const char1 &a, const char1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const char2 &a, const char2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const char3 &a, const char3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const char4 &a, const char4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const ushort1 &a, const ushort1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const ushort2 &a, const ushort2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const ushort3 &a, const ushort3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const ushort4 &a, const ushort4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const short1 &a, const short1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const short2 &a, const short2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const short3 &a, const short3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const short4 &a, const short4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const uint1 &a, const uint1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const uint2 &a, const uint2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const uint3 &a, const uint3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const uint4 &a, const uint4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const int1 &a, const int1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const int2 &a, const int2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const int3 &a, const int3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const int4 &a, const int4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const float1 &a, const float1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const float2 &a, const float2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const float3 &a, const float3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const float4 &a, const float4 &b)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (const double1 &a, const double1 &b)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (const double2 &a, const double2 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (const double3 &a, const double3 &b)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (const double4 &a, const double4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const uchar1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (float s, const uchar1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const uchar2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (float s, const uchar2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const uchar3 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (float s, const uchar3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const uchar4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (float s, const uchar4 &b)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (const uchar1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (double s, const uchar1 &b)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (const uchar2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (double s, const uchar2 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (double s, const uchar3 &b)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (const uchar4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (double s, const uchar4 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (const uchar3 &a, double s)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (float s, const char1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const char2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (float s, const char2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const char3 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (float s, const char3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const char4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (float s, const char4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const char1 &a, float s)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (const char1 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (const char3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (double s, const char1 &b)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (const char2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (double s, const char2 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (double s, const char3 &b)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (const char4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (double s, const char4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const ushort1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (float s, const ushort1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const ushort2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (float s, const ushort2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const ushort3 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (float s, const ushort3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const ushort4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (float s, const ushort4 &b)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (const ushort1 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (const ushort3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (double s, const ushort1 &b)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (const ushort2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (double s, const ushort2 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (double s, const ushort3 &b)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (const ushort4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (double s, const ushort4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const short1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (float s, const short1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const short2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (float s, const short2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const short3 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (float s, const short3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const short4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (float s, const short4 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (const short3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (const short1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (double s, const short1 &b)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (const short2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (double s, const short2 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (double s, const short3 &b)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (const short4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (double s, const short4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const uint1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (float s, const uint1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const uint2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (float s, const uint2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const uint3 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (float s, const uint3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const uint4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (float s, const uint4 &b)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (double s, const uint1 &b)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (const uint2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (double s, const uint2 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (double s, const uint3 &b)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (const uint4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (double s, const uint4 &b)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (const uint1 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (const uint3 &a, double s)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (float s, const int1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const int2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (float s, const int2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const int3 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (float s, const int3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const int4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (float s, const int4 &b)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const int1 &a, float s)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (const int3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (double s, const int1 &b)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (const int2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (double s, const int2 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (double s, const int3 &b)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (const int4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (double s, const int4 &b)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (const int1 &a, double s)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (const float1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::atan2 (float s, const float1 &b)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (const float2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::atan2 (float s, const float2 &b)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (const float3 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::atan2 (float s, const float3 &b)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (const float4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::atan2 (float s, const float4 &b)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (const float1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (double s, const float1 &b)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (const float2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (double s, const float2 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (double s, const float3 &b)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (const float4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (double s, const float4 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (const float3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (double s, const double1 &b)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (const double2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::atan2 (double s, const double2 &b)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (const double3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::atan2 (double s, const double3 &b)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (const double4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::atan2 (double s, const double4 &b)
 
__device__ __forceinline__ double1  cv::cudev::atan2 (const double1 &a, double s)
 
__device__ __forceinline__ float1  cv::cudev::atanh (const uchar1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atanh (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atanh (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atanh (const uchar4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atanh (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atanh (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atanh (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atanh (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atanh (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atanh (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atanh (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atanh (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atanh (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atanh (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atanh (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atanh (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atanh (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atanh (const int2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atanh (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atanh (const int4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atanh (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atanh (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atanh (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atanh (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::atanh (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::atanh (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::atanh (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::atanh (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::atanh (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::atanh (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::atanh (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::atanh (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cos (const uchar1 &a)
 
__device__ __forceinline__ float3  cv::cudev::cos (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cos (const uchar4 &a)
 
__device__ __forceinline__ float2  cv::cudev::cos (const uchar2 &a)
 
__device__ __forceinline__ float1  cv::cudev::cos (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cos (const char2 &a)
 
__device__ __forceinline__ float4  cv::cudev::cos (const char4 &a)
 
__device__ __forceinline__ float3  cv::cudev::cos (const char3 &a)
 
__device__ __forceinline__ float1  cv::cudev::cos (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cos (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cos (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cos (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cos (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cos (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cos (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cos (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cos (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cos (const int2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cos (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cos (const int4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cos (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cos (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cos (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cos (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cos (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cos (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cos (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cos (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::cos (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::cos (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::cos (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::cos (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cosh (const uchar1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cosh (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cosh (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cosh (const uchar4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cosh (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cosh (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cosh (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cosh (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cosh (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cosh (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cosh (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cosh (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cosh (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cosh (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cosh (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cosh (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cosh (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cosh (const int2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cosh (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cosh (const int4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cosh (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cosh (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cosh (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cosh (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::cosh (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::cosh (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::cosh (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::cosh (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::cosh (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::cosh (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::cosh (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::cosh (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp (const uchar1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp (const uchar4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp (const char1 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp (const char3 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp (const char2 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp (const int2 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp (const int4 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp (const uint1 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp (const uint3 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp (const uint2 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp (const float2 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp (const float4 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp (const float3 &a)
 
__device__ __forceinline__ double1  cv::cudev::exp (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::exp (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::exp (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::exp (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp10 (const uchar1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp10 (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp10 (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp10 (const uchar4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp10 (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp10 (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp10 (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp10 (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp10 (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp10 (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp10 (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp10 (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp10 (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp10 (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp10 (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp10 (const short4 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp10 (const int3 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp10 (const int2 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp10 (const int4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp10 (const int1 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp10 (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp10 (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp10 (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp10 (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp10 (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp10 (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp10 (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp10 (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::exp10 (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::exp10 (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::exp10 (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::exp10 (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp2 (const uchar1 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp2 (const uchar4 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp2 (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp2 (const uchar3 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp2 (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp2 (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp2 (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp2 (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp2 (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp2 (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp2 (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp2 (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp2 (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp2 (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp2 (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp2 (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp2 (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp2 (const int2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp2 (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp2 (const int4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp2 (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp2 (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp2 (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp2 (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::exp2 (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::exp2 (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::exp2 (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::exp2 (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::exp2 (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::exp2 (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::exp2 (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::exp2 (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const uchar1 &a, const uchar1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const uchar2 &a, const uchar2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const uchar3 &a, const uchar3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const uchar4 &a, const uchar4 &b)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const char1 &a, const char1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const char2 &a, const char2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const char3 &a, const char3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const char4 &a, const char4 &b)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const ushort1 &a, const ushort1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const ushort2 &a, const ushort2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const ushort3 &a, const ushort3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const ushort4 &a, const ushort4 &b)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const short1 &a, const short1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const short2 &a, const short2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const short3 &a, const short3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const short4 &a, const short4 &b)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const uint1 &a, const uint1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const uint2 &a, const uint2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const uint3 &a, const uint3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const uint4 &a, const uint4 &b)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const int1 &a, const int1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const int2 &a, const int2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const int3 &a, const int3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const int4 &a, const int4 &b)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const float1 &a, const float1 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const float3 &a, const float3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const float4 &a, const float4 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const float2 &a, const float2 &b)
 
__device__ __forceinline__ double1  cv::cudev::hypot (const double1 &a, const double1 &b)
 
__device__ __forceinline__ double3  cv::cudev::hypot (const double3 &a, const double3 &b)
 
__device__ __forceinline__ double2  cv::cudev::hypot (const double2 &a, const double2 &b)
 
__device__ __forceinline__ double4  cv::cudev::hypot (const double4 &a, const double4 &b)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const uchar1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (float s, const uchar1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const uchar2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::hypot (float s, const uchar2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (float s, const uchar3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const uchar4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::hypot (float s, const uchar4 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const uchar3 &a, float s)
 
__device__ __forceinline__ double1  cv::cudev::hypot (double s, const uchar1 &b)
 
__device__ __forceinline__ double2  cv::cudev::hypot (const uchar2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::hypot (double s, const uchar2 &b)
 
__device__ __forceinline__ double3  cv::cudev::hypot (const uchar3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::hypot (double s, const uchar3 &b)
 
__device__ __forceinline__ double4  cv::cudev::hypot (const uchar4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::hypot (double s, const uchar4 &b)
 
__device__ __forceinline__ double1  cv::cudev::hypot (const uchar1 &a, double s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const char1 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const char3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (float s, const char1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const char2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::hypot (float s, const char2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (float s, const char3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const char4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::hypot (float s, const char4 &b)
 
__device__ __forceinline__ double1  cv::cudev::hypot (const char1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::hypot (double s, const char1 &b)
 
__device__ __forceinline__ double2  cv::cudev::hypot (const char2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::hypot (double s, const char2 &b)
 
__device__ __forceinline__ double3  cv::cudev::hypot (const char3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::hypot (double s, const char3 &b)
 
__device__ __forceinline__ double4  cv::cudev::hypot (const char4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::hypot (double s, const char4 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const ushort3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const ushort1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (float s, const ushort1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const ushort2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::hypot (float s, const ushort2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (float s, const ushort3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const ushort4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::hypot (float s, const ushort4 &b)
 
__device__ __forceinline__ double1  cv::cudev::hypot (const ushort1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::hypot (double s, const ushort1 &b)
 
__device__ __forceinline__ double2  cv::cudev::hypot (const ushort2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::hypot (double s, const ushort2 &b)
 
__device__ __forceinline__ double3  cv::cudev::hypot (const ushort3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::hypot (double s, const ushort3 &b)
 
__device__ __forceinline__ double4  cv::cudev::hypot (const ushort4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::hypot (double s, const ushort4 &b)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const short1 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const short3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (float s, const short1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const short2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::hypot (float s, const short2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (float s, const short3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const short4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::hypot (float s, const short4 &b)
 
__device__ __forceinline__ double3  cv::cudev::hypot (const short3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::hypot (const short1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::hypot (double s, const short1 &b)
 
__device__ __forceinline__ double2  cv::cudev::hypot (const short2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::hypot (double s, const short2 &b)
 
__device__ __forceinline__ double3  cv::cudev::hypot (double s, const short3 &b)
 
__device__ __forceinline__ double4  cv::cudev::hypot (const short4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::hypot (double s, const short4 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const uint3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const uint1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (float s, const uint1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const uint2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::hypot (float s, const uint2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (float s, const uint3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const uint4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::hypot (float s, const uint4 &b)
 
__device__ __forceinline__ double1  cv::cudev::hypot (const uint1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::hypot (double s, const uint1 &b)
 
__device__ __forceinline__ double2  cv::cudev::hypot (const uint2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::hypot (double s, const uint2 &b)
 
__device__ __forceinline__ double3  cv::cudev::hypot (const uint3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::hypot (double s, const uint3 &b)
 
__device__ __forceinline__ double4  cv::cudev::hypot (const uint4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::hypot (double s, const uint4 &b)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const int1 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const int3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (float s, const int1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const int2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::hypot (float s, const int2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (float s, const int3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const int4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::hypot (float s, const int4 &b)
 
__device__ __forceinline__ double1  cv::cudev::hypot (const int1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::hypot (double s, const int1 &b)
 
__device__ __forceinline__ double2  cv::cudev::hypot (const int2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::hypot (double s, const int2 &b)
 
__device__ __forceinline__ double3  cv::cudev::hypot (const int3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::hypot (double s, const int3 &b)
 
__device__ __forceinline__ double4  cv::cudev::hypot (const int4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::hypot (double s, const int4 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (const float3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (const float1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::hypot (float s, const float1 &b)
 
__device__ __forceinline__ float2  cv::cudev::hypot (const float2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::hypot (float s, const float2 &b)
 
__device__ __forceinline__ float3  cv::cudev::hypot (float s, const float3 &b)
 
__device__ __forceinline__ float4  cv::cudev::hypot (const float4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::hypot (float s, const float4 &b)
 
__device__ __forceinline__ double1  cv::cudev::hypot (const float1 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::hypot (const float2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::hypot (double s, const float2 &b)
 
__device__ __forceinline__ double3  cv::cudev::hypot (const float3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::hypot (double s, const float3 &b)
 
__device__ __forceinline__ double4  cv::cudev::hypot (const float4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::hypot (double s, const float4 &b)
 
__device__ __forceinline__ double1  cv::cudev::hypot (double s, const float1 &b)
 
__device__ __forceinline__ double2  cv::cudev::hypot (const double2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::hypot (double s, const double2 &b)
 
__device__ __forceinline__ double1  cv::cudev::hypot (double s, const double1 &b)
 
__device__ __forceinline__ double4  cv::cudev::hypot (const double4 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::hypot (double s, const double3 &b)
 
__device__ __forceinline__ double1  cv::cudev::hypot (const double1 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::hypot (double s, const double4 &b)
 
__device__ __forceinline__ double3  cv::cudev::hypot (const double3 &a, double s)
 
__device__ __forceinline__ float1  cv::cudev::log (const uchar1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log (const uchar3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log (const uchar4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log (const int1 &a)
 
__device__ __forceinline__ float3  cv::cudev::log (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log (const int4 &a)
 
__device__ __forceinline__ float2  cv::cudev::log (const int2 &a)
 
__device__ __forceinline__ float1  cv::cudev::log (const uint1 &a)
 
__device__ __forceinline__ float3  cv::cudev::log (const uint3 &a)
 
__device__ __forceinline__ float2  cv::cudev::log (const uint2 &a)
 
__device__ __forceinline__ float4  cv::cudev::log (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log (const float1 &a)
 
__device__ __forceinline__ float3  cv::cudev::log (const float3 &a)
 
__device__ __forceinline__ float2  cv::cudev::log (const float2 &a)
 
__device__ __forceinline__ float4  cv::cudev::log (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::log (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::log (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::log (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::log (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log10 (const uchar1 &a)
 
__device__ __forceinline__ float4  cv::cudev::log10 (const uchar4 &a)
 
__device__ __forceinline__ float2  cv::cudev::log10 (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log10 (const uchar3 &a)
 
__device__ __forceinline__ float1  cv::cudev::log10 (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log10 (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log10 (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log10 (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log10 (const ushort1 &a)
 
__device__ __forceinline__ float3  cv::cudev::log10 (const ushort3 &a)
 
__device__ __forceinline__ float2  cv::cudev::log10 (const ushort2 &a)
 
__device__ __forceinline__ float4  cv::cudev::log10 (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log10 (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log10 (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log10 (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log10 (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log10 (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log10 (const int2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log10 (const int3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log10 (const int4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log10 (const uint1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log10 (const uint2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log10 (const uint3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log10 (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log10 (const float1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log10 (const float2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log10 (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log10 (const float4 &a)
 
__device__ __forceinline__ double1  cv::cudev::log10 (const double1 &a)
 
__device__ __forceinline__ double2  cv::cudev::log10 (const double2 &a)
 
__device__ __forceinline__ double3  cv::cudev::log10 (const double3 &a)
 
__device__ __forceinline__ double4  cv::cudev::log10 (const double4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log2 (const uchar1 &a)
 
__device__ __forceinline__ float4  cv::cudev::log2 (const uchar4 &a)
 
__device__ __forceinline__ float2  cv::cudev::log2 (const uchar2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log2 (const uchar3 &a)
 
__device__ __forceinline__ float1  cv::cudev::log2 (const char1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log2 (const char2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log2 (const char3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log2 (const char4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log2 (const ushort1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log2 (const ushort2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log2 (const ushort3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log2 (const ushort4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log2 (const short1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log2 (const short2 &a)
 
__device__ __forceinline__ float3  cv::cudev::log2 (const short3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log2 (const short4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log2 (const int1 &a)
 
__device__ __forceinline__ float2  cv::cudev::log2 (const int2 &a)
 
__device__ __forceinline__ float4  cv::cudev::log2 (const int4 &a)
 
__device__ __forceinline__ float3  cv::cudev::log2 (const int3 &a)
 
__device__ __forceinline__ float1  cv::cudev::log2 (const uint1 &a)
 
__device__ __forceinline__ float3  cv::cudev::log2 (const uint3 &a)
 
__device__ __forceinline__ float2  cv::cudev::log2 (const uint2 &a)
 
__device__ __forceinline__ float4  cv::cudev::log2 (const uint4 &a)
 
__device__ __forceinline__ float1  cv::cudev::log2 (const float1 &a)
 
__device__ __forceinline__ float3  cv::cudev::log2 (const float3 &a)
 
__device__ __forceinline__ float4  cv::cudev::log2 (const float4 &a)
 
__device__ __forceinline__ float2  cv::cudev::log2 (const float2 &a)
 
__device__ __forceinline__ double1  cv::cudev::log2 (const double1 &a)
 
__device__ __forceinline__ double3  cv::cudev::log2 (const double3 &a)
 
__device__ __forceinline__ double2  cv::cudev::log2 (const double2 &a)
 
__device__ __forceinline__ double4  cv::cudev::log2 (const double4 &a)
 
__device__ __forceinline__ uchar1  cv::cudev::max (const uchar1 &a, const uchar1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::max (const uchar2 &a, const uchar2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::max (const uchar3 &a, const uchar3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::max (const uchar4 &a, const uchar4 &b)
 
__device__ __forceinline__ char1  cv::cudev::max (const char1 &a, const char1 &b)
 
__device__ __forceinline__ char2  cv::cudev::max (const char2 &a, const char2 &b)
 
__device__ __forceinline__ char3  cv::cudev::max (const char3 &a, const char3 &b)
 
__device__ __forceinline__ char4  cv::cudev::max (const char4 &a, const char4 &b)
 
__device__ __forceinline__ ushort1  cv::cudev::max (const ushort1 &a, const ushort1 &b)
 
__device__ __forceinline__ ushort2  cv::cudev::max (const ushort2 &a, const ushort2 &b)
 
__device__ __forceinline__ ushort3  cv::cudev::max (const ushort3 &a, const ushort3 &b)
 
__device__ __forceinline__ ushort4  cv::cudev::max (const ushort4 &a, const ushort4 &b)
 
__device__ __forceinline__ short1  cv::cudev::max (const short1 &a, const short1 &b)
 
__device__ __forceinline__ short2  cv::cudev::max (const short2 &a, const short2 &b)
 
__device__ __forceinline__ short3  cv::cudev::max (const short3 &a, const short3 &b)
 
__device__ __forceinline__ short4  cv::cudev::max (const short4 &a, const short4 &b)
 
__device__ __forceinline__ uint2  cv::cudev::max (const uint2 &a, const uint2 &b)
 
__device__ __forceinline__ uint3  cv::cudev::max (const uint3 &a, const uint3 &b)
 
__device__ __forceinline__ uint4  cv::cudev::max (const uint4 &a, const uint4 &b)
 
__device__ __forceinline__ uint1  cv::cudev::max (const uint1 &a, const uint1 &b)
 
__device__ __forceinline__ int2  cv::cudev::max (const int2 &a, const int2 &b)
 
__device__ __forceinline__ int3  cv::cudev::max (const int3 &a, const int3 &b)
 
__device__ __forceinline__ int4  cv::cudev::max (const int4 &a, const int4 &b)
 
__device__ __forceinline__ int1  cv::cudev::max (const int1 &a, const int1 &b)
 
__device__ __forceinline__ float2  cv::cudev::max (const float2 &a, const float2 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (const float3 &a, const float3 &b)
 
__device__ __forceinline__ float4  cv::cudev::max (const float4 &a, const float4 &b)
 
__device__ __forceinline__ float1  cv::cudev::max (const float1 &a, const float1 &b)
 
__device__ __forceinline__ double1  cv::cudev::max (const double1 &a, const double1 &b)
 
__device__ __forceinline__ double2  cv::cudev::max (const double2 &a, const double2 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (const double3 &a, const double3 &b)
 
__device__ __forceinline__ double4  cv::cudev::max (const double4 &a, const double4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::max (const uchar1 &a, uchar s)
 
__device__ __forceinline__ uchar1  cv::cudev::max ( uchar s, const uchar1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::max (const uchar2 &a, uchar s)
 
__device__ __forceinline__ uchar2  cv::cudev::max ( uchar s, const uchar2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::max ( uchar s, const uchar3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::max (const uchar4 &a, uchar s)
 
__device__ __forceinline__ uchar4  cv::cudev::max ( uchar s, const uchar4 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::max (const uchar3 &a, uchar s)
 
__device__ __forceinline__ float3  cv::cudev::max (const uchar3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::max (float s, const uchar1 &b)
 
__device__ __forceinline__ float2  cv::cudev::max (const uchar2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::max (float s, const uchar2 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (float s, const uchar3 &b)
 
__device__ __forceinline__ float4  cv::cudev::max (const uchar4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::max (float s, const uchar4 &b)
 
__device__ __forceinline__ float1  cv::cudev::max (const uchar1 &a, float s)
 
__device__ __forceinline__ double3  cv::cudev::max (const uchar3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::max (const uchar1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::max (double s, const uchar1 &b)
 
__device__ __forceinline__ double2  cv::cudev::max (const uchar2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::max (double s, const uchar2 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (double s, const uchar3 &b)
 
__device__ __forceinline__ double4  cv::cudev::max (const uchar4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::max (double s, const uchar4 &b)
 
__device__ __forceinline__ char3  cv::cudev::max (const char3 &a, char s)
 
__device__ __forceinline__ char1  cv::cudev::max (const char1 &a, char s)
 
__device__ __forceinline__ char1  cv::cudev::max (char s, const char1 &b)
 
__device__ __forceinline__ char2  cv::cudev::max (const char2 &a, char s)
 
__device__ __forceinline__ char2  cv::cudev::max (char s, const char2 &b)
 
__device__ __forceinline__ char3  cv::cudev::max (char s, const char3 &b)
 
__device__ __forceinline__ char4  cv::cudev::max (const char4 &a, char s)
 
__device__ __forceinline__ char4  cv::cudev::max (char s, const char4 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (const char3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::max (const char1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::max (float s, const char1 &b)
 
__device__ __forceinline__ float2  cv::cudev::max (const char2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::max (float s, const char2 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (float s, const char3 &b)
 
__device__ __forceinline__ float4  cv::cudev::max (const char4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::max (float s, const char4 &b)
 
__device__ __forceinline__ double1  cv::cudev::max (double s, const char1 &b)
 
__device__ __forceinline__ double2  cv::cudev::max (const char2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::max (double s, const char2 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (double s, const char3 &b)
 
__device__ __forceinline__ double4  cv::cudev::max (const char4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::max (double s, const char4 &b)
 
__device__ __forceinline__ double1  cv::cudev::max (const char1 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::max (const char3 &a, double s)
 
__device__ __forceinline__ ushort1  cv::cudev::max ( ushort s, const ushort1 &b)
 
__device__ __forceinline__ ushort2  cv::cudev::max (const ushort2 &a, ushort s)
 
__device__ __forceinline__ ushort2  cv::cudev::max ( ushort s, const ushort2 &b)
 
__device__ __forceinline__ ushort3  cv::cudev::max ( ushort s, const ushort3 &b)
 
__device__ __forceinline__ ushort4  cv::cudev::max (const ushort4 &a, ushort s)
 
__device__ __forceinline__ ushort4  cv::cudev::max ( ushort s, const ushort4 &b)
 
__device__ __forceinline__ ushort3  cv::cudev::max (const ushort3 &a, ushort s)
 
__device__ __forceinline__ ushort1  cv::cudev::max (const ushort1 &a, ushort s)
 
__device__ __forceinline__ float1  cv::cudev::max (float s, const ushort1 &b)
 
__device__ __forceinline__ float2  cv::cudev::max (const ushort2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::max (float s, const ushort2 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (float s, const ushort3 &b)
 
__device__ __forceinline__ float4  cv::cudev::max (const ushort4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::max (float s, const ushort4 &b)
 
__device__ __forceinline__ float1  cv::cudev::max (const ushort1 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::max (const ushort3 &a, float s)
 
__device__ __forceinline__ double1  cv::cudev::max (double s, const ushort1 &b)
 
__device__ __forceinline__ double2  cv::cudev::max (const ushort2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::max (double s, const ushort2 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (double s, const ushort3 &b)
 
__device__ __forceinline__ double4  cv::cudev::max (const ushort4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::max (double s, const ushort4 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (const ushort3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::max (const ushort1 &a, double s)
 
__device__ __forceinline__ short3  cv::cudev::max (const short3 &a, short s)
 
__device__ __forceinline__ short1  cv::cudev::max (const short1 &a, short s)
 
__device__ __forceinline__ short1  cv::cudev::max (short s, const short1 &b)
 
__device__ __forceinline__ short2  cv::cudev::max (const short2 &a, short s)
 
__device__ __forceinline__ short2  cv::cudev::max (short s, const short2 &b)
 
__device__ __forceinline__ short3  cv::cudev::max (short s, const short3 &b)
 
__device__ __forceinline__ short4  cv::cudev::max (const short4 &a, short s)
 
__device__ __forceinline__ short4  cv::cudev::max (short s, const short4 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (const short3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::max (const short1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::max (float s, const short1 &b)
 
__device__ __forceinline__ float2  cv::cudev::max (const short2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::max (float s, const short2 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (float s, const short3 &b)
 
__device__ __forceinline__ float4  cv::cudev::max (const short4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::max (float s, const short4 &b)
 
__device__ __forceinline__ double1  cv::cudev::max (double s, const short1 &b)
 
__device__ __forceinline__ double2  cv::cudev::max (const short2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::max (double s, const short2 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (const short3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::max (double s, const short3 &b)
 
__device__ __forceinline__ double4  cv::cudev::max (const short4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::max (double s, const short4 &b)
 
__device__ __forceinline__ double1  cv::cudev::max (const short1 &a, double s)
 
__device__ __forceinline__ uint1  cv::cudev::max ( uint s, const uint1 &b)
 
__device__ __forceinline__ uint2  cv::cudev::max (const uint2 &a, uint s)
 
__device__ __forceinline__ uint2  cv::cudev::max ( uint s, const uint2 &b)
 
__device__ __forceinline__ uint3  cv::cudev::max ( uint s, const uint3 &b)
 
__device__ __forceinline__ uint4  cv::cudev::max (const uint4 &a, uint s)
 
__device__ __forceinline__ uint4  cv::cudev::max ( uint s, const uint4 &b)
 
__device__ __forceinline__ uint3  cv::cudev::max (const uint3 &a, uint s)
 
__device__ __forceinline__ uint1  cv::cudev::max (const uint1 &a, uint s)
 
__device__ __forceinline__ float1  cv::cudev::max (float s, const uint1 &b)
 
__device__ __forceinline__ float2  cv::cudev::max (const uint2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::max (float s, const uint2 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (float s, const uint3 &b)
 
__device__ __forceinline__ float4  cv::cudev::max (const uint4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::max (float s, const uint4 &b)
 
__device__ __forceinline__ float1  cv::cudev::max (const uint1 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::max (const uint3 &a, float s)
 
__device__ __forceinline__ double1  cv::cudev::max (double s, const uint1 &b)
 
__device__ __forceinline__ double2  cv::cudev::max (const uint2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::max (double s, const uint2 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (double s, const uint3 &b)
 
__device__ __forceinline__ double4  cv::cudev::max (const uint4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::max (double s, const uint4 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (const uint3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::max (const uint1 &a, double s)
 
__device__ __forceinline__ int1  cv::cudev::max (int s, const int1 &b)
 
__device__ __forceinline__ int2  cv::cudev::max (const int2 &a, int s)
 
__device__ __forceinline__ int2  cv::cudev::max (int s, const int2 &b)
 
__device__ __forceinline__ int3  cv::cudev::max (int s, const int3 &b)
 
__device__ __forceinline__ int4  cv::cudev::max (const int4 &a, int s)
 
__device__ __forceinline__ int4  cv::cudev::max (int s, const int4 &b)
 
__device__ __forceinline__ int1  cv::cudev::max (const int1 &a, int s)
 
__device__ __forceinline__ int3  cv::cudev::max (const int3 &a, int s)
 
__device__ __forceinline__ float1  cv::cudev::max (float s, const int1 &b)
 
__device__ __forceinline__ float2  cv::cudev::max (const int2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::max (float s, const int2 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (float s, const int3 &b)
 
__device__ __forceinline__ float4  cv::cudev::max (const int4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::max (float s, const int4 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (const int3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::max (const int1 &a, float s)
 
__device__ __forceinline__ double1  cv::cudev::max (const int1 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::max (const int3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::max (double s, const int1 &b)
 
__device__ __forceinline__ double2  cv::cudev::max (const int2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::max (double s, const int2 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (double s, const int3 &b)
 
__device__ __forceinline__ double4  cv::cudev::max (const int4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::max (double s, const int4 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (const float3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::max (const float1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::max (float s, const float1 &b)
 
__device__ __forceinline__ float2  cv::cudev::max (const float2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::max (float s, const float2 &b)
 
__device__ __forceinline__ float3  cv::cudev::max (float s, const float3 &b)
 
__device__ __forceinline__ float4  cv::cudev::max (const float4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::max (float s, const float4 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (const float3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::max (const float1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::max (double s, const float1 &b)
 
__device__ __forceinline__ double2  cv::cudev::max (const float2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::max (double s, const float2 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (double s, const float3 &b)
 
__device__ __forceinline__ double4  cv::cudev::max (const float4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::max (double s, const float4 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (const double3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::max (const double1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::max (double s, const double1 &b)
 
__device__ __forceinline__ double2  cv::cudev::max (const double2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::max (double s, const double2 &b)
 
__device__ __forceinline__ double3  cv::cudev::max (double s, const double3 &b)
 
__device__ __forceinline__ double4  cv::cudev::max (const double4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::max (double s, const double4 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::min (const uchar2 &a, const uchar2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::min (const uchar3 &a, const uchar3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::min (const uchar4 &a, const uchar4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::min (const uchar1 &a, const uchar1 &b)
 
__device__ __forceinline__ char2  cv::cudev::min (const char2 &a, const char2 &b)
 
__device__ __forceinline__ char3  cv::cudev::min (const char3 &a, const char3 &b)
 
__device__ __forceinline__ char4  cv::cudev::min (const char4 &a, const char4 &b)
 
__device__ __forceinline__ char1  cv::cudev::min (const char1 &a, const char1 &b)
 
__device__ __forceinline__ ushort2  cv::cudev::min (const ushort2 &a, const ushort2 &b)
 
__device__ __forceinline__ ushort3  cv::cudev::min (const ushort3 &a, const ushort3 &b)
 
__device__ __forceinline__ ushort4  cv::cudev::min (const ushort4 &a, const ushort4 &b)
 
__device__ __forceinline__ ushort1  cv::cudev::min (const ushort1 &a, const ushort1 &b)
 
__device__ __forceinline__ short1  cv::cudev::min (const short1 &a, const short1 &b)
 
__device__ __forceinline__ short2  cv::cudev::min (const short2 &a, const short2 &b)
 
__device__ __forceinline__ short3  cv::cudev::min (const short3 &a, const short3 &b)
 
__device__ __forceinline__ short4  cv::cudev::min (const short4 &a, const short4 &b)
 
__device__ __forceinline__ uint2  cv::cudev::min (const uint2 &a, const uint2 &b)
 
__device__ __forceinline__ uint3  cv::cudev::min (const uint3 &a, const uint3 &b)
 
__device__ __forceinline__ uint4  cv::cudev::min (const uint4 &a, const uint4 &b)
 
__device__ __forceinline__ uint1  cv::cudev::min (const uint1 &a, const uint1 &b)
 
__device__ __forceinline__ int2  cv::cudev::min (const int2 &a, const int2 &b)
 
__device__ __forceinline__ int3  cv::cudev::min (const int3 &a, const int3 &b)
 
__device__ __forceinline__ int4  cv::cudev::min (const int4 &a, const int4 &b)
 
__device__ __forceinline__ int1  cv::cudev::min (const int1 &a, const int1 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (const float3 &a, const float3 &b)
 
__device__ __forceinline__ float4  cv::cudev::min (const float4 &a, const float4 &b)
 
__device__ __forceinline__ float2  cv::cudev::min (const float2 &a, const float2 &b)
 
__device__ __forceinline__ float1  cv::cudev::min (const float1 &a, const float1 &b)
 
__device__ __forceinline__ double1  cv::cudev::min (const double1 &a, const double1 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (const double3 &a, const double3 &b)
 
__device__ __forceinline__ double2  cv::cudev::min (const double2 &a, const double2 &b)
 
__device__ __forceinline__ double4  cv::cudev::min (const double4 &a, const double4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::min ( uchar s, const uchar1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::min (const uchar2 &a, uchar s)
 
__device__ __forceinline__ uchar2  cv::cudev::min ( uchar s, const uchar2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::min ( uchar s, const uchar3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::min (const uchar4 &a, uchar s)
 
__device__ __forceinline__ uchar4  cv::cudev::min ( uchar s, const uchar4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::min (const uchar1 &a, uchar s)
 
__device__ __forceinline__ uchar3  cv::cudev::min (const uchar3 &a, uchar s)
 
__device__ __forceinline__ float1  cv::cudev::min (float s, const uchar1 &b)
 
__device__ __forceinline__ float2  cv::cudev::min (const uchar2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::min (float s, const uchar2 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (float s, const uchar3 &b)
 
__device__ __forceinline__ float4  cv::cudev::min (const uchar4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::min (float s, const uchar4 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (const uchar3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::min (const uchar1 &a, float s)
 
__device__ __forceinline__ double1  cv::cudev::min (double s, const uchar1 &b)
 
__device__ __forceinline__ double2  cv::cudev::min (const uchar2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::min (double s, const uchar2 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (double s, const uchar3 &b)
 
__device__ __forceinline__ double4  cv::cudev::min (const uchar4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::min (double s, const uchar4 &b)
 
__device__ __forceinline__ double1  cv::cudev::min (const uchar1 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::min (const uchar3 &a, double s)
 
__device__ __forceinline__ char1  cv::cudev::min (char s, const char1 &b)
 
__device__ __forceinline__ char2  cv::cudev::min (const char2 &a, char s)
 
__device__ __forceinline__ char2  cv::cudev::min (char s, const char2 &b)
 
__device__ __forceinline__ char3  cv::cudev::min (char s, const char3 &b)
 
__device__ __forceinline__ char4  cv::cudev::min (const char4 &a, char s)
 
__device__ __forceinline__ char4  cv::cudev::min (char s, const char4 &b)
 
__device__ __forceinline__ char3  cv::cudev::min (const char3 &a, char s)
 
__device__ __forceinline__ char1  cv::cudev::min (const char1 &a, char s)
 
__device__ __forceinline__ float1  cv::cudev::min (const char1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::min (float s, const char1 &b)
 
__device__ __forceinline__ float2  cv::cudev::min (const char2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::min (float s, const char2 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (float s, const char3 &b)
 
__device__ __forceinline__ float4  cv::cudev::min (const char4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::min (float s, const char4 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (const char3 &a, float s)
 
__device__ __forceinline__ double1  cv::cudev::min (double s, const char1 &b)
 
__device__ __forceinline__ double2  cv::cudev::min (const char2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::min (double s, const char2 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (double s, const char3 &b)
 
__device__ __forceinline__ double4  cv::cudev::min (const char4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::min (double s, const char4 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (const char3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::min (const char1 &a, double s)
 
__device__ __forceinline__ ushort1  cv::cudev::min ( ushort s, const ushort1 &b)
 
__device__ __forceinline__ ushort2  cv::cudev::min (const ushort2 &a, ushort s)
 
__device__ __forceinline__ ushort2  cv::cudev::min ( ushort s, const ushort2 &b)
 
__device__ __forceinline__ ushort3  cv::cudev::min ( ushort s, const ushort3 &b)
 
__device__ __forceinline__ ushort4  cv::cudev::min (const ushort4 &a, ushort s)
 
__device__ __forceinline__ ushort4  cv::cudev::min ( ushort s, const ushort4 &b)
 
__device__ __forceinline__ ushort3  cv::cudev::min (const ushort3 &a, ushort s)
 
__device__ __forceinline__ ushort1  cv::cudev::min (const ushort1 &a, ushort s)
 
__device__ __forceinline__ float1  cv::cudev::min (float s, const ushort1 &b)
 
__device__ __forceinline__ float2  cv::cudev::min (const ushort2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::min (float s, const ushort2 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (float s, const ushort3 &b)
 
__device__ __forceinline__ float4  cv::cudev::min (const ushort4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::min (float s, const ushort4 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (const ushort3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::min (const ushort1 &a, float s)
 
__device__ __forceinline__ double1  cv::cudev::min (double s, const ushort1 &b)
 
__device__ __forceinline__ double2  cv::cudev::min (const ushort2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::min (double s, const ushort2 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (double s, const ushort3 &b)
 
__device__ __forceinline__ double4  cv::cudev::min (const ushort4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::min (double s, const ushort4 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (const ushort3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::min (const ushort1 &a, double s)
 
__device__ __forceinline__ short1  cv::cudev::min (short s, const short1 &b)
 
__device__ __forceinline__ short2  cv::cudev::min (short s, const short2 &b)
 
__device__ __forceinline__ short3  cv::cudev::min (short s, const short3 &b)
 
__device__ __forceinline__ short4  cv::cudev::min (short s, const short4 &b)
 
__device__ __forceinline__ short4  cv::cudev::min (const short4 &a, short s)
 
__device__ __forceinline__ short3  cv::cudev::min (const short3 &a, short s)
 
__device__ __forceinline__ short2  cv::cudev::min (const short2 &a, short s)
 
__device__ __forceinline__ short1  cv::cudev::min (const short1 &a, short s)
 
__device__ __forceinline__ float4  cv::cudev::min (const short4 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::min (float s, const short1 &b)
 
__device__ __forceinline__ float2  cv::cudev::min (const short2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::min (float s, const short2 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (float s, const short3 &b)
 
__device__ __forceinline__ float4  cv::cudev::min (float s, const short4 &b)
 
__device__ __forceinline__ float1  cv::cudev::min (const short1 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::min (const short3 &a, float s)
 
__device__ __forceinline__ double4  cv::cudev::min (const short4 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::min (double s, const short1 &b)
 
__device__ __forceinline__ double2  cv::cudev::min (double s, const short2 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (double s, const short3 &b)
 
__device__ __forceinline__ double4  cv::cudev::min (double s, const short4 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (const short3 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::min (const short2 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::min (const short1 &a, double s)
 
__device__ __forceinline__ uint1  cv::cudev::min ( uint s, const uint1 &b)
 
__device__ __forceinline__ uint2  cv::cudev::min ( uint s, const uint2 &b)
 
__device__ __forceinline__ uint3  cv::cudev::min ( uint s, const uint3 &b)
 
__device__ __forceinline__ uint4  cv::cudev::min ( uint s, const uint4 &b)
 
__device__ __forceinline__ uint4  cv::cudev::min (const uint4 &a, uint s)
 
__device__ __forceinline__ uint2  cv::cudev::min (const uint2 &a, uint s)
 
__device__ __forceinline__ uint3  cv::cudev::min (const uint3 &a, uint s)
 
__device__ __forceinline__ uint1  cv::cudev::min (const uint1 &a, uint s)
 
__device__ __forceinline__ float1  cv::cudev::min (float s, const uint1 &b)
 
__device__ __forceinline__ float2  cv::cudev::min (const uint2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::min (float s, const uint2 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (float s, const uint3 &b)
 
__device__ __forceinline__ float4  cv::cudev::min (float s, const uint4 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (const uint3 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::min (const uint4 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::min (const uint1 &a, float s)
 
__device__ __forceinline__ double1  cv::cudev::min (double s, const uint1 &b)
 
__device__ __forceinline__ double2  cv::cudev::min (const uint2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::min (double s, const uint2 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (double s, const uint3 &b)
 
__device__ __forceinline__ double4  cv::cudev::min (const uint4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::min (double s, const uint4 &b)
 
__device__ __forceinline__ double1  cv::cudev::min (const uint1 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::min (const uint3 &a, double s)
 
__device__ __forceinline__ int4  cv::cudev::min (const int4 &a, int s)
 
__device__ __forceinline__ int1  cv::cudev::min (int s, const int1 &b)
 
__device__ __forceinline__ int2  cv::cudev::min (const int2 &a, int s)
 
__device__ __forceinline__ int2  cv::cudev::min (int s, const int2 &b)
 
__device__ __forceinline__ int3  cv::cudev::min (int s, const int3 &b)
 
__device__ __forceinline__ int4  cv::cudev::min (int s, const int4 &b)
 
__device__ __forceinline__ int3  cv::cudev::min (const int3 &a, int s)
 
__device__ __forceinline__ int1  cv::cudev::min (const int1 &a, int s)
 
__device__ __forceinline__ float1  cv::cudev::min (float s, const int1 &b)
 
__device__ __forceinline__ float2  cv::cudev::min (const int2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::min (float s, const int2 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (float s, const int3 &b)
 
__device__ __forceinline__ float4  cv::cudev::min (const int4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::min (float s, const int4 &b)
 
__device__ __forceinline__ float1  cv::cudev::min (const int1 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::min (const int3 &a, float s)
 
__device__ __forceinline__ double4  cv::cudev::min (const int4 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::min (double s, const int1 &b)
 
__device__ __forceinline__ double2  cv::cudev::min (const int2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::min (double s, const int2 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (double s, const int3 &b)
 
__device__ __forceinline__ double4  cv::cudev::min (double s, const int4 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (const int3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::min (const int1 &a, double s)
 
__device__ __forceinline__ float1  cv::cudev::min (float s, const float1 &b)
 
__device__ __forceinline__ float2  cv::cudev::min (const float2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::min (float s, const float2 &b)
 
__device__ __forceinline__ float3  cv::cudev::min (float s, const float3 &b)
 
__device__ __forceinline__ float4  cv::cudev::min (const float4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::min (float s, const float4 &b)
 
__device__ __forceinline__ float1  cv::cudev::min (const float1 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::min (const float3 &a, float s)
 
__device__ __forceinline__ double4  cv::cudev::min (const float4 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::min (double s, const float1 &b)
 
__device__ __forceinline__ double2  cv::cudev::min (const float2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::min (double s, const float2 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (double s, const float3 &b)
 
__device__ __forceinline__ double4  cv::cudev::min (double s, const float4 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (const float3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::min (const float1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::min (double s, const double1 &b)
 
__device__ __forceinline__ double2  cv::cudev::min (const double2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::min (double s, const double2 &b)
 
__device__ __forceinline__ double3  cv::cudev::min (double s, const double3 &b)
 
__device__ __forceinline__ double4  cv::cudev::min (const double4 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::min (const double3 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::min (double s, const double4 &b)
 
__device__ __forceinline__ double1  cv::cudev::min (const double1 &a, double s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator! (const uchar1 &a)
 
__device__ __forceinline__ uchar2  cv::cudev::operator! (const uchar2 &a)
 
__device__ __forceinline__ uchar3  cv::cudev::operator! (const uchar3 &a)
 
__device__ __forceinline__ uchar4  cv::cudev::operator! (const uchar4 &a)
 
__device__ __forceinline__ uchar1  cv::cudev::operator! (const char1 &a)
 
__device__ __forceinline__ uchar2  cv::cudev::operator! (const char2 &a)
 
__device__ __forceinline__ uchar3  cv::cudev::operator! (const char3 &a)
 
__device__ __forceinline__ uchar4  cv::cudev::operator! (const char4 &a)
 
__device__ __forceinline__ uchar4  cv::cudev::operator! (const ushort4 &a)
 
__device__ __forceinline__ uchar1  cv::cudev::operator! (const ushort1 &a)
 
__device__ __forceinline__ uchar2  cv::cudev::operator! (const ushort2 &a)
 
__device__ __forceinline__ uchar3  cv::cudev::operator! (const ushort3 &a)
 
__device__ __forceinline__ uchar3  cv::cudev::operator! (const short3 &a)
 
__device__ __forceinline__ uchar1  cv::cudev::operator! (const short1 &a)
 
__device__ __forceinline__ uchar2  cv::cudev::operator! (const short2 &a)
 
__device__ __forceinline__ uchar4  cv::cudev::operator! (const short4 &a)
 
__device__ __forceinline__ uchar1  cv::cudev::operator! (const int1 &a)
 
__device__ __forceinline__ uchar2  cv::cudev::operator! (const int2 &a)
 
__device__ __forceinline__ uchar3  cv::cudev::operator! (const int3 &a)
 
__device__ __forceinline__ uchar4  cv::cudev::operator! (const int4 &a)
 
__device__ __forceinline__ uchar1  cv::cudev::operator! (const uint1 &a)
 
__device__ __forceinline__ uchar2  cv::cudev::operator! (const uint2 &a)
 
__device__ __forceinline__ uchar3  cv::cudev::operator! (const uint3 &a)
 
__device__ __forceinline__ uchar4  cv::cudev::operator! (const uint4 &a)
 
__device__ __forceinline__ uchar1  cv::cudev::operator! (const float1 &a)
 
__device__ __forceinline__ uchar2  cv::cudev::operator! (const float2 &a)
 
__device__ __forceinline__ uchar3  cv::cudev::operator! (const float3 &a)
 
__device__ __forceinline__ uchar4  cv::cudev::operator! (const float4 &a)
 
__device__ __forceinline__ uchar2  cv::cudev::operator! (const double2 &a)
 
__device__ __forceinline__ uchar3  cv::cudev::operator! (const double3 &a)
 
__device__ __forceinline__ uchar1  cv::cudev::operator! (const double1 &a)
 
__device__ __forceinline__ uchar4  cv::cudev::operator! (const double4 &a)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const uchar1 &a, const uchar1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const uchar2 &a, const uchar2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const uchar3 &a, const uchar3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const uchar4 &a, const uchar4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const char1 &a, const char1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const char2 &a, const char2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const char3 &a, const char3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const char4 &a, const char4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const ushort1 &a, const ushort1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const ushort2 &a, const ushort2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const ushort3 &a, const ushort3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const ushort4 &a, const ushort4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const short1 &a, const short1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const short2 &a, const short2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const short3 &a, const short3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const short4 &a, const short4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const int1 &a, const int1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const int2 &a, const int2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const int3 &a, const int3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const int4 &a, const int4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const uint1 &a, const uint1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const uint2 &a, const uint2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const uint3 &a, const uint3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const uint4 &a, const uint4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const float1 &a, const float1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const float2 &a, const float2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const float3 &a, const float3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const float4 &a, const float4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const double1 &a, const double1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const double2 &a, const double2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const double3 &a, const double3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const double4 &a, const double4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const uchar1 &a, uchar s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= ( uchar s, const uchar1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const uchar2 &a, uchar s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= ( uchar s, const uchar2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const uchar3 &a, uchar s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= ( uchar s, const uchar3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const uchar4 &a, uchar s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= ( uchar s, const uchar4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const char1 &a, char s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (char s, const char1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const char2 &a, char s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (char s, const char2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const char3 &a, char s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (char s, const char3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const char4 &a, char s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (char s, const char4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const ushort1 &a, ushort s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= ( ushort s, const ushort1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const ushort2 &a, ushort s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= ( ushort s, const ushort2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const ushort3 &a, ushort s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= ( ushort s, const ushort3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const ushort4 &a, ushort s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= ( ushort s, const ushort4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const short1 &a, short s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (short s, const short1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const short2 &a, short s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (short s, const short2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const short3 &a, short s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (short s, const short3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const short4 &a, short s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (short s, const short4 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const int3 &a, int s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const int1 &a, int s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (int s, const int1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const int2 &a, int s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (int s, const int2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (int s, const int3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const int4 &a, int s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (int s, const int4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const uint1 &a, uint s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= ( uint s, const uint1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const uint2 &a, uint s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= ( uint s, const uint2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const uint3 &a, uint s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= ( uint s, const uint3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const uint4 &a, uint s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= ( uint s, const uint4 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const float3 &a, float s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const float1 &a, float s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (float s, const float1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const float2 &a, float s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (float s, const float2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (float s, const float3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const float4 &a, float s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (float s, const float4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (const double1 &a, double s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator!= (double s, const double1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (const double2 &a, double s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator!= (double s, const double2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (const double3 &a, double s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator!= (double s, const double3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (const double4 &a, double s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator!= (double s, const double4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator& (const uchar1 &a, const uchar1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator& (const uchar2 &a, const uchar2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator& (const uchar3 &a, const uchar3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator& (const uchar4 &a, const uchar4 &b)
 
__device__ __forceinline__ char1  cv::cudev::operator& (const char1 &a, const char1 &b)
 
__device__ __forceinline__ char2  cv::cudev::operator& (const char2 &a, const char2 &b)
 
__device__ __forceinline__ char3  cv::cudev::operator& (const char3 &a, const char3 &b)
 
__device__ __forceinline__ char4  cv::cudev::operator& (const char4 &a, const char4 &b)
 
__device__ __forceinline__ ushort1  cv::cudev::operator& (const ushort1 &a, const ushort1 &b)
 
__device__ __forceinline__ ushort2  cv::cudev::operator& (const ushort2 &a, const ushort2 &b)
 
__device__ __forceinline__ ushort3  cv::cudev::operator& (const ushort3 &a, const ushort3 &b)
 
__device__ __forceinline__ ushort4  cv::cudev::operator& (const ushort4 &a, const ushort4 &b)
 
__device__ __forceinline__ short1  cv::cudev::operator& (const short1 &a, const short1 &b)
 
__device__ __forceinline__ short2  cv::cudev::operator& (const short2 &a, const short2 &b)
 
__device__ __forceinline__ short3  cv::cudev::operator& (const short3 &a, const short3 &b)
 
__device__ __forceinline__ short4  cv::cudev::operator& (const short4 &a, const short4 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator& (const int1 &a, const int1 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator& (const int2 &a, const int2 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator& (const int3 &a, const int3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator& (const int4 &a, const int4 &b)
 
__device__ __forceinline__ uint1  cv::cudev::operator& (const uint1 &a, const uint1 &b)
 
__device__ __forceinline__ uint2  cv::cudev::operator& (const uint2 &a, const uint2 &b)
 
__device__ __forceinline__ uint3  cv::cudev::operator& (const uint3 &a, const uint3 &b)
 
__device__ __forceinline__ uint4  cv::cudev::operator& (const uint4 &a, const uint4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator& (const uchar1 &a, uchar s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator& ( uchar s, const uchar1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator& (const uchar2 &a, uchar s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator& ( uchar s, const uchar2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator& ( uchar s, const uchar3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator& (const uchar4 &a, uchar s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator& ( uchar s, const uchar4 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator& (const uchar3 &a, uchar s)
 
__device__ __forceinline__ char1  cv::cudev::operator& (char s, const char1 &b)
 
__device__ __forceinline__ char2  cv::cudev::operator& (const char2 &a, char s)
 
__device__ __forceinline__ char2  cv::cudev::operator& (char s, const char2 &b)
 
__device__ __forceinline__ char3  cv::cudev::operator& (char s, const char3 &b)
 
__device__ __forceinline__ char4  cv::cudev::operator& (const char4 &a, char s)
 
__device__ __forceinline__ char4  cv::cudev::operator& (char s, const char4 &b)
 
__device__ __forceinline__ char1  cv::cudev::operator& (const char1 &a, char s)
 
__device__ __forceinline__ char3  cv::cudev::operator& (const char3 &a, char s)
 
__device__ __forceinline__ ushort1  cv::cudev::operator& ( ushort s, const ushort1 &b)
 
__device__ __forceinline__ ushort2  cv::cudev::operator& (const ushort2 &a, ushort s)
 
__device__ __forceinline__ ushort2  cv::cudev::operator& ( ushort s, const ushort2 &b)
 
__device__ __forceinline__ ushort3  cv::cudev::operator& ( ushort s, const ushort3 &b)
 
__device__ __forceinline__ ushort4  cv::cudev::operator& (const ushort4 &a, ushort s)
 
__device__ __forceinline__ ushort4  cv::cudev::operator& ( ushort s, const ushort4 &b)
 
__device__ __forceinline__ ushort3  cv::cudev::operator& (const ushort3 &a, ushort s)
 
__device__ __forceinline__ ushort1  cv::cudev::operator& (const ushort1 &a, ushort s)
 
__device__ __forceinline__ short1  cv::cudev::operator& (short s, const short1 &b)
 
__device__ __forceinline__ short2  cv::cudev::operator& (const short2 &a, short s)
 
__device__ __forceinline__ short2  cv::cudev::operator& (short s, const short2 &b)
 
__device__ __forceinline__ short3  cv::cudev::operator& (const short3 &a, short s)
 
__device__ __forceinline__ short3  cv::cudev::operator& (short s, const short3 &b)
 
__device__ __forceinline__ short4  cv::cudev::operator& (const short4 &a, short s)
 
__device__ __forceinline__ short4  cv::cudev::operator& (short s, const short4 &b)
 
__device__ __forceinline__ short1  cv::cudev::operator& (const short1 &a, short s)
 
__device__ __forceinline__ int1  cv::cudev::operator& (int s, const int1 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator& (const int2 &a, int s)
 
__device__ __forceinline__ int2  cv::cudev::operator& (int s, const int2 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator& (int s, const int3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator& (const int4 &a, int s)
 
__device__ __forceinline__ int4  cv::cudev::operator& (int s, const int4 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator& (const int3 &a, int s)
 
__device__ __forceinline__ int1  cv::cudev::operator& (const int1 &a, int s)
 
__device__ __forceinline__ uint3  cv::cudev::operator& (const uint3 &a, uint s)
 
__device__ __forceinline__ uint1  cv::cudev::operator& ( uint s, const uint1 &b)
 
__device__ __forceinline__ uint2  cv::cudev::operator& (const uint2 &a, uint s)
 
__device__ __forceinline__ uint2  cv::cudev::operator& ( uint s, const uint2 &b)
 
__device__ __forceinline__ uint3  cv::cudev::operator& ( uint s, const uint3 &b)
 
__device__ __forceinline__ uint4  cv::cudev::operator& (const uint4 &a, uint s)
 
__device__ __forceinline__ uint4  cv::cudev::operator& ( uint s, const uint4 &b)
 
__device__ __forceinline__ uint1  cv::cudev::operator& (const uint1 &a, uint s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const uchar1 &a, const uchar1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const uchar2 &a, const uchar2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const uchar3 &a, const uchar3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const uchar4 &a, const uchar4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const char1 &a, const char1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const char2 &a, const char2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const char3 &a, const char3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const char4 &a, const char4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const ushort1 &a, const ushort1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const ushort2 &a, const ushort2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const ushort3 &a, const ushort3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const ushort4 &a, const ushort4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const short1 &a, const short1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const short2 &a, const short2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const short3 &a, const short3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const short4 &a, const short4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const int1 &a, const int1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const int2 &a, const int2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const int3 &a, const int3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const int4 &a, const int4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const uint1 &a, const uint1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const uint2 &a, const uint2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const uint3 &a, const uint3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const uint4 &a, const uint4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const float1 &a, const float1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const float2 &a, const float2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const float3 &a, const float3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const float4 &a, const float4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const double1 &a, const double1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const double2 &a, const double2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const double3 &a, const double3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const double4 &a, const double4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const uchar1 &a, uchar s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& ( uchar s, const uchar1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const uchar2 &a, uchar s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& ( uchar s, const uchar2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& ( uchar s, const uchar3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const uchar4 &a, uchar s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& ( uchar s, const uchar4 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const uchar3 &a, uchar s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (char s, const char1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const char2 &a, char s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (char s, const char2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (char s, const char3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (char s, const char4 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const char4 &a, char s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const char3 &a, char s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const char1 &a, char s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& ( ushort s, const ushort1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& ( ushort s, const ushort2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& ( ushort s, const ushort3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const ushort4 &a, ushort s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& ( ushort s, const ushort4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const ushort1 &a, ushort s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const ushort3 &a, ushort s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const ushort2 &a, ushort s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (short s, const short1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const short2 &a, short s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (short s, const short2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (short s, const short3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (short s, const short4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const short1 &a, short s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const short4 &a, short s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const short3 &a, short s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (int s, const int1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (int s, const int2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (int s, const int3 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const int1 &a, int s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const int4 &a, int s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const int3 &a, int s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const int2 &a, int s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (int s, const int4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& ( uint s, const uint1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const uint2 &a, uint s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& ( uint s, const uint2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& ( uint s, const uint3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const uint4 &a, uint s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const uint3 &a, uint s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& ( uint s, const uint4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const uint1 &a, uint s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (float s, const float1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (float s, const float2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (float s, const float3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (float s, const float4 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const float2 &a, float s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const float4 &a, float s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const float3 &a, float s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const float1 &a, float s)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (double s, const double1 &b)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (const double2 &a, double s)
 
__device__ __forceinline__ uchar2  cv::cudev::operator&& (double s, const double2 &b)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (const double3 &a, double s)
 
__device__ __forceinline__ uchar3  cv::cudev::operator&& (double s, const double3 &b)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (const double4 &a, double s)
 
__device__ __forceinline__ uchar4  cv::cudev::operator&& (double s, const double4 &b)
 
__device__ __forceinline__ uchar1  cv::cudev::operator&& (const double1 &a, double s)
 
__device__ __forceinline__ int1  cv::cudev::operator* (const uchar1 &a, const uchar1 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator* (const uchar2 &a, const uchar2 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (const uchar3 &a, const uchar3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (const uchar4 &a, const uchar4 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator* (const char1 &a, const char1 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator* (const char2 &a, const char2 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (const char3 &a, const char3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (const char4 &a, const char4 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator* (const ushort1 &a, const ushort1 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator* (const ushort2 &a, const ushort2 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (const ushort3 &a, const ushort3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (const ushort4 &a, const ushort4 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator* (const short1 &a, const short1 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator* (const short2 &a, const short2 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (const short3 &a, const short3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (const short4 &a, const short4 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator* (const int1 &a, const int1 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator* (const int2 &a, const int2 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (const int3 &a, const int3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (const int4 &a, const int4 &b)
 
__device__ __forceinline__ uint1  cv::cudev::operator* (const uint1 &a, const uint1 &b)
 
__device__ __forceinline__ uint2  cv::cudev::operator* (const uint2 &a, const uint2 &b)
 
__device__ __forceinline__ uint3  cv::cudev::operator* (const uint3 &a, const uint3 &b)
 
__device__ __forceinline__ uint4  cv::cudev::operator* (const uint4 &a, const uint4 &b)
 
__device__ __forceinline__ float1  cv::cudev::operator* (const float1 &a, const float1 &b)
 
__device__ __forceinline__ float2  cv::cudev::operator* (const float2 &a, const float2 &b)
 
__device__ __forceinline__ float3  cv::cudev::operator* (const float3 &a, const float3 &b)
 
__device__ __forceinline__ float4  cv::cudev::operator* (const float4 &a, const float4 &b)
 
__device__ __forceinline__ double1  cv::cudev::operator* (const double1 &a, const double1 &b)
 
__device__ __forceinline__ double2  cv::cudev::operator* (const double2 &a, const double2 &b)
 
__device__ __forceinline__ double3  cv::cudev::operator* (const double3 &a, const double3 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (const double4 &a, const double4 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (int s, const uchar4 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (const uchar4 &a, int s)
 
__device__ __forceinline__ int1  cv::cudev::operator* (int s, const uchar1 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator* (const uchar1 &a, int s)
 
__device__ __forceinline__ int2  cv::cudev::operator* (const uchar2 &a, int s)
 
__device__ __forceinline__ int3  cv::cudev::operator* (int s, const uchar3 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator* (int s, const uchar2 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (const uchar3 &a, int s)
 
__device__ __forceinline__ float1  cv::cudev::operator* (const uchar1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::operator* (float s, const uchar1 &b)
 
__device__ __forceinline__ float2  cv::cudev::operator* (float s, const uchar2 &b)
 
__device__ __forceinline__ float2  cv::cudev::operator* (const uchar2 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::operator* (float s, const uchar3 &b)
 
__device__ __forceinline__ float3  cv::cudev::operator* (const uchar3 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::operator* (const uchar4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::operator* (float s, const uchar4 &b)
 
__device__ __forceinline__ double2  cv::cudev::operator* (const uchar2 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::operator* (double s, const uchar3 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (double s, const uchar4 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (const uchar4 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::operator* (const uchar3 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::operator* (double s, const uchar2 &b)
 
__device__ __forceinline__ double1  cv::cudev::operator* (double s, const uchar1 &b)
 
__device__ __forceinline__ double1  cv::cudev::operator* (const uchar1 &a, double s)
 
__device__ __forceinline__ int4  cv::cudev::operator* (const char4 &a, int s)
 
__device__ __forceinline__ int4  cv::cudev::operator* (int s, const char4 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (const char3 &a, int s)
 
__device__ __forceinline__ int2  cv::cudev::operator* (const char2 &a, int s)
 
__device__ __forceinline__ int3  cv::cudev::operator* (int s, const char3 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator* (int s, const char2 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator* (int s, const char1 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator* (const char1 &a, int s)
 
__device__ __forceinline__ float4  cv::cudev::operator* (float s, const char4 &b)
 
__device__ __forceinline__ float4  cv::cudev::operator* (const char4 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::operator* (float s, const char1 &b)
 
__device__ __forceinline__ float1  cv::cudev::operator* (const char1 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::operator* (const char2 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::operator* (float s, const char3 &b)
 
__device__ __forceinline__ float2  cv::cudev::operator* (float s, const char2 &b)
 
__device__ __forceinline__ float3  cv::cudev::operator* (const char3 &a, float s)
 
__device__ __forceinline__ double2  cv::cudev::operator* (double s, const char2 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (const char4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::operator* (double s, const char4 &b)
 
__device__ __forceinline__ double1  cv::cudev::operator* (const char1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::operator* (double s, const char1 &b)
 
__device__ __forceinline__ double2  cv::cudev::operator* (const char2 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::operator* (double s, const char3 &b)
 
__device__ __forceinline__ double3  cv::cudev::operator* (const char3 &a, double s)
 
__device__ __forceinline__ int2  cv::cudev::operator* (int s, const ushort2 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator* (const ushort2 &a, int s)
 
__device__ __forceinline__ int1  cv::cudev::operator* (const ushort1 &a, int s)
 
__device__ __forceinline__ int1  cv::cudev::operator* (int s, const ushort1 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (const ushort3 &a, int s)
 
__device__ __forceinline__ int3  cv::cudev::operator* (int s, const ushort3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (int s, const ushort4 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (const ushort4 &a, int s)
 
__device__ __forceinline__ float4  cv::cudev::operator* (const ushort4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::operator* (float s, const ushort4 &b)
 
__device__ __forceinline__ float1  cv::cudev::operator* (float s, const ushort1 &b)
 
__device__ __forceinline__ float3  cv::cudev::operator* (float s, const ushort3 &b)
 
__device__ __forceinline__ float2  cv::cudev::operator* (float s, const ushort2 &b)
 
__device__ __forceinline__ float2  cv::cudev::operator* (const ushort2 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::operator* (const ushort3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::operator* (const ushort1 &a, float s)
 
__device__ __forceinline__ double2  cv::cudev::operator* (double s, const ushort2 &b)
 
__device__ __forceinline__ double3  cv::cudev::operator* (const ushort3 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::operator* (const ushort2 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::operator* (const ushort1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::operator* (double s, const ushort1 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (const ushort4 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::operator* (double s, const ushort3 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (double s, const ushort4 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator* (int s, const short1 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (int s, const short3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (const short4 &a, int s)
 
__device__ __forceinline__ int4  cv::cudev::operator* (int s, const short4 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator* (const short2 &a, int s)
 
__device__ __forceinline__ int3  cv::cudev::operator* (const short3 &a, int s)
 
__device__ __forceinline__ int2  cv::cudev::operator* (int s, const short2 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator* (const short1 &a, int s)
 
__device__ __forceinline__ float1  cv::cudev::operator* (const short1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::operator* (float s, const short1 &b)
 
__device__ __forceinline__ float2  cv::cudev::operator* (const short2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::operator* (float s, const short2 &b)
 
__device__ __forceinline__ float3  cv::cudev::operator* (const short3 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::operator* (float s, const short3 &b)
 
__device__ __forceinline__ float4  cv::cudev::operator* (const short4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::operator* (float s, const short4 &b)
 
__device__ __forceinline__ double1  cv::cudev::operator* (const short1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::operator* (double s, const short1 &b)
 
__device__ __forceinline__ double2  cv::cudev::operator* (const short2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::operator* (double s, const short2 &b)
 
__device__ __forceinline__ double3  cv::cudev::operator* (const short3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::operator* (double s, const short3 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (const short4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::operator* (double s, const short4 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (const int3 &a, int s)
 
__device__ __forceinline__ int1  cv::cudev::operator* (const int1 &a, int s)
 
__device__ __forceinline__ int1  cv::cudev::operator* (int s, const int1 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator* (const int2 &a, int s)
 
__device__ __forceinline__ int2  cv::cudev::operator* (int s, const int2 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator* (int s, const int3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator* (const int4 &a, int s)
 
__device__ __forceinline__ int4  cv::cudev::operator* (int s, const int4 &b)
 
__device__ __forceinline__ float1  cv::cudev::operator* (float s, const int1 &b)
 
__device__ __forceinline__ float2  cv::cudev::operator* (const int2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::operator* (float s, const int2 &b)
 
__device__ __forceinline__ float3  cv::cudev::operator* (const int3 &a, float s)
 
__device__ __forceinline__ float3  cv::cudev::operator* (float s, const int3 &b)
 
__device__ __forceinline__ float4  cv::cudev::operator* (const int4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::operator* (float s, const int4 &b)
 
__device__ __forceinline__ float1  cv::cudev::operator* (const int1 &a, float s)
 
__device__ __forceinline__ double3  cv::cudev::operator* (const int3 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::operator* (double s, const int1 &b)
 
__device__ __forceinline__ double2  cv::cudev::operator* (const int2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::operator* (double s, const int2 &b)
 
__device__ __forceinline__ double3  cv::cudev::operator* (double s, const int3 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (const int4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::operator* (double s, const int4 &b)
 
__device__ __forceinline__ double1  cv::cudev::operator* (const int1 &a, double s)
 
__device__ __forceinline__ uint1  cv::cudev::operator* ( uint s, const uint1 &b)
 
__device__ __forceinline__ uint2  cv::cudev::operator* (const uint2 &a, uint s)
 
__device__ __forceinline__ uint2  cv::cudev::operator* ( uint s, const uint2 &b)
 
__device__ __forceinline__ uint3  cv::cudev::operator* (const uint3 &a, uint s)
 
__device__ __forceinline__ uint3  cv::cudev::operator* ( uint s, const uint3 &b)
 
__device__ __forceinline__ uint4  cv::cudev::operator* (const uint4 &a, uint s)
 
__device__ __forceinline__ uint4  cv::cudev::operator* ( uint s, const uint4 &b)
 
__device__ __forceinline__ uint1  cv::cudev::operator* (const uint1 &a, uint s)
 
__device__ __forceinline__ float3  cv::cudev::operator* (const uint3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::operator* (float s, const uint1 &b)
 
__device__ __forceinline__ float2  cv::cudev::operator* (const uint2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::operator* (float s, const uint2 &b)
 
__device__ __forceinline__ float3  cv::cudev::operator* (float s, const uint3 &b)
 
__device__ __forceinline__ float4  cv::cudev::operator* (const uint4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::operator* (float s, const uint4 &b)
 
__device__ __forceinline__ float1  cv::cudev::operator* (const uint1 &a, float s)
 
__device__ __forceinline__ double1  cv::cudev::operator* (const uint1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::operator* (double s, const uint1 &b)
 
__device__ __forceinline__ double2  cv::cudev::operator* (const uint2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::operator* (double s, const uint2 &b)
 
__device__ __forceinline__ double3  cv::cudev::operator* (const uint3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::operator* (double s, const uint3 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (const uint4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::operator* (double s, const uint4 &b)
 
__device__ __forceinline__ float3  cv::cudev::operator* (const float3 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::operator* (const float1 &a, float s)
 
__device__ __forceinline__ float1  cv::cudev::operator* (float s, const float1 &b)
 
__device__ __forceinline__ float2  cv::cudev::operator* (const float2 &a, float s)
 
__device__ __forceinline__ float2  cv::cudev::operator* (float s, const float2 &b)
 
__device__ __forceinline__ float3  cv::cudev::operator* (float s, const float3 &b)
 
__device__ __forceinline__ float4  cv::cudev::operator* (const float4 &a, float s)
 
__device__ __forceinline__ float4  cv::cudev::operator* (float s, const float4 &b)
 
__device__ __forceinline__ double1  cv::cudev::operator* (double s, const float1 &b)
 
__device__ __forceinline__ double2  cv::cudev::operator* (const float2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::operator* (double s, const float2 &b)
 
__device__ __forceinline__ double3  cv::cudev::operator* (const float3 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::operator* (double s, const float3 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (const float4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::operator* (double s, const float4 &b)
 
__device__ __forceinline__ double1  cv::cudev::operator* (const float1 &a, double s)
 
__device__ __forceinline__ double1  cv::cudev::operator* (double s, const double1 &b)
 
__device__ __forceinline__ double2  cv::cudev::operator* (const double2 &a, double s)
 
__device__ __forceinline__ double2  cv::cudev::operator* (double s, const double2 &b)
 
__device__ __forceinline__ double3  cv::cudev::operator* (double s, const double3 &b)
 
__device__ __forceinline__ double4  cv::cudev::operator* (const double4 &a, double s)
 
__device__ __forceinline__ double4  cv::cudev::operator* (double s, const double4 &b)
 
__device__ __forceinline__ double1  cv::cudev::operator* (const double1 &a, double s)
 
__device__ __forceinline__ double3  cv::cudev::operator* (const double3 &a, double s)
 
__device__ __forceinline__ int3  cv::cudev::operator+ (const uchar3 &a, const uchar3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator+ (const uchar4 &a, const uchar4 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator+ (const uchar1 &a, const uchar1 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator+ (const uchar2 &a, const uchar2 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator+ (const char2 &a, const char2 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator+ (const char1 &a, const char1 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator+ (const char3 &a, const char3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator+ (const char4 &a, const char4 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator+ (const ushort2 &a, const ushort2 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator+ (const ushort1 &a, const ushort1 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator+ (const ushort3 &a, const ushort3 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator+ (const ushort4 &a, const ushort4 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator+ (const short3 &a, const short3 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator+ (const short1 &a, const short1 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator+ (const short2 &a, const short2 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator+ (const short4 &a, const short4 &b)
 
__device__ __forceinline__ int4  cv::cudev::operator+ (const int4 &a, const int4 &b)
 
__device__ __forceinline__ int2  cv::cudev::operator+ (const int2 &a, const int2 &b)
 
__device__ __forceinline__ int1  cv::cudev::operator+ (const int1 &a, const int1 &b)
 
__device__ __forceinline__ int3  cv::cudev::operator+ (const int3 &a, const int3 &b)
 
__device__ __forceinline__ uint2  cv::cudev::operator+ (const uint2 &a, const uint2 &b)
 
__device__ __forceinline__ uint1  cv::cudev::operator+