test_conformance/clcpp/integer_funcs/numeric_funcs.hpp - external/github.com/KhronosGroup/OpenCL-CTS - Git at Google

 //
 // Copyright (c) 2017 The Khronos Group Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
 #ifndef TEST_CONFORMANCE_CLCPP_INTEGER_FUNCS_NUMERIC_HPP
 #define TEST_CONFORMANCE_CLCPP_INTEGER_FUNCS_NUMERIC_HPP

 #include "common.hpp"
 #include <type_traits>

 template<class IN1, class OUT1>
 struct int_func_abs : public unary_func<IN1, OUT1>
 {
     std::string str()
     {
         return "abs";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x)
     {
         static_assert(
             std::is_unsigned<OUT1>::value,
             "OUT1 type must be unsigned"
         );
         if(x < IN1(0))
             return static_cast<OUT1>(-x);
         return static_cast<OUT1>(x);
     }
 };

 template<class IN1, class IN2, class OUT1>
 struct int_func_abs_diff : public binary_func<IN1, IN2, OUT1>
 {
     std::string str()
     {
         return "abs_diff";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& y)
     {
         static_assert(
             std::is_same<IN1, IN2>::value,
             "IN1 must be IN2"
         );
         static_assert(
             std::is_unsigned<OUT1>::value,
             "OUT1 type must be unsigned"
         );
         if(x < y)
             return static_cast<OUT1>(y-x);
         return static_cast<OUT1>(x-y);
     }
 };

 template<class IN1, class IN2, class OUT1>
 struct int_func_add_sat : public binary_func<IN1, IN2, OUT1>
 {
     std::string str()
     {
         return "add_sat";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& y)
     {
         static_assert(
             std::is_same<IN1, IN2>::value,
             "IN1 must be IN2"
         );
         static_assert(
             std::is_same<OUT1, IN2>::value,
             "OUT1 must be IN2"
         );
         // sat unsigned integers
         if(std::is_unsigned<OUT1>::value)
         {
             OUT1 z = x + y;
             if(z < x || z < y)
                 return (std::numeric_limits<OUT1>::max)();
             return z;
         }
         // sat signed integers
         OUT1 z = x + y;
         if(y > 0)
         {
             if(z < x)
                 return (std::numeric_limits<OUT1>::max)();
         }
         else
         {
             if(z > x)
                 return (std::numeric_limits<OUT1>::min)();
         }
         return z;
     }
 };

 template<class IN1, class IN2, class OUT1>
 struct int_func_hadd : public binary_func<IN1, IN2, OUT1>
 {
     std::string str()
     {
         return "hadd";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& y)
     {
         static_assert(
             std::is_same<IN1, IN2>::value,
             "IN1 must be IN2"
         );
         static_assert(
             std::is_same<OUT1, IN2>::value,
             "OUT1 must be IN2"
         );
         return (x >> OUT1(1)) + (y >> OUT1(1)) + (x & y & OUT1(1));
     }
 };

 template<class IN1, class IN2, class OUT1>
 struct int_func_rhadd : public binary_func<IN1, IN2, OUT1>
 {
     std::string str()
     {
         return "rhadd";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& y)
     {
         static_assert(
             std::is_same<IN1, IN2>::value,
             "IN1 must be IN2"
         );
         static_assert(
             std::is_same<OUT1, IN2>::value,
             "OUT1 must be IN2"
         );
         return (x >> OUT1(1)) + (y >> OUT1(1)) + ((x | y) & OUT1(1));
     }
 };

 // clamp for scalars
 template<class IN1, class IN2, class IN3, class OUT1, class Enable = void>
 struct int_func_clamp : public ternary_func<IN1, IN2, IN3, OUT1>
 {
     std::string str()
     {
         return "clamp";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& minval, const IN3& maxval)
     {
         static_assert(
             std::is_same<IN2, IN3>::value,
             "IN3 must be IN2"
         );
         static_assert(
             std::is_same<OUT1, IN1>::value,
             "OUT1 must be IN1"
         );
         return (std::min)((std::max)(x, minval), maxval);
     }

     IN2 min2()
     {
         return (std::numeric_limits<IN2>::min)();
     }

     IN2 max2()
     {
         return (std::numeric_limits<IN2>::max)() / IN2(2);
     }

     IN3 min3()
     {
         return IN3(1) + ((std::numeric_limits<IN3>::max)() / IN3(2));
     }

     IN3 max3()
     {
         return (std::numeric_limits<IN3>::max)();
     }
 };

 // gentype clamp(gentype x, scalar minval, scalar maxval);
 template<class IN1, class IN2, class IN3, class OUT1>
 struct int_func_clamp<IN1, IN2, IN3, OUT1, typename std::enable_if<is_vector_type<OUT1>::value>::type> : public ternary_func<IN1, IN2, IN3, OUT1>
 {
     std::string str()
     {
         return "clamp";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& minval, const IN3& maxval)
     {
         static_assert(
             std::is_same<IN2, IN3>::value,
             "IN3 must be IN2"
         );
         static_assert(
             !is_vector_type<IN2>::value && !is_vector_type<IN3>::value,
             "IN3 and IN2 must be scalar"
         );
         static_assert(
             std::is_same<OUT1, IN1>::value,
             "OUT1 must be IN1"
         );
         OUT1 result;
         for(size_t i = 0; i < vector_size<OUT1>::value; i++)
         {
             result.s[i] = (std::min)((std::max)(x.s[i], minval), maxval);
         }
         return result;
     }

     IN1 min1()
     {
         typedef typename scalar_type<IN1>::type SCALAR1;
         IN1 min1;
         for(size_t i = 0; i < vector_size<IN1>::value; i++)
         {
             min1.s[i] = (std::numeric_limits<SCALAR1>::min)();
         }
         return min1;
     }

     IN1 max1()
     {
         typedef typename scalar_type<IN1>::type SCALAR1;
         IN1 max1;
         for(size_t i = 0; i < vector_size<IN1>::value; i++)
         {
             max1.s[i] = (std::numeric_limits<SCALAR1>::max)();
         }
         return max1;
     }

     IN2 min2()
     {
         return (std::numeric_limits<IN2>::min)();
     }

     IN2 max2()
     {
         return (std::numeric_limits<IN2>::max)() / IN2(2);
     }

     IN3 min3()
     {
         return IN3(1) + ((std::numeric_limits<IN3>::max)() / IN3(2));
     }

     IN3 max3()
     {
         return (std::numeric_limits<IN3>::max)();
     }
 };

 template<class IN1, class IN2, class OUT1>
 struct int_func_mul_hi : public binary_func<IN1, IN2, OUT1>
 {
     std::string str()
     {
         return "mul_hi";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& y)
     {
         static_assert(
             std::is_same<IN1, IN2>::value
                 && std::is_same<IN2, OUT1>::value,
             "Types must be the same"
         );
         static_assert(
             !std::is_same<IN1, cl_long>::value && !std::is_same<IN1, cl_ulong>::value,
             "Operation unimplemented for 64-bit scalars"
         );
         cl_long xl = static_cast<cl_long>(x);
         cl_long yl = static_cast<cl_long>(y);
         return static_cast<OUT1>((xl * yl) >> (8 * sizeof(OUT1)));
     }
 };

 template<class IN1, class IN2, class IN3, class OUT1>
 struct int_func_mad_hi : public ternary_func<IN1, IN2, IN3, OUT1>
 {
     std::string str()
     {
         return "mad_hi";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& y, const IN3& z)
     {
         static_assert(
             std::is_same<IN1, IN2>::value
                 && std::is_same<IN2, IN3>::value
                 && std::is_same<IN3, OUT1>::value,
             "Types must be the same"
         );
         return int_func_mul_hi<IN1, IN2, OUT1>()(x, y) + z;
     }
 };

 // This test is implemented only for unsigned integers
 template<class IN1, class IN2, class IN3, class OUT1>
 struct int_func_mad_sat : public ternary_func<IN1, IN2, IN3, OUT1>
 {
     std::string str()
     {
         return "mad_sat";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& y, const IN3& z)
     {
         static_assert(
             std::is_same<IN1, IN2>::value
                 && std::is_same<IN2, IN3>::value
                 && std::is_same<IN3, OUT1>::value,
             "Types must be the same"
         );
         static_assert(
             std::is_unsigned<OUT1>::value,
             "Test operation is not implemented for signed integers"
         );
         // mad_sat unsigned integers
         OUT1 w1 = (x * y);
         if (x != 0 && w1 / x != y)
             return (std::numeric_limits<OUT1>::max)();
         OUT1 w2 = w1 + z;
         if(w2 < w1)
             return (std::numeric_limits<OUT1>::max)();
         return w2;
     }
 };

 template<class IN1, class IN2, class OUT1>
 struct int_func_sub_sat : public binary_func<IN1, IN2, OUT1>
 {
     std::string str()
     {
         return "sub_sat";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& y)
     {
         static_assert(
             std::is_same<IN1, IN2>::value && std::is_same<IN2, OUT1>::value,
             "IN1, IN2 and OUT1 must be the same types"
         );
         // sat unsigned integers
         if(std::is_unsigned<OUT1>::value)
         {
             OUT1 z = x - y;
             if(x < y)
                 return (std::numeric_limits<OUT1>::min)();
             return z;
         }
         // sat signed integers
         OUT1 z = x - y;
         if(y < 0)
         {
             if(z < x)
                 return (std::numeric_limits<OUT1>::max)();
         }
         else
         {
             if(z > x)
                 return (std::numeric_limits<OUT1>::min)();
         }
         return z;
     }
 };

 template<class IN1, class IN2, class OUT1, class Enable = void>
 struct int_func_max : public binary_func<IN1, IN2, OUT1>
 {
     std::string str()
     {
         return "max";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& y)
     {
         static_assert(
             std::is_same<IN1, IN2>::value && std::is_same<IN2, OUT1>::value,
             "IN1, IN2 and OUT1 must be the same types"
         );
         return (std::max)(x, y);
     }
 };

 template<class IN1, class IN2, class OUT1>
 struct int_func_max<IN1, IN2, OUT1, typename std::enable_if<is_vector_type<OUT1>::value>::type> : public binary_func<IN1, IN2, OUT1>
 {
     std::string str()
     {
         return "max";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     IN1 min1()
     {
         typedef typename scalar_type<IN1>::type SCALAR1;
         IN1 min1;
         for(size_t i = 0; i < vector_size<IN1>::value; i++)
         {
             min1.s[i] = (std::numeric_limits<SCALAR1>::min)();
         }
         return min1;
     }

     IN1 max1()
     {
         typedef typename scalar_type<IN1>::type SCALAR1;
         IN1 max1;
         for(size_t i = 0; i < vector_size<IN1>::value; i++)
         {
             max1.s[i] = (std::numeric_limits<SCALAR1>::max)();
         }
         return max1;
     }

     OUT1 operator()(const IN1& x, const IN2& y)
     {
         static_assert(
             std::is_same<IN1, OUT1>::value,
             "IN1 and OUT1 must be the same types"
         );
         static_assert(
             !is_vector_type<IN2>::value,
             "IN2 must be scalar"
         );
         static_assert(
             std::is_same<typename scalar_type<OUT1>::type, IN2>::value,
             "IN2 must match with OUT1 and IN1"
         );
         IN1 result = x;
         for(size_t i = 0; i < vector_size<IN1>::value; i++)
         {
             result.s[i] = (std::max)(x.s[i], y);
         }
         return result;
     }
 };

 template<class IN1, class IN2, class OUT1, class Enable = void>
 struct int_func_min : public binary_func<IN1, IN2, OUT1>
 {
     std::string str()
     {
         return "min";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     OUT1 operator()(const IN1& x, const IN2& y)
     {
         static_assert(
             std::is_same<IN1, IN2>::value && std::is_same<IN2, OUT1>::value,
             "IN1, IN2 and OUT1 must be the same types"
         );
         return (std::min)(x, y);
     }
 };

 template<class IN1, class IN2, class OUT1>
 struct int_func_min<IN1, IN2, OUT1, typename std::enable_if<is_vector_type<OUT1>::value>::type> : public binary_func<IN1, IN2, OUT1>
 {
     std::string str()
     {
         return "min";
     }

     std::string headers()
     {
         return "#include <opencl_integer>\n";
     }

     IN1 min1()
     {
         typedef typename scalar_type<IN1>::type SCALAR1;
         IN1 min1;
         for(size_t i = 0; i < vector_size<IN1>::value; i++)
         {
             min1.s[i] = (std::numeric_limits<SCALAR1>::min)();
         }
         return min1;
     }

     IN1 max1()
     {
         typedef typename scalar_type<IN1>::type SCALAR1;
         IN1 max1;
         for(size_t i = 0; i < vector_size<IN1>::value; i++)
         {
             max1.s[i] = (std::numeric_limits<SCALAR1>::max)();
         }
         return max1;
     }

     OUT1 operator()(const IN1& x, const IN2& y)
     {
         static_assert(
             std::is_same<IN1, OUT1>::value,
             "IN1 and OUT1 must be the same types"
         );
         static_assert(
             !is_vector_type<IN2>::value,
             "IN2 must be scalar"
         );
         static_assert(
             std::is_same<typename scalar_type<OUT1>::type, IN2>::value,
             "IN2 must match with OUT1 and IN1"
         );
         IN1 result = x;
         for(size_t i = 0; i < vector_size<IN1>::value; i++)
         {
             result.s[i] = (std::min)(x.s[i], y);
         }
         return result;
     }
 };

 AUTO_TEST_CASE(test_int_numeric_funcs)
 (cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
 {
     int error = CL_SUCCESS;
     int last_error = CL_SUCCESS;

     // ugentype abs(gentype x);
     TEST_UNARY_FUNC_MACRO((int_func_abs<cl_int, cl_uint>()))
     TEST_UNARY_FUNC_MACRO((int_func_abs<cl_uint, cl_uint>()))
     TEST_UNARY_FUNC_MACRO((int_func_abs<cl_long, cl_ulong>()))
     TEST_UNARY_FUNC_MACRO((int_func_abs<cl_ulong, cl_ulong>()))

     // ugentype abs_diff(gentype x, gentype y);
     TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_int, cl_int, cl_uint>()))
     TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_uint, cl_uint, cl_uint>()))
     TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_long, cl_long, cl_ulong>()))
     TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_ulong, cl_ulong, cl_ulong>()))

     // gentype add_sat(gentype x, gentype y);
     TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_int, cl_int, cl_int>()))
     TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_uint, cl_uint, cl_uint>()))
     TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_long, cl_long, cl_long>()))
     TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_ulong, cl_ulong, cl_ulong>()))

     // gentype hadd(gentype x, gentype y);
     TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_int, cl_int, cl_int>()))
     TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_uint, cl_uint, cl_uint>()))
     TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_long, cl_long, cl_long>()))
     TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_ulong, cl_ulong, cl_ulong>()))

     // gentype rhadd(gentype x, gentype y);
     TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_int, cl_int, cl_int>()))
     TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_uint, cl_uint, cl_uint>()))
     TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_long, cl_long, cl_long>()))
     TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_ulong, cl_ulong, cl_ulong>()))

     // gentype clamp(gentype x, gentype minval, gentype maxval);
     TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_int, cl_int, cl_int, cl_int>()))
     TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_uint, cl_uint, cl_uint, cl_uint>()))
     TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_long, cl_long, cl_long, cl_long>()))
     TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_ulong, cl_ulong, cl_ulong, cl_ulong>()))

     // gentype clamp(gentype x, scalar minval, scalar maxval);
     TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_int2, cl_int, cl_int, cl_int2>()))
     TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_uint4, cl_uint, cl_uint, cl_uint4>()))
     TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_long8, cl_long, cl_long, cl_long8>()))
     TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_ulong16, cl_ulong, cl_ulong, cl_ulong16>()))

     // gentype mad_hi(gentype a, gentype b, gentype c);
     TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_short, cl_short, cl_short, cl_short>()))
     TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_ushort, cl_ushort, cl_ushort, cl_ushort>()))
     TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_int, cl_int, cl_int, cl_int>()))
     TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_uint, cl_uint, cl_uint, cl_uint>()))

     // gentype mad_sat(gentype a, gentype b, gentype c);
     TEST_TERNARY_FUNC_MACRO((int_func_mad_sat<cl_ushort, cl_ushort, cl_ushort, cl_ushort>()))
     TEST_TERNARY_FUNC_MACRO((int_func_mad_sat<cl_uint, cl_uint, cl_uint, cl_uint>()))
     TEST_TERNARY_FUNC_MACRO((int_func_mad_sat<cl_ulong, cl_ulong, cl_ulong, cl_ulong>()))

     // gentype max(gentype x, gentype y);
     TEST_BINARY_FUNC_MACRO((int_func_max<cl_int, cl_int, cl_int>()))
     TEST_BINARY_FUNC_MACRO((int_func_max<cl_uint, cl_uint, cl_uint>()))
     TEST_BINARY_FUNC_MACRO((int_func_max<cl_long, cl_long, cl_long>()))
     TEST_BINARY_FUNC_MACRO((int_func_max<cl_ulong, cl_ulong, cl_ulong>()))

     // gentype max(gentype x, scalar y);
     TEST_BINARY_FUNC_MACRO((int_func_max<cl_int2, cl_int, cl_int2>()))
     TEST_BINARY_FUNC_MACRO((int_func_max<cl_uint4, cl_uint, cl_uint4>()))
     TEST_BINARY_FUNC_MACRO((int_func_max<cl_long8, cl_long, cl_long8>()))
     TEST_BINARY_FUNC_MACRO((int_func_max<cl_ulong16, cl_ulong, cl_ulong16>()))

     // gentype min(gentype x, gentype y);
     TEST_BINARY_FUNC_MACRO((int_func_min<cl_int, cl_int, cl_int>()))
     TEST_BINARY_FUNC_MACRO((int_func_min<cl_uint, cl_uint, cl_uint>()))
     TEST_BINARY_FUNC_MACRO((int_func_min<cl_long, cl_long, cl_long>()))
     TEST_BINARY_FUNC_MACRO((int_func_min<cl_ulong, cl_ulong, cl_ulong>()))

     // gentype min(gentype x, scalar y);
     TEST_BINARY_FUNC_MACRO((int_func_min<cl_int2, cl_int, cl_int2>()))
     TEST_BINARY_FUNC_MACRO((int_func_min<cl_uint4, cl_uint, cl_uint4>()))
     TEST_BINARY_FUNC_MACRO((int_func_min<cl_long8, cl_long, cl_long8>()))
     TEST_BINARY_FUNC_MACRO((int_func_min<cl_ulong16, cl_ulong, cl_ulong16>()))

     // gentype mul_hi(gentype x, gentype y);
     TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_short, cl_short, cl_short>()))
     TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_ushort, cl_ushort, cl_ushort>()))
     TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_int, cl_int, cl_int>()))
     TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_uint, cl_uint, cl_uint>()))

     // gentype sub_sat(gentype x, gentype y);
     TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_int, cl_int, cl_int>()))
     TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_uint, cl_uint, cl_uint>()))
     TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_long, cl_long, cl_long>()))
     TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_ulong, cl_ulong, cl_ulong>()))

     if(error != CL_SUCCESS)
     {
         return -1;
     }
     return error;
 }

 #endif // TEST_CONFORMANCE_CLCPP_INTEGER_FUNCS_NUMERIC_HPP
	//
	// Copyright (c) 2017 The Khronos Group Inc.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//
	#ifndef TEST_CONFORMANCE_CLCPP_INTEGER_FUNCS_NUMERIC_HPP
	#define TEST_CONFORMANCE_CLCPP_INTEGER_FUNCS_NUMERIC_HPP

	#include "common.hpp"
	#include <type_traits>

	template<class IN1, class OUT1>
	struct int_func_abs : public unary_func<IN1, OUT1>
	{
	std::string str()
	{
	return "abs";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x)
	{
	static_assert(
	std::is_unsigned<OUT1>::value,
	"OUT1 type must be unsigned"
	);
	if(x < IN1(0))
	return static_cast<OUT1>(-x);
	return static_cast<OUT1>(x);
	}
	};

	template<class IN1, class IN2, class OUT1>
	struct int_func_abs_diff : public binary_func<IN1, IN2, OUT1>
	{
	std::string str()
	{
	return "abs_diff";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& y)
	{
	static_assert(
	std::is_same<IN1, IN2>::value,
	"IN1 must be IN2"
	);
	static_assert(
	std::is_unsigned<OUT1>::value,
	"OUT1 type must be unsigned"
	);
	if(x < y)
	return static_cast<OUT1>(y-x);
	return static_cast<OUT1>(x-y);
	}
	};

	template<class IN1, class IN2, class OUT1>
	struct int_func_add_sat : public binary_func<IN1, IN2, OUT1>
	{
	std::string str()
	{
	return "add_sat";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& y)
	{
	static_assert(
	std::is_same<IN1, IN2>::value,
	"IN1 must be IN2"
	);
	static_assert(
	std::is_same<OUT1, IN2>::value,
	"OUT1 must be IN2"
	);
	// sat unsigned integers
	if(std::is_unsigned<OUT1>::value)
	{
	OUT1 z = x + y;
	if(z < x \|\| z < y)
	return (std::numeric_limits<OUT1>::max)();
	return z;
	}
	// sat signed integers
	OUT1 z = x + y;
	if(y > 0)
	{
	if(z < x)
	return (std::numeric_limits<OUT1>::max)();
	}
	else
	{
	if(z > x)
	return (std::numeric_limits<OUT1>::min)();
	}
	return z;
	}
	};

	template<class IN1, class IN2, class OUT1>
	struct int_func_hadd : public binary_func<IN1, IN2, OUT1>
	{
	std::string str()
	{
	return "hadd";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& y)
	{
	static_assert(
	std::is_same<IN1, IN2>::value,
	"IN1 must be IN2"
	);
	static_assert(
	std::is_same<OUT1, IN2>::value,
	"OUT1 must be IN2"
	);
	return (x >> OUT1(1)) + (y >> OUT1(1)) + (x & y & OUT1(1));
	}
	};

	template<class IN1, class IN2, class OUT1>
	struct int_func_rhadd : public binary_func<IN1, IN2, OUT1>
	{
	std::string str()
	{
	return "rhadd";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& y)
	{
	static_assert(
	std::is_same<IN1, IN2>::value,
	"IN1 must be IN2"
	);
	static_assert(
	std::is_same<OUT1, IN2>::value,
	"OUT1 must be IN2"
	);
	return (x >> OUT1(1)) + (y >> OUT1(1)) + ((x \| y) & OUT1(1));
	}
	};

	// clamp for scalars
	template<class IN1, class IN2, class IN3, class OUT1, class Enable = void>
	struct int_func_clamp : public ternary_func<IN1, IN2, IN3, OUT1>
	{
	std::string str()
	{
	return "clamp";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& minval, const IN3& maxval)
	{
	static_assert(
	std::is_same<IN2, IN3>::value,
	"IN3 must be IN2"
	);
	static_assert(
	std::is_same<OUT1, IN1>::value,
	"OUT1 must be IN1"
	);
	return (std::min)((std::max)(x, minval), maxval);
	}

	IN2 min2()
	{
	return (std::numeric_limits<IN2>::min)();
	}

	IN2 max2()
	{
	return (std::numeric_limits<IN2>::max)() / IN2(2);
	}

	IN3 min3()
	{
	return IN3(1) + ((std::numeric_limits<IN3>::max)() / IN3(2));
	}

	IN3 max3()
	{
	return (std::numeric_limits<IN3>::max)();
	}
	};

	// gentype clamp(gentype x, scalar minval, scalar maxval);
	template<class IN1, class IN2, class IN3, class OUT1>
	struct int_func_clamp<IN1, IN2, IN3, OUT1, typename std::enable_if<is_vector_type<OUT1>::value>::type> : public ternary_func<IN1, IN2, IN3, OUT1>
	{
	std::string str()
	{
	return "clamp";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& minval, const IN3& maxval)
	{
	static_assert(
	std::is_same<IN2, IN3>::value,
	"IN3 must be IN2"
	);
	static_assert(
	!is_vector_type<IN2>::value && !is_vector_type<IN3>::value,
	"IN3 and IN2 must be scalar"
	);
	static_assert(
	std::is_same<OUT1, IN1>::value,
	"OUT1 must be IN1"
	);
	OUT1 result;
	for(size_t i = 0; i < vector_size<OUT1>::value; i++)
	{
	result.s[i] = (std::min)((std::max)(x.s[i], minval), maxval);
	}
	return result;
	}

	IN1 min1()
	{
	typedef typename scalar_type<IN1>::type SCALAR1;
	IN1 min1;
	for(size_t i = 0; i < vector_size<IN1>::value; i++)
	{
	min1.s[i] = (std::numeric_limits<SCALAR1>::min)();
	}
	return min1;
	}

	IN1 max1()
	{
	typedef typename scalar_type<IN1>::type SCALAR1;
	IN1 max1;
	for(size_t i = 0; i < vector_size<IN1>::value; i++)
	{
	max1.s[i] = (std::numeric_limits<SCALAR1>::max)();
	}
	return max1;
	}

	IN2 min2()
	{
	return (std::numeric_limits<IN2>::min)();
	}

	IN2 max2()
	{
	return (std::numeric_limits<IN2>::max)() / IN2(2);
	}

	IN3 min3()
	{
	return IN3(1) + ((std::numeric_limits<IN3>::max)() / IN3(2));
	}

	IN3 max3()
	{
	return (std::numeric_limits<IN3>::max)();
	}
	};

	template<class IN1, class IN2, class OUT1>
	struct int_func_mul_hi : public binary_func<IN1, IN2, OUT1>
	{
	std::string str()
	{
	return "mul_hi";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& y)
	{
	static_assert(
	std::is_same<IN1, IN2>::value
	&& std::is_same<IN2, OUT1>::value,
	"Types must be the same"
	);
	static_assert(
	!std::is_same<IN1, cl_long>::value && !std::is_same<IN1, cl_ulong>::value,
	"Operation unimplemented for 64-bit scalars"
	);
	cl_long xl = static_cast<cl_long>(x);
	cl_long yl = static_cast<cl_long>(y);
	return static_cast<OUT1>((xl * yl) >> (8 * sizeof(OUT1)));
	}
	};

	template<class IN1, class IN2, class IN3, class OUT1>
	struct int_func_mad_hi : public ternary_func<IN1, IN2, IN3, OUT1>
	{
	std::string str()
	{
	return "mad_hi";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& y, const IN3& z)
	{
	static_assert(
	std::is_same<IN1, IN2>::value
	&& std::is_same<IN2, IN3>::value
	&& std::is_same<IN3, OUT1>::value,
	"Types must be the same"
	);
	return int_func_mul_hi<IN1, IN2, OUT1>()(x, y) + z;
	}
	};

	// This test is implemented only for unsigned integers
	template<class IN1, class IN2, class IN3, class OUT1>
	struct int_func_mad_sat : public ternary_func<IN1, IN2, IN3, OUT1>
	{
	std::string str()
	{
	return "mad_sat";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& y, const IN3& z)
	{
	static_assert(
	std::is_same<IN1, IN2>::value
	&& std::is_same<IN2, IN3>::value
	&& std::is_same<IN3, OUT1>::value,
	"Types must be the same"
	);
	static_assert(
	std::is_unsigned<OUT1>::value,
	"Test operation is not implemented for signed integers"
	);
	// mad_sat unsigned integers
	OUT1 w1 = (x * y);
	if (x != 0 && w1 / x != y)
	return (std::numeric_limits<OUT1>::max)();
	OUT1 w2 = w1 + z;
	if(w2 < w1)
	return (std::numeric_limits<OUT1>::max)();
	return w2;
	}
	};

	template<class IN1, class IN2, class OUT1>
	struct int_func_sub_sat : public binary_func<IN1, IN2, OUT1>
	{
	std::string str()
	{
	return "sub_sat";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& y)
	{
	static_assert(
	std::is_same<IN1, IN2>::value && std::is_same<IN2, OUT1>::value,
	"IN1, IN2 and OUT1 must be the same types"
	);
	// sat unsigned integers
	if(std::is_unsigned<OUT1>::value)
	{
	OUT1 z = x - y;
	if(x < y)
	return (std::numeric_limits<OUT1>::min)();
	return z;
	}
	// sat signed integers
	OUT1 z = x - y;
	if(y < 0)
	{
	if(z < x)
	return (std::numeric_limits<OUT1>::max)();
	}
	else
	{
	if(z > x)
	return (std::numeric_limits<OUT1>::min)();
	}
	return z;
	}
	};

	template<class IN1, class IN2, class OUT1, class Enable = void>
	struct int_func_max : public binary_func<IN1, IN2, OUT1>
	{
	std::string str()
	{
	return "max";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& y)
	{
	static_assert(
	std::is_same<IN1, IN2>::value && std::is_same<IN2, OUT1>::value,
	"IN1, IN2 and OUT1 must be the same types"
	);
	return (std::max)(x, y);
	}
	};

	template<class IN1, class IN2, class OUT1>
	struct int_func_max<IN1, IN2, OUT1, typename std::enable_if<is_vector_type<OUT1>::value>::type> : public binary_func<IN1, IN2, OUT1>
	{
	std::string str()
	{
	return "max";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	IN1 min1()
	{
	typedef typename scalar_type<IN1>::type SCALAR1;
	IN1 min1;
	for(size_t i = 0; i < vector_size<IN1>::value; i++)
	{
	min1.s[i] = (std::numeric_limits<SCALAR1>::min)();
	}
	return min1;
	}

	IN1 max1()
	{
	typedef typename scalar_type<IN1>::type SCALAR1;
	IN1 max1;
	for(size_t i = 0; i < vector_size<IN1>::value; i++)
	{
	max1.s[i] = (std::numeric_limits<SCALAR1>::max)();
	}
	return max1;
	}

	OUT1 operator()(const IN1& x, const IN2& y)
	{
	static_assert(
	std::is_same<IN1, OUT1>::value,
	"IN1 and OUT1 must be the same types"
	);
	static_assert(
	!is_vector_type<IN2>::value,
	"IN2 must be scalar"
	);
	static_assert(
	std::is_same<typename scalar_type<OUT1>::type, IN2>::value,
	"IN2 must match with OUT1 and IN1"
	);
	IN1 result = x;
	for(size_t i = 0; i < vector_size<IN1>::value; i++)
	{
	result.s[i] = (std::max)(x.s[i], y);
	}
	return result;
	}
	};

	template<class IN1, class IN2, class OUT1, class Enable = void>
	struct int_func_min : public binary_func<IN1, IN2, OUT1>
	{
	std::string str()
	{
	return "min";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	OUT1 operator()(const IN1& x, const IN2& y)
	{
	static_assert(
	std::is_same<IN1, IN2>::value && std::is_same<IN2, OUT1>::value,
	"IN1, IN2 and OUT1 must be the same types"
	);
	return (std::min)(x, y);
	}
	};

	template<class IN1, class IN2, class OUT1>
	struct int_func_min<IN1, IN2, OUT1, typename std::enable_if<is_vector_type<OUT1>::value>::type> : public binary_func<IN1, IN2, OUT1>
	{
	std::string str()
	{
	return "min";
	}

	std::string headers()
	{
	return "#include <opencl_integer>\n";
	}

	IN1 min1()
	{
	typedef typename scalar_type<IN1>::type SCALAR1;
	IN1 min1;
	for(size_t i = 0; i < vector_size<IN1>::value; i++)
	{
	min1.s[i] = (std::numeric_limits<SCALAR1>::min)();
	}
	return min1;
	}

	IN1 max1()
	{
	typedef typename scalar_type<IN1>::type SCALAR1;
	IN1 max1;
	for(size_t i = 0; i < vector_size<IN1>::value; i++)
	{
	max1.s[i] = (std::numeric_limits<SCALAR1>::max)();
	}
	return max1;
	}

	OUT1 operator()(const IN1& x, const IN2& y)
	{
	static_assert(
	std::is_same<IN1, OUT1>::value,
	"IN1 and OUT1 must be the same types"
	);
	static_assert(
	!is_vector_type<IN2>::value,
	"IN2 must be scalar"
	);
	static_assert(
	std::is_same<typename scalar_type<OUT1>::type, IN2>::value,
	"IN2 must match with OUT1 and IN1"
	);
	IN1 result = x;
	for(size_t i = 0; i < vector_size<IN1>::value; i++)
	{
	result.s[i] = (std::min)(x.s[i], y);
	}
	return result;
	}
	};

	AUTO_TEST_CASE(test_int_numeric_funcs)
	(cl_device_id device, cl_context context, cl_command_queue queue, int n_elems)
	{
	int error = CL_SUCCESS;
	int last_error = CL_SUCCESS;

	// ugentype abs(gentype x);
	TEST_UNARY_FUNC_MACRO((int_func_abs<cl_int, cl_uint>()))
	TEST_UNARY_FUNC_MACRO((int_func_abs<cl_uint, cl_uint>()))
	TEST_UNARY_FUNC_MACRO((int_func_abs<cl_long, cl_ulong>()))
	TEST_UNARY_FUNC_MACRO((int_func_abs<cl_ulong, cl_ulong>()))

	// ugentype abs_diff(gentype x, gentype y);
	TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_int, cl_int, cl_uint>()))
	TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_uint, cl_uint, cl_uint>()))
	TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_long, cl_long, cl_ulong>()))
	TEST_BINARY_FUNC_MACRO((int_func_abs_diff<cl_ulong, cl_ulong, cl_ulong>()))

	// gentype add_sat(gentype x, gentype y);
	TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_int, cl_int, cl_int>()))
	TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_uint, cl_uint, cl_uint>()))
	TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_long, cl_long, cl_long>()))
	TEST_BINARY_FUNC_MACRO((int_func_add_sat<cl_ulong, cl_ulong, cl_ulong>()))

	// gentype hadd(gentype x, gentype y);
	TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_int, cl_int, cl_int>()))
	TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_uint, cl_uint, cl_uint>()))
	TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_long, cl_long, cl_long>()))
	TEST_BINARY_FUNC_MACRO((int_func_hadd<cl_ulong, cl_ulong, cl_ulong>()))

	// gentype rhadd(gentype x, gentype y);
	TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_int, cl_int, cl_int>()))
	TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_uint, cl_uint, cl_uint>()))
	TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_long, cl_long, cl_long>()))
	TEST_BINARY_FUNC_MACRO((int_func_rhadd<cl_ulong, cl_ulong, cl_ulong>()))

	// gentype clamp(gentype x, gentype minval, gentype maxval);
	TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_int, cl_int, cl_int, cl_int>()))
	TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_uint, cl_uint, cl_uint, cl_uint>()))
	TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_long, cl_long, cl_long, cl_long>()))
	TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_ulong, cl_ulong, cl_ulong, cl_ulong>()))

	// gentype clamp(gentype x, scalar minval, scalar maxval);
	TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_int2, cl_int, cl_int, cl_int2>()))
	TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_uint4, cl_uint, cl_uint, cl_uint4>()))
	TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_long8, cl_long, cl_long, cl_long8>()))
	TEST_TERNARY_FUNC_MACRO((int_func_clamp<cl_ulong16, cl_ulong, cl_ulong, cl_ulong16>()))

	// gentype mad_hi(gentype a, gentype b, gentype c);
	TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_short, cl_short, cl_short, cl_short>()))
	TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_ushort, cl_ushort, cl_ushort, cl_ushort>()))
	TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_int, cl_int, cl_int, cl_int>()))
	TEST_TERNARY_FUNC_MACRO((int_func_mad_hi<cl_uint, cl_uint, cl_uint, cl_uint>()))

	// gentype mad_sat(gentype a, gentype b, gentype c);
	TEST_TERNARY_FUNC_MACRO((int_func_mad_sat<cl_ushort, cl_ushort, cl_ushort, cl_ushort>()))
	TEST_TERNARY_FUNC_MACRO((int_func_mad_sat<cl_uint, cl_uint, cl_uint, cl_uint>()))
	TEST_TERNARY_FUNC_MACRO((int_func_mad_sat<cl_ulong, cl_ulong, cl_ulong, cl_ulong>()))

	// gentype max(gentype x, gentype y);
	TEST_BINARY_FUNC_MACRO((int_func_max<cl_int, cl_int, cl_int>()))
	TEST_BINARY_FUNC_MACRO((int_func_max<cl_uint, cl_uint, cl_uint>()))
	TEST_BINARY_FUNC_MACRO((int_func_max<cl_long, cl_long, cl_long>()))
	TEST_BINARY_FUNC_MACRO((int_func_max<cl_ulong, cl_ulong, cl_ulong>()))

	// gentype max(gentype x, scalar y);
	TEST_BINARY_FUNC_MACRO((int_func_max<cl_int2, cl_int, cl_int2>()))
	TEST_BINARY_FUNC_MACRO((int_func_max<cl_uint4, cl_uint, cl_uint4>()))
	TEST_BINARY_FUNC_MACRO((int_func_max<cl_long8, cl_long, cl_long8>()))
	TEST_BINARY_FUNC_MACRO((int_func_max<cl_ulong16, cl_ulong, cl_ulong16>()))

	// gentype min(gentype x, gentype y);
	TEST_BINARY_FUNC_MACRO((int_func_min<cl_int, cl_int, cl_int>()))
	TEST_BINARY_FUNC_MACRO((int_func_min<cl_uint, cl_uint, cl_uint>()))
	TEST_BINARY_FUNC_MACRO((int_func_min<cl_long, cl_long, cl_long>()))
	TEST_BINARY_FUNC_MACRO((int_func_min<cl_ulong, cl_ulong, cl_ulong>()))

	// gentype min(gentype x, scalar y);
	TEST_BINARY_FUNC_MACRO((int_func_min<cl_int2, cl_int, cl_int2>()))
	TEST_BINARY_FUNC_MACRO((int_func_min<cl_uint4, cl_uint, cl_uint4>()))
	TEST_BINARY_FUNC_MACRO((int_func_min<cl_long8, cl_long, cl_long8>()))
	TEST_BINARY_FUNC_MACRO((int_func_min<cl_ulong16, cl_ulong, cl_ulong16>()))

	// gentype mul_hi(gentype x, gentype y);
	TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_short, cl_short, cl_short>()))
	TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_ushort, cl_ushort, cl_ushort>()))
	TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_int, cl_int, cl_int>()))
	TEST_BINARY_FUNC_MACRO((int_func_mul_hi<cl_uint, cl_uint, cl_uint>()))

	// gentype sub_sat(gentype x, gentype y);
	TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_int, cl_int, cl_int>()))
	TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_uint, cl_uint, cl_uint>()))
	TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_long, cl_long, cl_long>()))
	TEST_BINARY_FUNC_MACRO((int_func_sub_sat<cl_ulong, cl_ulong, cl_ulong>()))

	if(error != CL_SUCCESS)
	{
	return -1;
	}
	return error;
	}

	#endif // TEST_CONFORMANCE_CLCPP_INTEGER_FUNCS_NUMERIC_HPP