1 //---------------------------------------------------------------------------//
2 // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
4 // Distributed under the Boost Software License, Version 1.0
5 // See accompanying file LICENSE_1_0.txt or copy at
6 // http://www.boost.org/LICENSE_1_0.txt
8 // See http://boostorg.github.com/compute for more information.
9 //---------------------------------------------------------------------------//
11 #ifndef BOOST_COMPUTE_TYPES_FUNDAMENTAL_HPP
12 #define BOOST_COMPUTE_TYPES_FUNDAMENTAL_HPP
17 #include <boost/preprocessor/cat.hpp>
18 #include <boost/preprocessor/comma.hpp>
19 #include <boost/preprocessor/repetition.hpp>
20 #include <boost/preprocessor/stringize.hpp>
22 #include <boost/compute/cl.hpp>
28 typedef cl_char char_;
29 typedef cl_uchar uchar_;
30 typedef cl_short short_;
31 typedef cl_ushort ushort_;
33 typedef cl_uint uint_;
34 typedef cl_long long_;
35 typedef cl_ulong ulong_;
36 typedef cl_float float_;
37 typedef cl_double double_;
39 // converts uchar to ::boost::compute::uchar_
40 #define BOOST_COMPUTE_MAKE_SCALAR_TYPE(scalar) \
41 BOOST_PP_CAT(::boost::compute::scalar, _)
43 // converts float, 4 to ::boost::compute::float4_
44 #define BOOST_COMPUTE_MAKE_VECTOR_TYPE(scalar, size) \
45 BOOST_PP_CAT(BOOST_PP_CAT(::boost::compute::scalar, size), _)
48 template<class Scalar, size_t N>
52 typedef Scalar scalar_type;
59 explicit vector_type(const Scalar scalar)
61 for(size_t i = 0; i < N; i++)
65 vector_type(const vector_type<Scalar, N> &other)
67 std::memcpy(m_value, other.m_value, sizeof(m_value));
70 vector_type<Scalar, N>&
71 operator=(const vector_type<Scalar, N> &other)
73 std::memcpy(m_value, other.m_value, sizeof(m_value));
82 Scalar& operator[](size_t i)
87 Scalar operator[](size_t i) const
92 bool operator==(const vector_type<Scalar, N> &other) const
94 return std::memcmp(m_value, other.m_value, sizeof(m_value)) == 0;
97 bool operator!=(const vector_type<Scalar, N> &other) const
99 return !(*this == other);
103 scalar_type m_value[N];
106 #define BOOST_COMPUTE_VECTOR_TYPE_CTOR_ARG_FUNCTION(z, i, _) \
107 BOOST_PP_COMMA_IF(i) scalar_type BOOST_PP_CAT(arg, i)
108 #define BOOST_COMPUTE_VECTOR_TYPE_DECLARE_CTOR_ARGS(scalar, size) \
109 BOOST_PP_REPEAT(size, BOOST_COMPUTE_VECTOR_TYPE_CTOR_ARG_FUNCTION, _)
110 #define BOOST_COMPUTE_VECTOR_TYPE_ASSIGN_CTOR_ARG(z, i, _) \
111 m_value[i] = BOOST_PP_CAT(arg, i);
112 #define BOOST_COMPUTE_VECTOR_TYPE_ASSIGN_CTOR_SINGLE_ARG(z, i, _) \
115 #define BOOST_COMPUTE_DECLARE_VECTOR_TYPE_CLASS(cl_scalar, size, class_name) \
116 class class_name : public vector_type<cl_scalar, size> \
120 explicit class_name( scalar_type arg ) \
122 BOOST_PP_REPEAT(size, BOOST_COMPUTE_VECTOR_TYPE_ASSIGN_CTOR_SINGLE_ARG, _) \
125 BOOST_PP_REPEAT(size, BOOST_COMPUTE_VECTOR_TYPE_CTOR_ARG_FUNCTION, _) \
128 BOOST_PP_REPEAT(size, BOOST_COMPUTE_VECTOR_TYPE_ASSIGN_CTOR_ARG, _) \
132 #define BOOST_COMPUTE_DECLARE_VECTOR_TYPE(scalar, size) \
133 BOOST_COMPUTE_DECLARE_VECTOR_TYPE_CLASS(BOOST_PP_CAT(cl_, scalar), \
135 BOOST_PP_CAT(BOOST_PP_CAT(scalar, size), _)) \
137 inline std::ostream& operator<<( \
139 const BOOST_COMPUTE_MAKE_VECTOR_TYPE(scalar, size) &v) \
141 s << BOOST_PP_STRINGIZE(BOOST_PP_CAT(scalar, size)) << "("; \
142 for(size_t i = 0; i < size; i++){\
152 #define BOOST_COMPUTE_DECLARE_VECTOR_TYPES(scalar) \
153 BOOST_COMPUTE_DECLARE_VECTOR_TYPE(scalar, 2) \
154 BOOST_COMPUTE_DECLARE_VECTOR_TYPE(scalar, 4) \
155 BOOST_COMPUTE_DECLARE_VECTOR_TYPE(scalar, 8) \
156 BOOST_COMPUTE_DECLARE_VECTOR_TYPE(scalar, 16) \
158 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(char)
159 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(uchar)
160 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(short)
161 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(ushort)
162 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(int)
163 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(uint)
164 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(long)
165 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(ulong)
166 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(float)
167 BOOST_COMPUTE_DECLARE_VECTOR_TYPES(double)
169 } // end compute namespace
170 } // end boost namespace
172 #endif // BOOST_COMPUTE_TYPES_FUNDAMENTAL_HPP