1 //
2 // Copyright (c) 2017 The Khronos Group Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 #ifndef TEST_CONFORMANCE_CLCPP_UTILS_TEST_GENERATE_INPUTS_HPP
17 #define TEST_CONFORMANCE_CLCPP_UTILS_TEST_GENERATE_INPUTS_HPP
18
19 #include <random>
20 #include <limits>
21 #include <type_traits>
22 #include <algorithm>
23
24 #include <cmath>
25
26 #include "../common.hpp"
27
28 template <class type>
generate_input(size_t count,const type & min,const type & max,const std::vector<type> special_cases,typename std::enable_if<is_vector_type<type>::value && std::is_integral<typename scalar_type<type>::type>::value &&!(std::is_same<typename scalar_type<type>::type,cl_uchar>::value||std::is_same<typename scalar_type<type>::type,cl_char>::value)>::type * =0)29 std::vector<type> generate_input(size_t count,
30 const type& min,
31 const type& max,
32 const std::vector<type> special_cases,
33 typename std::enable_if<
34 is_vector_type<type>::value
35 && std::is_integral<typename scalar_type<type>::type>::value
36 // std::uniform_int_distribution<> does not work in VS2015 for cl_uchar and cl_char,
37 // because VS2015 thinks that use cl_int, because VS2015 thinks cl_uchar cl_char are
38 // not int types
39 && !(std::is_same<typename scalar_type<type>::type, cl_uchar>::value
40 || std::is_same<typename scalar_type<type>::type, cl_char>::value)
41 >::type* = 0)
42 {
43 typedef typename scalar_type<type>::type SCALAR;
44 const size_t vec_size = vector_size<type>::value;
45
46 std::vector<type> input(count);
47 std::random_device rd;
48 std::mt19937 gen(rd());
49 std::vector<std::uniform_int_distribution<SCALAR>> dists(vec_size);
50 for(size_t i = 0; i < vec_size; i++)
51 {
52 dists[i] = std::uniform_int_distribution<SCALAR>(min.s[i], max.s[i]);
53 }
54 for(auto& i : input)
55 {
56 for(size_t j = 0; j < vec_size; j++)
57 {
58 i.s[j] = dists[j](gen);
59 }
60 }
61
62 input.insert(input.begin(), special_cases.begin(), special_cases.end());
63 input.resize(count);
64 return input;
65 }
66
67 template <class type>
generate_input(size_t count,const type & min,const type & max,const std::vector<type> special_cases,typename std::enable_if<is_vector_type<type>::value && std::is_integral<typename scalar_type<type>::type>::value && (std::is_same<typename scalar_type<type>::type,cl_uchar>::value||std::is_same<typename scalar_type<type>::type,cl_char>::value)>::type * =0)68 std::vector<type> generate_input(size_t count,
69 const type& min,
70 const type& max,
71 const std::vector<type> special_cases,
72 typename std::enable_if<
73 is_vector_type<type>::value
74 && std::is_integral<typename scalar_type<type>::type>::value
75 // std::uniform_int_distribution<> does not work in VS2015 for cl_uchar and cl_char,
76 // because VS2015 thinks that use cl_int, because VS2015 thinks cl_uchar cl_char are
77 // not int types
78 && (std::is_same<typename scalar_type<type>::type, cl_uchar>::value
79 || std::is_same<typename scalar_type<type>::type, cl_char>::value)
80 >::type* = 0)
81 {
82 typedef typename scalar_type<type>::type SCALAR;
83 const size_t vec_size = vector_size<type>::value;
84
85 std::vector<type> input(count);
86 std::random_device rd;
87 std::mt19937 gen(rd());
88 std::vector<std::uniform_int_distribution<cl_int>> dists(vec_size);
89 for(size_t i = 0; i < vec_size; i++)
90 {
91 dists[i] = std::uniform_int_distribution<cl_int>(
92 static_cast<cl_int>(min.s[i]),
93 static_cast<cl_int>(max.s[i])
94 );
95 }
96 for(auto& i : input)
97 {
98 for(size_t j = 0; j < vec_size; j++)
99 {
100 i.s[j] = static_cast<SCALAR>(dists[j](gen));
101 }
102 }
103
104 input.insert(input.begin(), special_cases.begin(), special_cases.end());
105 input.resize(count);
106 return input;
107 }
108
109
110 template <class type>
generate_input(size_t count,const type & min,const type & max,const std::vector<type> special_cases,typename std::enable_if<!is_vector_type<type>::value && std::is_integral<type>::value &&!(std::is_same<type,cl_uchar>::value||std::is_same<type,cl_char>::value)>::type * =0)111 std::vector<type> generate_input(size_t count,
112 const type& min,
113 const type& max,
114 const std::vector<type> special_cases,
115 typename std::enable_if<
116 !is_vector_type<type>::value
117 && std::is_integral<type>::value
118 // std::uniform_int_distribution<> does not work in VS2015 for cl_uchar and cl_char,
119 // because VS2015 thinks that use cl_int, because VS2015 thinks cl_uchar cl_char are
120 // not int types
121 && !(std::is_same<type, cl_uchar>::value || std::is_same<type, cl_char>::value)
122 >::type* = 0)
123 {
124 std::vector<type> input(count);
125 std::random_device rd;
126 std::mt19937 gen(rd());
127 std::uniform_int_distribution<type> dis(min, max);
128 for(auto& i : input)
129 {
130 i = dis(gen);
131 }
132
133 input.insert(input.begin(), special_cases.begin(), special_cases.end());
134 input.resize(count);
135 return input;
136 }
137
138 template <class type>
generate_input(size_t count,const type & min,const type & max,const std::vector<type> special_cases,typename std::enable_if<!is_vector_type<type>::value && std::is_integral<type>::value && (std::is_same<type,cl_uchar>::value||std::is_same<type,cl_char>::value)>::type * =0)139 std::vector<type> generate_input(size_t count,
140 const type& min,
141 const type& max,
142 const std::vector<type> special_cases,
143 typename std::enable_if<
144 !is_vector_type<type>::value
145 && std::is_integral<type>::value
146 // std::uniform_int_distribution<> does not work in VS2015 for cl_uchar and cl_char,
147 // because VS2015 thinks that use cl_int, because VS2015 thinks cl_uchar cl_char are
148 // not int types
149 && (std::is_same<type, cl_uchar>::value || std::is_same<type, cl_char>::value)
150 >::type* = 0)
151 {
152 std::vector<type> input(count);
153 std::random_device rd;
154 std::mt19937 gen(rd());
155 std::uniform_int_distribution<cl_int> dis(
156 static_cast<cl_int>(min), static_cast<cl_int>(max)
157 );
158 for(auto& i : input)
159 {
160 i = static_cast<type>(dis(gen));
161 }
162
163 input.insert(input.begin(), special_cases.begin(), special_cases.end());
164 input.resize(count);
165 return input;
166 }
167
168 template <class type>
generate_input(size_t count,const type & min,const type & max,const std::vector<type> special_cases,typename std::enable_if<is_vector_type<type>::value && std::is_floating_point<typename scalar_type<type>::type>::value>::type * =0)169 std::vector<type> generate_input(size_t count,
170 const type& min,
171 const type& max,
172 const std::vector<type> special_cases,
173 typename std::enable_if<
174 is_vector_type<type>::value
175 && std::is_floating_point<typename scalar_type<type>::type>::value
176 >::type* = 0)
177 {
178 typedef typename scalar_type<type>::type SCALAR;
179 const size_t vec_size = vector_size<type>::value;
180
181 std::vector<type> input(count);
182 std::random_device rd;
183 std::mt19937 gen(rd());
184 std::vector<std::uniform_real_distribution<SCALAR>> dists(vec_size);
185 for(size_t i = 0; i < vec_size; i++)
186 {
187 // Fatal error
188 if(std::fpclassify(max.s[i]) == FP_SUBNORMAL || std::fpclassify(min.s[i]) == FP_SUBNORMAL)
189 {
190 log_error("ERROR: min and max value for input generation CAN NOT BE subnormal\n");
191 }
192 dists[i] = std::uniform_real_distribution<SCALAR>(min.s[i], max.s[i]);
193 }
194 for(auto& i : input)
195 {
196 for(size_t j = 0; j < vec_size; j++)
197 {
198 SCALAR x = dists[j](gen);
199 while(std::fpclassify(x) == FP_SUBNORMAL)
200 {
201 x = dists[j](gen);
202 }
203 i.s[j] = x;
204 }
205 }
206
207 input.insert(input.begin(), special_cases.begin(), special_cases.end());
208 input.resize(count);
209 return input;
210 }
211
212 template <class type>
generate_input(size_t count,const type & min,const type & max,const std::vector<type> special_cases,typename std::enable_if<!is_vector_type<type>::value && std::is_floating_point<type>::value>::type * =0)213 std::vector<type> generate_input(size_t count,
214 const type& min,
215 const type& max,
216 const std::vector<type> special_cases,
217 typename std::enable_if<
218 !is_vector_type<type>::value
219 && std::is_floating_point<type>::value
220 >::type* = 0)
221 {
222 // Fatal error
223 if(std::fpclassify(max) == FP_SUBNORMAL || std::fpclassify(min) == FP_SUBNORMAL)
224 {
225 log_error("ERROR: min and max value for input generation CAN NOT BE subnormal\n");
226 }
227 std::vector<type> input(count);
228 std::random_device rd;
229 std::mt19937 gen(rd());
230 std::uniform_real_distribution<type> dis(min, max);
231 for(auto& i : input)
232 {
233 type x = dis(gen);
234 while(std::fpclassify(x) == FP_SUBNORMAL)
235 {
236 x = dis(gen);
237 }
238 i = x;
239 }
240
241 input.insert(input.begin(), special_cases.begin(), special_cases.end());
242 input.resize(count);
243 return input;
244 }
245
246 template <class type>
generate_output(size_t count,typename scalar_type<type>::type svalue=typename scalar_type<type>::type (0),typename std::enable_if<is_vector_type<type>::value>::type * =0)247 std::vector<type> generate_output(size_t count,
248 typename scalar_type<type>::type svalue = typename scalar_type<type>::type(0),
249 typename std::enable_if<is_vector_type<type>::value>::type* = 0)
250 {
251 type value;
252 for(size_t i = 0; i < vector_size<type>::value; i++)
253 value.s[i] = svalue;
254 return std::vector<type>(count, value);
255 }
256
257 template <class type>
generate_output(size_t count,type svalue=type (0),typename std::enable_if<!is_vector_type<type>::value>::type * =0)258 std::vector<type> generate_output(size_t count,
259 type svalue = type(0),
260 typename std::enable_if<!is_vector_type<type>::value>::type* = 0)
261 {
262 return std::vector<type>(count, svalue);
263 }
264
265 template<class T, class K>
prepare_special_cases(std::vector<T> & in1_spec_cases,std::vector<K> & in2_spec_cases)266 void prepare_special_cases(std::vector<T>& in1_spec_cases, std::vector<K>& in2_spec_cases)
267 {
268 if(in1_spec_cases.empty() || in2_spec_cases.empty())
269 {
270 return;
271 }
272
273 size_t new_size = in1_spec_cases.size() * in2_spec_cases.size();
274 std::vector<T> new_in1(new_size);
275 std::vector<K> new_in2(new_size);
276 for(size_t i = 0; i < in1_spec_cases.size(); i++)
277 {
278 for(size_t j = 0; j < in2_spec_cases.size(); j++)
279 {
280 new_in1[(i * in2_spec_cases.size()) + j] = in1_spec_cases[i];
281 new_in2[(i * in2_spec_cases.size()) + j] = in2_spec_cases[j];
282 }
283 }
284 in1_spec_cases = new_in1;
285 in2_spec_cases = new_in2;
286 }
287
288 template<class T, class K, class M>
prepare_special_cases(std::vector<T> & in1_spec_cases,std::vector<K> & in2_spec_cases,std::vector<M> & in3_spec_cases)289 void prepare_special_cases(std::vector<T>& in1_spec_cases,
290 std::vector<K>& in2_spec_cases,
291 std::vector<M>& in3_spec_cases)
292 {
293 if(in3_spec_cases.empty())
294 {
295 return prepare_special_cases(in1_spec_cases, in2_spec_cases);
296 }
297 else if (in2_spec_cases.empty())
298 {
299 return prepare_special_cases(in1_spec_cases, in3_spec_cases);
300 }
301 else if (in1_spec_cases.empty())
302 {
303 return prepare_special_cases(in2_spec_cases, in3_spec_cases);
304 }
305
306 size_t new_size = in1_spec_cases.size() * in2_spec_cases.size() * in3_spec_cases.size();
307 std::vector<T> new_in1(new_size);
308 std::vector<K> new_in2(new_size);
309 std::vector<M> new_in3(new_size);
310 for(size_t i = 0; i < in1_spec_cases.size(); i++)
311 {
312 for(size_t j = 0; j < in2_spec_cases.size(); j++)
313 {
314 for(size_t k = 0; k < in3_spec_cases.size(); k++)
315 {
316 size_t idx =
317 (i * in2_spec_cases.size() * in3_spec_cases.size())
318 + (j * in3_spec_cases.size())
319 + k;
320 new_in1[idx] = in1_spec_cases[i];
321 new_in2[idx] = in2_spec_cases[j];
322 new_in3[idx] = in3_spec_cases[k];
323 }
324 }
325 }
326 in1_spec_cases = new_in1;
327 in2_spec_cases = new_in2;
328 in3_spec_cases = new_in3;
329 }
330
331 #endif // TEST_CONFORMANCE_CLCPP_UTILS_TEST_GENERATE_INPUTS_HPP
332