ViennaCL - The Vienna Computing Library: tests/src/vector_uint.cpp Source File

ViennaCL - The Vienna Computing Library 1.7.1 Free open-source GPU-accelerated linear algebra and solver library. |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
vector_uint.cpp
Go to the documentation of this file.
1 /* =========================================================================
2 Copyright (c) 2010-2016, Institute for Microelectronics,
3 Institute for Analysis and Scientific Computing,
4 TU Wien.
5 Portions of this software are copyright by UChicago Argonne, LLC.
6
7 -----------------
8 ViennaCL - The Vienna Computing Library
9 -----------------
10
11 Project Head: Karl Rupp rupp@iue.tuwien.ac.at
12
13 (A list of authors and contributors can be found in the PDF manual)
14
15 License: MIT (X11), see file LICENSE in the base directory
16 ============================================================================= */
17
18
19
24 //
25 // *** System
26 //
27 #include <iostream>
28 #include <iomanip>
29 #include <vector>
30
31 //
32 // *** ViennaCL
33 //
34 #include "viennacl/vector.hpp"
35 #include "viennacl/vector_proxy.hpp"
36 #include "viennacl/linalg/inner_prod.hpp"
37 #include "viennacl/linalg/norm_1.hpp"
38 #include "viennacl/linalg/norm_2.hpp"
39 #include "viennacl/linalg/norm_inf.hpp"
40 #include "viennacl/linalg/maxmin.hpp"
41 #include "viennacl/linalg/sum.hpp"
42
43
44 //
45 // -------------------------------------------------------------
46 //
47 template<typename ScalarType>
48 ScalarType diff(ScalarType const & s1, ScalarType const & s2)
49 {
50 viennacl::backend::finish();
51 return s1 - s2;
52 }
53 //
54 // -------------------------------------------------------------
55 //
56 template<typename ScalarType>
57 ScalarType diff(ScalarType const & s1, viennacl::scalar<ScalarType> const & s2)
58 {
59 viennacl::backend::finish();
60 return s1 - s2;
61 }
62 //
63 // -------------------------------------------------------------
64 //
65 template<typename ScalarType>
66 ScalarType diff(ScalarType const & s1, viennacl::entry_proxy<ScalarType> const & s2)
67 {
68 viennacl::backend::finish();
69 return s1 - s2;
70 }
71 //
72 // -------------------------------------------------------------
73 //
74 template<typename ScalarType, typename VCLVectorType>
75 ScalarType diff(std::vector<ScalarType> const & v1, VCLVectorType const & v2)
76 {
77 std::vector<ScalarType> v2_cpu(v2.size());
78 viennacl::backend::finish(); //workaround for a bug in APP SDK 2.7 on Trinity APUs (with Catalyst 12.8)
79 viennacl::copy(v2.begin(), v2.end(), v2_cpu.begin());
80
81 for (unsigned int i=0;i<v1.size(); ++i)
82 {
83 if (v2_cpu[i] != v1[i])
84 return 1;
85 }
86
87 return 0;
88 }
89
90
91 template<typename T1, typename T2>
92 int check(T1 const & t1, T2 const & t2)
93 {
94 int retval = EXIT_SUCCESS;
95
96 if (diff(t1, t2) != 0)
97 {
98 std::cout << "# Error! Difference: " << diff(t1, t2) << std::endl;
99 retval = EXIT_FAILURE;
100 }
101 return retval;
102 }
103
104
105 //
106 // -------------------------------------------------------------
107 //
108 template< typename NumericT, typename STLVectorType, typename ViennaCLVectorType1, typename ViennaCLVectorType2 >
109 int test(STLVectorType & std_v1, STLVectorType & std_v2,
110 ViennaCLVectorType1 & vcl_v1, ViennaCLVectorType2 & vcl_v2)
111 {
112 int retval = EXIT_SUCCESS;
113
114 NumericT cpu_result = 42;
115 viennacl::scalar<NumericT> gpu_result = 43;
116
117 //
118 // Initializer:
119 //
120 std::cout << "Checking for zero_vector initializer..." << std::endl;
121 for (std::size_t i=0; i<std_v1.size(); ++i)
122 std_v1[i] = 0;
123 vcl_v1 = viennacl::zero_vector<NumericT>(vcl_v1.size());
124 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
125 return EXIT_FAILURE;
126
127 std::cout << "Checking for scalar_vector initializer..." << std::endl;
128 for (std::size_t i=0; i<std_v1.size(); ++i)
129 std_v1[i] = cpu_result;
130 vcl_v1 = viennacl::scalar_vector<NumericT>(vcl_v1.size(), cpu_result);
131 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
132 return EXIT_FAILURE;
133
134 for (std::size_t i=0; i<std_v1.size(); ++i)
135 std_v1[i] = cpu_result + 1;
136 vcl_v1 = viennacl::scalar_vector<NumericT>(vcl_v1.size(), gpu_result);
137 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
138 return EXIT_FAILURE;
139
140 std::cout << "Checking for unit_vector initializer..." << std::endl;
141 for (std::size_t i=0; i<std_v1.size(); ++i)
142 std_v1[i] = (i == 5) ? 1 : 0;
143 vcl_v1 = viennacl::unit_vector<NumericT>(vcl_v1.size(), 5);
144 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
145 return EXIT_FAILURE;
146
147 for (std::size_t i=0; i<std_v1.size(); ++i)
148 {
149 std_v1[i] = NumericT(i);
150 std_v2[i] = NumericT(i+42);
151 }
152
153 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin()); //resync
154 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
155
156 std::cout << "Checking for successful copy..." << std::endl;
157 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
158 return EXIT_FAILURE;
159 if (check(std_v2, vcl_v2) != EXIT_SUCCESS)
160 return EXIT_FAILURE;
161
162 //
163 // Part 1: Norms and inner product
164 //
165
166 // --------------------------------------------------------------------------
167 std::cout << "Testing inner_prod..." << std::endl;
168 cpu_result = 0;
169 for (std::size_t i=0; i<std_v1.size(); ++i)
170 cpu_result += std_v1[i] * std_v2[i];
171 NumericT cpu_result2 = viennacl::linalg::inner_prod(vcl_v1, vcl_v2);
172 gpu_result = viennacl::linalg::inner_prod(vcl_v1, vcl_v2);
173
174 if (check(cpu_result, cpu_result2) != EXIT_SUCCESS)
175 return EXIT_FAILURE;
176 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
177 return EXIT_FAILURE;
178
179 cpu_result = 0;
180 for (std::size_t i=0; i<std_v1.size(); ++i)
181 cpu_result += (std_v1[i] + std_v2[i]) * (2*std_v2[i]);
182 NumericT cpu_result3 = viennacl::linalg::inner_prod(vcl_v1 + vcl_v2, 2*vcl_v2);
183 gpu_result = viennacl::linalg::inner_prod(vcl_v1 + vcl_v2, 2*vcl_v2);
184
185 if (check(cpu_result, cpu_result3) != EXIT_SUCCESS)
186 return EXIT_FAILURE;
187 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
188 return EXIT_FAILURE;
189
190 // --------------------------------------------------------------------------
191 std::cout << "Testing norm_1..." << std::endl;
192 cpu_result = 0;
193 for (std::size_t i=0; i<std_v1.size(); ++i) //note: norm_1 broken for unsigned ints on MacOS
194 cpu_result += std_v1[i];
195 gpu_result = viennacl::linalg::norm_1(vcl_v1);
196
197 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
198 return EXIT_FAILURE;
199
200 cpu_result2 = 0; //reset
201 for (std::size_t i=0; i<std_v1.size(); ++i) //note: norm_1 broken for unsigned ints on MacOS
202 cpu_result2 += std_v1[i];
203 cpu_result = viennacl::linalg::norm_1(vcl_v1);
204
205 if (check(cpu_result, cpu_result2) != EXIT_SUCCESS)
206 return EXIT_FAILURE;
207
208 cpu_result2 = 0;
209 for (std::size_t i=0; i<std_v1.size(); ++i) //note: norm_1 broken for unsigned ints on MacOS
210 cpu_result2 += std_v1[i] + std_v2[i];
211 cpu_result = viennacl::linalg::norm_1(vcl_v1 + vcl_v2);
212
213 if (check(cpu_result, cpu_result2) != EXIT_SUCCESS)
214 return EXIT_FAILURE;
215
216 // --------------------------------------------------------------------------
217 std::cout << "Testing norm_inf..." << std::endl;
218 cpu_result = 0;
219 for (std::size_t i=0; i<std_v1.size(); ++i)
220 if (std_v1[i] > cpu_result)
221 cpu_result = std_v1[i];
222 gpu_result = viennacl::linalg::norm_inf(vcl_v1);
223
224 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
225 return EXIT_FAILURE;
226
227 cpu_result2 = 0;
228 for (std::size_t i=0; i<std_v1.size(); ++i)
229 if (std_v1[i] > cpu_result2)
230 cpu_result2 = std_v1[i];
231 cpu_result = viennacl::linalg::norm_inf(vcl_v1);
232
233 if (check(cpu_result, cpu_result2) != EXIT_SUCCESS)
234 return EXIT_FAILURE;
235
236 cpu_result2 = 0;
237 for (std::size_t i=0; i<std_v1.size(); ++i)
238 if (std_v1[i] + std_v2[i] > cpu_result2)
239 cpu_result2 = std_v1[i] + std_v2[i];
240 cpu_result = viennacl::linalg::norm_inf(vcl_v1 + vcl_v2);
241
242 if (check(cpu_result, cpu_result2) != EXIT_SUCCESS)
243 return EXIT_FAILURE;
244
245 // --------------------------------------------------------------------------
246 std::cout << "Testing index_norm_inf..." << std::endl;
247
248 std::size_t cpu_index = 0;
249 cpu_result = 0;
250 for (std::size_t i=0; i<std_v1.size(); ++i)
251 if (std_v1[i] > cpu_result)
252 {
253 cpu_result = std_v1[i];
254 cpu_index = i;
255 }
256 std::size_t gpu_index = viennacl::linalg::index_norm_inf(vcl_v1);
257
258 if (check(static_cast<NumericT>(cpu_index), static_cast<NumericT>(gpu_index)) != EXIT_SUCCESS)
259 return EXIT_FAILURE;
260 // --------------------------------------------------------------------------
261 gpu_result = vcl_v1[viennacl::linalg::index_norm_inf(vcl_v1)];
262
263 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
264 return EXIT_FAILURE;
265
266 cpu_index = 0;
267 cpu_result = 0;
268 for (std::size_t i=0; i<std_v1.size(); ++i)
269 if (std_v1[i] + std_v2[i] > cpu_result)
270 {
271 cpu_result = std_v1[i];
272 cpu_index = i;
273 }
274 gpu_result = vcl_v1[viennacl::linalg::index_norm_inf(vcl_v1 + vcl_v2)];
275
276 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
277 return EXIT_FAILURE;
278
279 // --------------------------------------------------------------------------
280 std::cout << "Testing max..." << std::endl;
281 cpu_result = std_v1[0];
282 for (std::size_t i=0; i<std_v1.size(); ++i)
283 cpu_result = std::max<NumericT>(cpu_result, std_v1[i]);
284 gpu_result = viennacl::linalg::max(vcl_v1);
285
286 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
287 return EXIT_FAILURE;
288
289 cpu_result = std_v1[0];
290 for (std::size_t i=0; i<std_v1.size(); ++i)
291 cpu_result = std::max<NumericT>(cpu_result, std_v1[i]);
292 gpu_result = cpu_result;
293 cpu_result *= 2; //reset
294 cpu_result = viennacl::linalg::max(vcl_v1);
295
296 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
297 return EXIT_FAILURE;
298
299 cpu_result = std_v1[0] + std_v2[0];
300 for (std::size_t i=0; i<std_v1.size(); ++i)
301 cpu_result = std::max<NumericT>(cpu_result, std_v1[i] + std_v2[i]);
302 gpu_result = cpu_result;
303 cpu_result *= 2; //reset
304 cpu_result = viennacl::linalg::max(vcl_v1 + vcl_v2);
305
306 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
307 return EXIT_FAILURE;
308
309
310 // --------------------------------------------------------------------------
311 std::cout << "Testing min..." << std::endl;
312 cpu_result = std_v1[0];
313 for (std::size_t i=0; i<std_v1.size(); ++i)
314 cpu_result = std::min<NumericT>(cpu_result, std_v1[i]);
315 gpu_result = viennacl::linalg::min(vcl_v1);
316
317 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
318 return EXIT_FAILURE;
319
320 cpu_result = std_v1[0];
321 for (std::size_t i=0; i<std_v1.size(); ++i)
322 cpu_result = std::min<NumericT>(cpu_result, std_v1[i]);
323 gpu_result = cpu_result;
324 cpu_result *= 2; //reset
325 cpu_result = viennacl::linalg::min(vcl_v1);
326
327 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
328 return EXIT_FAILURE;
329
330 cpu_result = std_v1[0] + std_v2[0];
331 for (std::size_t i=0; i<std_v1.size(); ++i)
332 cpu_result = std::min<NumericT>(cpu_result, std_v1[i] + std_v2[i]);
333 gpu_result = cpu_result;
334 cpu_result *= 2; //reset
335 cpu_result = viennacl::linalg::min(vcl_v1 + vcl_v2);
336
337 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
338 return EXIT_FAILURE;
339
340 // --------------------------------------------------------------------------
341 std::cout << "Testing sum..." << std::endl;
342 cpu_result = 0;
343 for (std::size_t i=0; i<std_v1.size(); ++i)
344 cpu_result += std_v1[i];
345 cpu_result2 = viennacl::linalg::sum(vcl_v1);
346 gpu_result = viennacl::linalg::sum(vcl_v1);
347
348 if (check(cpu_result, cpu_result2) != EXIT_SUCCESS)
349 return EXIT_FAILURE;
350 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
351 return EXIT_FAILURE;
352
353 cpu_result = 0;
354 for (std::size_t i=0; i<std_v1.size(); ++i)
355 cpu_result += std_v1[i] + std_v2[i];
356 cpu_result3 = viennacl::linalg::sum(vcl_v1 + vcl_v2);
357 gpu_result = viennacl::linalg::sum(vcl_v1 + vcl_v2);
358
359 if (check(cpu_result, cpu_result3) != EXIT_SUCCESS)
360 return EXIT_FAILURE;
361 if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
362 return EXIT_FAILURE;
363
364
365 // --------------------------------------------------------------------------
366
367 std::cout << "Testing assignments..." << std::endl;
368 NumericT val = static_cast<NumericT>(1);
369 for (size_t i=0; i < std_v1.size(); ++i)
370 std_v1[i] = val;
371
372 for (size_t i=0; i < vcl_v1.size(); ++i)
373 vcl_v1(i) = val;
374
375 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
376 return EXIT_FAILURE;
377
378
379 //
380 // multiplication and division of vectors by scalars
381 //
382 std::cout << "Testing scaling with CPU scalar..." << std::endl;
383 NumericT alpha = static_cast<NumericT>(3);
384 viennacl::scalar<NumericT> gpu_alpha = alpha;
385
386 for (size_t i=0; i<std_v1.size(); ++i)
387 std_v1[i] *= alpha;
388 vcl_v1 *= alpha;
389
390 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
391 return EXIT_FAILURE;
392
393 std::cout << "Testing scaling with GPU scalar..." << std::endl;
394 for (size_t i=0; i<std_v1.size(); ++i)
395 std_v1[i] *= alpha;
396 vcl_v1 *= gpu_alpha;
397
398 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
399 return EXIT_FAILURE;
400
401 NumericT beta = static_cast<NumericT>(2);
402 viennacl::scalar<NumericT> gpu_beta = beta;
403
404 std::cout << "Testing shrinking with CPU scalar..." << std::endl;
405 for (size_t i=0; i<std_v1.size(); ++i)
406 std_v1[i] /= beta;
407 vcl_v1 /= beta;
408
409 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
410 return EXIT_FAILURE;
411
412 std::cout << "Testing shrinking with GPU scalar..." << std::endl;
413 for (size_t i=0; i<std_v1.size(); ++i)
414 std_v1[i] /= beta;
415 vcl_v1 /= gpu_beta;
416
417 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
418 return EXIT_FAILURE;
419
420
421 //
422 // add and inplace_add of vectors
423 //
424 for (size_t i=0; i<std_v1.size(); ++i)
425 std_v1[i] = NumericT(i);
426 for (size_t i=0; i<std_v1.size(); ++i)
427 std_v2[i] = 3 * std_v1[i];
428 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin()); //resync
429 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
430
431 std::cout << "Testing add on vector..." << std::endl;
432
433 std::cout << "Checking for successful copy..." << std::endl;
434 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
435 return EXIT_FAILURE;
436 if (check(std_v2, vcl_v2) != EXIT_SUCCESS)
437 return EXIT_FAILURE;
438
439 for (size_t i=0; i<std_v1.size(); ++i)
440 std_v1[i] = std_v1[i] + std_v2[i];
441 vcl_v1 = vcl_v1 + vcl_v2;
442
443 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
444 return EXIT_FAILURE;
445
446 std::cout << "Testing inplace-add on vector..." << std::endl;
447 for (size_t i=0; i<std_v1.size(); ++i)
448 std_v1[i] += std_v2[i];
449 vcl_v1 += vcl_v2;
450
451 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
452 return EXIT_FAILURE;
453
454
455 //
456 // multiply-add
457 //
458 std::cout << "Testing multiply-add on vector with CPU scalar (right)..." << std::endl;
459 for (size_t i=0; i < std_v1.size(); ++i)
460 std_v1[i] = NumericT(i);
461 for (std::size_t i=0; i<std_v1.size(); ++i)
462 std_v2[i] = 3 * std_v1[i];
463 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
464 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
465
466 for (std::size_t i=0; i<std_v1.size(); ++i)
467 std_v1[i] = std_v1[i] + alpha * std_v2[i];
468 vcl_v1 = vcl_v1 + alpha * vcl_v2;
469
470 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
471 return EXIT_FAILURE;
472
473 std::cout << "Testing multiply-add on vector with CPU scalar (left)..." << std::endl;
474 for (std::size_t i=0; i<std_v1.size(); ++i)
475 std_v2[i] = 3 * std_v1[i];
476 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
477 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
478
479 for (std::size_t i=0; i<std_v1.size(); ++i)
480 std_v1[i] = alpha * std_v1[i] + std_v2[i];
481 vcl_v1 = alpha * vcl_v1 + vcl_v2;
482
483 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
484 return EXIT_FAILURE;
485
486 std::cout << "Testing multiply-add on vector with CPU scalar (both)..." << std::endl;
487 for (std::size_t i=0; i<std_v1.size(); ++i)
488 std_v2[i] = 3 * std_v1[i];
489 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
490 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
491
492 for (std::size_t i=0; i<std_v1.size(); ++i)
493 std_v1[i] = alpha * std_v1[i] + beta * std_v2[i];
494 vcl_v1 = alpha * vcl_v1 + beta * vcl_v2;
495
496 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
497 return EXIT_FAILURE;
498
499
500 std::cout << "Testing inplace multiply-add on vector with CPU scalar..." << std::endl;
501 for (std::size_t i=0; i<std_v1.size(); ++i)
502 std_v2[i] = 3 * std_v1[i];
503 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
504 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
505
506 for (std::size_t i=0; i<std_v1.size(); ++i)
507 std_v1[i] += alpha * std_v2[i];
508 vcl_v1 += alpha * vcl_v2;
509
510 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
511 return EXIT_FAILURE;
512
513
514 std::cout << "Testing multiply-add on vector with GPU scalar (right)..." << std::endl;
515 for (std::size_t i=0; i<std_v1.size(); ++i)
516 std_v2[i] = 3 * std_v1[i];
517 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
518 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
519
520 for (std::size_t i=0; i<std_v1.size(); ++i)
521 std_v1[i] = std_v1[i] + alpha * std_v2[i];
522 vcl_v1 = vcl_v1 + gpu_alpha * vcl_v2;
523
524 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
525 return EXIT_FAILURE;
526
527 std::cout << "Testing multiply-add on vector with GPU scalar (left)..." << std::endl;
528 for (std::size_t i=0; i<std_v1.size(); ++i)
529 std_v2[i] = 3 * std_v1[i];
530 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
531 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
532
533 for (std::size_t i=0; i<std_v1.size(); ++i)
534 std_v1[i] = std_v1[i] + alpha * std_v2[i];
535 vcl_v1 = vcl_v1 + gpu_alpha * vcl_v2;
536
537 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
538 return EXIT_FAILURE;
539
540 std::cout << "Testing multiply-add on vector with GPU scalar (both)..." << std::endl;
541 for (std::size_t i=0; i<std_v1.size(); ++i)
542 std_v2[i] = 3 * std_v1[i];
543 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
544 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
545
546 for (std::size_t i=0; i<std_v1.size(); ++i)
547 std_v1[i] = alpha * std_v1[i] + beta * std_v2[i];
548 vcl_v1 = gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
549
550 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
551 return EXIT_FAILURE;
552
553
554 std::cout << "Testing inplace multiply-add on vector with GPU scalar (both, adding)..." << std::endl;
555 for (std::size_t i=0; i<std_v1.size(); ++i)
556 std_v2[i] = 3 * std_v1[i];
557 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
558 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
559
560 for (std::size_t i=0; i<std_v1.size(); ++i)
561 std_v1[i] += alpha * std_v1[i] + beta * std_v2[i];
562 vcl_v1 += gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
563
564 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
565 return EXIT_FAILURE;
566
567
568 std::cout << "Testing inplace multiply-add on vector with GPU scalar..." << std::endl;
569 for (std::size_t i=0; i<std_v1.size(); ++i)
570 std_v2[i] = 3 * std_v1[i];
571 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
572 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
573
574 for (std::size_t i=0; i<std_v1.size(); ++i)
575 std_v1[i] += alpha * std_v2[i];
576 vcl_v1 += gpu_alpha * vcl_v2;
577
578 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
579 return EXIT_FAILURE;
580
581
582 //
583 // division-add
584 //
585 std::cout << "Testing division-add on vector with CPU scalar (right)..." << std::endl;
586 for (size_t i=0; i < std_v1.size(); ++i)
587 std_v1[i] = NumericT(i);
588 for (std::size_t i=0; i<std_v1.size(); ++i)
589 std_v2[i] = 3 * std_v1[i];
590 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
591 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
592
593 for (std::size_t i=0; i<std_v1.size(); ++i)
594 std_v1[i] = std_v1[i] + std_v2[i] / alpha;
595 vcl_v1 = vcl_v1 + vcl_v2 / alpha;
596
597 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
598 return EXIT_FAILURE;
599
600
601 std::cout << "Testing division-add on vector with CPU scalar (left)..." << std::endl;
602 for (std::size_t i=0; i<std_v1.size(); ++i)
603 std_v2[i] = 3 * std_v1[i];
604 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
605 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
606
607 for (std::size_t i=0; i<std_v1.size(); ++i)
608 std_v1[i] = std_v1[i] / alpha + std_v2[i];
609 vcl_v1 = vcl_v1 / alpha + vcl_v2;
610
611 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
612 return EXIT_FAILURE;
613
614 std::cout << "Testing division-add on vector with CPU scalar (both)..." << std::endl;
615 for (std::size_t i=0; i<std_v1.size(); ++i)
616 std_v2[i] = 3 * std_v1[i];
617 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
618 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
619
620 for (std::size_t i=0; i<std_v1.size(); ++i)
621 std_v1[i] = std_v1[i] / alpha + std_v2[i] / beta;
622 vcl_v1 = vcl_v1 / alpha + vcl_v2 / beta;
623
624 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
625 return EXIT_FAILURE;
626
627 std::cout << "Testing division-multiply-add on vector with CPU scalar..." << std::endl;
628 for (std::size_t i=0; i<std_v1.size(); ++i)
629 std_v2[i] = 3 * std_v1[i];
630 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
631 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
632
633 for (std::size_t i=0; i<std_v1.size(); ++i)
634 std_v1[i] = std_v1[i] / alpha + std_v2[i] * beta;
635 vcl_v1 = vcl_v1 / alpha + vcl_v2 * beta;
636
637 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
638 return EXIT_FAILURE;
639
640
641 std::cout << "Testing multiply-division-add on vector with CPU scalar..." << std::endl;
642 for (std::size_t i=0; i<std_v1.size(); ++i)
643 std_v2[i] = 3 * std_v1[i];
644 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
645 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
646
647 for (std::size_t i=0; i<std_v1.size(); ++i)
648 std_v1[i] = std_v1[i] * alpha + std_v2[i] / beta;
649 vcl_v1 = vcl_v1 * alpha + vcl_v2 / beta;
650
651 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
652 return EXIT_FAILURE;
653
654
655
656 std::cout << "Testing inplace division-add on vector with CPU scalar..." << std::endl;
657 for (std::size_t i=0; i<std_v1.size(); ++i)
658 std_v2[i] = 3 * std_v1[i];
659 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
660 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
661
662 for (std::size_t i=0; i<std_v1.size(); ++i)
663 std_v1[i] += std_v2[i] / alpha;
664 vcl_v1 += vcl_v2 / alpha;
665
666 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
667 return EXIT_FAILURE;
668
669
670 std::cout << "Testing division-add on vector with GPU scalar (right)..." << std::endl;
671 for (std::size_t i=0; i<std_v1.size(); ++i)
672 std_v2[i] = 3 * std_v1[i];
673 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
674 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
675
676 for (std::size_t i=0; i<std_v1.size(); ++i)
677 std_v1[i] = std_v1[i] + std_v2[i] / alpha;
678 vcl_v1 = vcl_v1 + vcl_v2 / gpu_alpha;
679
680 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
681 return EXIT_FAILURE;
682
683 std::cout << "Testing division-add on vector with GPU scalar (left)..." << std::endl;
684 for (std::size_t i=0; i<std_v1.size(); ++i)
685 std_v2[i] = 3 * std_v1[i];
686 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
687 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
688
689 for (std::size_t i=0; i<std_v1.size(); ++i)
690 std_v1[i] = std_v1[i] + std_v2[i] / alpha;
691 vcl_v1 = vcl_v1 + vcl_v2 / gpu_alpha;
692
693 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
694 return EXIT_FAILURE;
695
696 std::cout << "Testing division-add on vector with GPU scalar (both)..." << std::endl;
697 for (std::size_t i=0; i<std_v1.size(); ++i)
698 std_v2[i] = 3 * std_v1[i];
699 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
700 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
701
702 for (std::size_t i=0; i<std_v1.size(); ++i)
703 std_v1[i] = std_v1[i] / alpha + std_v2[i] / beta;
704 vcl_v1 = vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
705
706 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
707 return EXIT_FAILURE;
708
709
710 std::cout << "Testing inplace division-add on vector with GPU scalar (both, adding)..." << std::endl;
711 for (std::size_t i=0; i<std_v1.size(); ++i)
712 std_v2[i] = 3 * std_v1[i];
713 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
714 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
715
716 for (std::size_t i=0; i<std_v1.size(); ++i)
717 std_v1[i] += std_v1[i] / alpha + std_v2[i] / beta;
718 vcl_v1 += vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
719
720 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
721 return EXIT_FAILURE;
722
723 std::cout << "Testing inplace division-multiply-add on vector with GPU scalar (adding)..." << std::endl;
724 for (std::size_t i=0; i<std_v1.size(); ++i)
725 std_v2[i] = 3 * std_v1[i];
726 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
727 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
728
729 for (std::size_t i=0; i<std_v1.size(); ++i)
730 std_v1[i] += std_v1[i] / alpha + std_v2[i] * beta;
731 vcl_v1 += vcl_v1 / gpu_alpha + vcl_v2 * gpu_beta;
732
733 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
734 return EXIT_FAILURE;
735
736
737 std::cout << "Testing inplace division-add on vector with GPU scalar..." << std::endl;
738 for (std::size_t i=0; i<std_v1.size(); ++i)
739 std_v2[i] = 3 * std_v1[i];
740 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
741 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
742
743 for (std::size_t i=0; i<std_v1.size(); ++i)
744 std_v1[i] += std_v2[i] * alpha;
745 vcl_v1 += vcl_v2 * gpu_alpha;
746
747 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
748 return EXIT_FAILURE;
749
750 //
751 // More complicated expressions (for ensuring the operator overloads work correctly)
752 //
753 for (size_t i=0; i < std_v1.size(); ++i)
754 std_v1[i] = NumericT(i);
755 for (std::size_t i=0; i<std_v1.size(); ++i)
756 std_v2[i] = 3 * std_v1[i];
757 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
758 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
759
760 std::cout << "Testing three vector additions..." << std::endl;
761 for (std::size_t i=0; i<std_v1.size(); ++i)
762 std_v1[i] = std_v2[i] + std_v1[i] + std_v2[i];
763 vcl_v1 = vcl_v2 + vcl_v1 + vcl_v2;
764
765 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
766 return EXIT_FAILURE;
767
768 // --------------------------------------------------------------------------
769 for (std::size_t i=0; i<std_v1.size(); ++i)
770 std_v2[i] = 3 * std_v1[i];
771 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
772 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
773
774 std::cout << "Testing swap..." << std::endl;
775 swap(std_v1, std_v2);
776 swap(vcl_v1, vcl_v2);
777
778 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
779 return EXIT_FAILURE;
780
781 std::cout << "Testing elementwise multiplication..." << std::endl;
782 std::cout << " v1 = element_prod(v1, v2);" << std::endl;
783 for (std::size_t i=0; i<std_v1.size(); ++i)
784 std_v1[i] = std_v1[i] * std_v2[i];
785 vcl_v1 = viennacl::linalg::element_prod(vcl_v1, vcl_v2);
786
787 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
788 return EXIT_FAILURE;
789
790 std::cout << " v1 += element_prod(v1, v2);" << std::endl;
791 for (std::size_t i=0; i<std_v1.size(); ++i)
792 std_v1[i] += std_v1[i] * std_v2[i];
793 vcl_v1 += viennacl::linalg::element_prod(vcl_v1, vcl_v2);
794
795 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
796 return EXIT_FAILURE;
797
799 std::cout << " v1 = element_prod(v1 + v2, v2);" << std::endl;
800 for (std::size_t i=0; i<std_v1.size(); ++i)
801 std_v1[i] = (std_v1[i] + std_v2[i]) * std_v2[i];
802 vcl_v1 = viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2);
803
804 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
805 return EXIT_FAILURE;
806
807 std::cout << " v1 += element_prod(v1 + v2, v2);" << std::endl;
808 for (std::size_t i=0; i<std_v1.size(); ++i)
809 std_v1[i] += (std_v1[i] + std_v2[i]) * std_v2[i];
810 vcl_v1 += viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2);
811
812 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
813 return EXIT_FAILURE;
814
816 std::cout << " v1 = element_prod(v1, v2 + v1);" << std::endl;
817 for (std::size_t i=0; i<std_v1.size(); ++i)
818 std_v1[i] = std_v1[i] * (std_v2[i] + std_v1[i]);
819 vcl_v1 = viennacl::linalg::element_prod(vcl_v1, vcl_v2 + vcl_v1);
820
821 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
822 return EXIT_FAILURE;
823
824 std::cout << " v1 += element_prod(v1, v2 + v1);" << std::endl;
825 for (std::size_t i=0; i<std_v1.size(); ++i)
826 std_v1[i] += std_v1[i] * (std_v2[i] + std_v1[i]);
827 vcl_v1 += viennacl::linalg::element_prod(vcl_v1, vcl_v2 + vcl_v1);
828
829 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
830 return EXIT_FAILURE;
831
833 std::cout << " v1 = element_prod(v1 + v2, v2 + v1);" << std::endl;
834 for (std::size_t i=0; i<std_v1.size(); ++i)
835 std_v1[i] = (std_v1[i] + std_v2[i]) * (std_v2[i] + std_v1[i]);
836 vcl_v1 = viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
837
838 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
839 return EXIT_FAILURE;
840
841 std::cout << " v1 += element_prod(v1 + v2, v2 + v1);" << std::endl;
842 for (std::size_t i=0; i<std_v1.size(); ++i)
843 std_v1[i] += (std_v1[i] + std_v2[i]) * (std_v2[i] + std_v1[i]);
844 vcl_v1 += viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
845
846 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
847 return EXIT_FAILURE;
848
849
850 std::cout << "Testing elementwise division..." << std::endl;
851 for (std::size_t i=0; i<std_v1.size(); ++i)
852 {
853 std_v1[i] = NumericT(1 + i);
854 std_v2[i] = NumericT(5 + i);
855 }
856
857 viennacl::copy(std_v1.begin(), std_v1.end(), vcl_v1.begin());
858 viennacl::copy(std_v2.begin(), std_v2.end(), vcl_v2.begin());
859
860 for (std::size_t i=0; i<std_v1.size(); ++i)
861 std_v1[i] = std_v1[i] / std_v2[i];
862 vcl_v1 = viennacl::linalg::element_div(vcl_v1, vcl_v2);
863
864 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
865 return EXIT_FAILURE;
866
867 for (std::size_t i=0; i<std_v1.size(); ++i)
868 std_v1[i] += std_v1[i] / std_v2[i];
869 vcl_v1 += viennacl::linalg::element_div(vcl_v1, vcl_v2);
870
871 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
872 return EXIT_FAILURE;
873
875 for (std::size_t i=0; i<std_v1.size(); ++i)
876 std_v1[i] = (std_v1[i] + std_v2[i]) / std_v2[i];
877 vcl_v1 = viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2);
878
879 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
880 return EXIT_FAILURE;
881
882 for (std::size_t i=0; i<std_v1.size(); ++i)
883 std_v1[i] += (std_v1[i] + std_v2[i]) / std_v2[i];
884 vcl_v1 += viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2);
885
886 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
887 return EXIT_FAILURE;
888
890 for (std::size_t i=0; i<std_v1.size(); ++i)
891 std_v1[i] = std_v1[i] / (std_v2[i] + std_v1[i]);
892 vcl_v1 = viennacl::linalg::element_div(vcl_v1, vcl_v2 + vcl_v1);
893
894 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
895 return EXIT_FAILURE;
896
897 for (std::size_t i=0; i<std_v1.size(); ++i)
898 std_v1[i] += std_v1[i] / (std_v2[i] + std_v1[i]);
899 vcl_v1 += viennacl::linalg::element_div(vcl_v1, vcl_v2 + vcl_v1);
900
901 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
902 return EXIT_FAILURE;
903
905 for (std::size_t i=0; i<std_v1.size(); ++i)
906 std_v1[i] = (std_v1[i] + std_v2[i]) / (std_v2[i] + std_v1[i]);
907 vcl_v1 = viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
908
909 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
910 return EXIT_FAILURE;
911
912 for (std::size_t i=0; i<std_v1.size(); ++i)
913 std_v1[i] += (std_v1[i] + std_v2[i]) / (std_v2[i] + std_v1[i]);
914 vcl_v1 += viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
915
916 if (check(std_v1, vcl_v1) != EXIT_SUCCESS)
917 return EXIT_FAILURE;
918
919 // --------------------------------------------------------------------------
920 return retval;
921 }
922
923
924 template< typename NumericT >
925 int test()
926 {
927 int retval = EXIT_SUCCESS;
928 std::size_t size = 12345;
929
930 std::cout << "Running tests for vector of size " << size << std::endl;
931
932 //
933 // Set up STL objects
934 //
935 std::vector<NumericT> std_full_vec(size);
936 std::vector<NumericT> std_full_vec2(std_full_vec.size());
937
938 for (std::size_t i=0; i<std_full_vec.size(); ++i)
939 {
940 std_full_vec[i] = NumericT(1.0) + NumericT(i);
941 std_full_vec2[i] = NumericT(2.0) + NumericT(i) / NumericT(2);
942 }
943
944 std::vector<NumericT> std_range_vec (2 * std_full_vec.size() / 4 - std_full_vec.size() / 4);
945 std::vector<NumericT> std_range_vec2(2 * std_full_vec.size() / 4 - std_full_vec.size() / 4);
946
947 for (std::size_t i=0; i<std_range_vec.size(); ++i)
948 std_range_vec[i] = std_full_vec[i + std_full_vec.size() / 4];
949 for (std::size_t i=0; i<std_range_vec2.size(); ++i)
950 std_range_vec2[i] = std_full_vec2[i + 2 * std_full_vec2.size() / 4];
951
952 std::vector<NumericT> std_slice_vec (std_full_vec.size() / 4);
953 std::vector<NumericT> std_slice_vec2(std_full_vec.size() / 4);
954
955 for (std::size_t i=0; i<std_slice_vec.size(); ++i)
956 std_slice_vec[i] = std_full_vec[3*i + std_full_vec.size() / 4];
957 for (std::size_t i=0; i<std_slice_vec2.size(); ++i)
958 std_slice_vec2[i] = std_full_vec2[2*i + 2 * std_full_vec2.size() / 4];
959
960 //
961 // Set up ViennaCL objects
962 //
963 viennacl::vector<NumericT> vcl_full_vec(std_full_vec.size());
964 viennacl::vector<NumericT> vcl_full_vec2(std_full_vec2.size());
965
966 viennacl::fast_copy(std_full_vec.begin(), std_full_vec.end(), vcl_full_vec.begin());
967 viennacl::copy(std_full_vec2.begin(), std_full_vec2.end(), vcl_full_vec2.begin());
968
969 viennacl::range vcl_r1( vcl_full_vec.size() / 4, 2 * vcl_full_vec.size() / 4);
970 viennacl::range vcl_r2(2 * vcl_full_vec2.size() / 4, 3 * vcl_full_vec2.size() / 4);
971 viennacl::vector_range< viennacl::vector<NumericT> > vcl_range_vec(vcl_full_vec, vcl_r1);
972 viennacl::vector_range< viennacl::vector<NumericT> > vcl_range_vec2(vcl_full_vec2, vcl_r2);
973
974 {
975 viennacl::vector<NumericT> vcl_short_vec(vcl_range_vec);
976 viennacl::vector<NumericT> vcl_short_vec2 = vcl_range_vec2;
977
978 std::vector<NumericT> std_short_vec(std_range_vec);
979 std::vector<NumericT> std_short_vec2(std_range_vec2);
980
981 std::cout << "Testing creation of vectors from range..." << std::endl;
982 if (check(std_short_vec, vcl_short_vec) != EXIT_SUCCESS)
983 return EXIT_FAILURE;
984 if (check(std_short_vec2, vcl_short_vec2) != EXIT_SUCCESS)
985 return EXIT_FAILURE;
986 }
987
988 viennacl::slice vcl_s1( vcl_full_vec.size() / 4, 3, vcl_full_vec.size() / 4);
989 viennacl::slice vcl_s2(2 * vcl_full_vec2.size() / 4, 2, vcl_full_vec2.size() / 4);
990 viennacl::vector_slice< viennacl::vector<NumericT> > vcl_slice_vec(vcl_full_vec, vcl_s1);
991 viennacl::vector_slice< viennacl::vector<NumericT> > vcl_slice_vec2(vcl_full_vec2, vcl_s2);
992
993 viennacl::vector<NumericT> vcl_short_vec(vcl_slice_vec);
994 viennacl::vector<NumericT> vcl_short_vec2 = vcl_slice_vec2;
995
996 std::vector<NumericT> std_short_vec(std_slice_vec);
997 std::vector<NumericT> std_short_vec2(std_slice_vec2);
998
999 std::cout << "Testing creation of vectors from slice..." << std::endl;
1000 if (check(std_short_vec, vcl_short_vec) != EXIT_SUCCESS)
1001 return EXIT_FAILURE;
1002 if (check(std_short_vec2, vcl_short_vec2) != EXIT_SUCCESS)
1003 return EXIT_FAILURE;
1004
1005
1006 //
1007 // Now start running tests for vectors, ranges and slices:
1008 //
1009
1010 std::cout << " ** vcl_v1 = vector, vcl_v2 = vector **" << std::endl;
1011 retval = test<NumericT>(std_short_vec, std_short_vec2,
1012 vcl_short_vec, vcl_short_vec2);
1013 if (retval != EXIT_SUCCESS)
1014 return EXIT_FAILURE;
1015
1016 std::cout << " ** vcl_v1 = vector, vcl_v2 = range **" << std::endl;
1017 retval = test<NumericT>(std_short_vec, std_short_vec2,
1018 vcl_short_vec, vcl_range_vec2);
1019 if (retval != EXIT_SUCCESS)
1020 return EXIT_FAILURE;
1021
1022 std::cout << " ** vcl_v1 = vector, vcl_v2 = slice **" << std::endl;
1023 retval = test<NumericT>(std_short_vec, std_short_vec2,
1024 vcl_short_vec, vcl_slice_vec2);
1025 if (retval != EXIT_SUCCESS)
1026 return EXIT_FAILURE;
1027
1029
1030 std::cout << " ** vcl_v1 = range, vcl_v2 = vector **" << std::endl;
1031 retval = test<NumericT>(std_short_vec, std_short_vec2,
1032 vcl_range_vec, vcl_short_vec2);
1033 if (retval != EXIT_SUCCESS)
1034 return EXIT_FAILURE;
1035
1036 std::cout << " ** vcl_v1 = range, vcl_v2 = range **" << std::endl;
1037 retval = test<NumericT>(std_short_vec, std_short_vec2,
1038 vcl_range_vec, vcl_range_vec2);
1039 if (retval != EXIT_SUCCESS)
1040 return EXIT_FAILURE;
1041
1042 std::cout << " ** vcl_v1 = range, vcl_v2 = slice **" << std::endl;
1043 retval = test<NumericT>(std_short_vec, std_short_vec2,
1044 vcl_range_vec, vcl_slice_vec2);
1045 if (retval != EXIT_SUCCESS)
1046 return EXIT_FAILURE;
1047
1049
1050 std::cout << " ** vcl_v1 = slice, vcl_v2 = vector **" << std::endl;
1051 retval = test<NumericT>(std_short_vec, std_short_vec2,
1052 vcl_slice_vec, vcl_short_vec2);
1053 if (retval != EXIT_SUCCESS)
1054 return EXIT_FAILURE;
1055
1056 std::cout << " ** vcl_v1 = slice, vcl_v2 = range **" << std::endl;
1057 retval = test<NumericT>(std_short_vec, std_short_vec2,
1058 vcl_slice_vec, vcl_range_vec2);
1059 if (retval != EXIT_SUCCESS)
1060 return EXIT_FAILURE;
1061
1062 std::cout << " ** vcl_v1 = slice, vcl_v2 = slice **" << std::endl;
1063 retval = test<NumericT>(std_short_vec, std_short_vec2,
1064 vcl_slice_vec, vcl_slice_vec2);
1065 if (retval != EXIT_SUCCESS)
1066 return EXIT_FAILURE;
1067
1068 return EXIT_SUCCESS;
1069 }
1070
1071
1072
1073 //
1074 // -------------------------------------------------------------
1075 //
1076 int main()
1077 {
1078 std::cout << std::endl;
1079 std::cout << "----------------------------------------------" << std::endl;
1080 std::cout << "----------------------------------------------" << std::endl;
1081 std::cout << "## Test :: Vector with Integer types" << std::endl;
1082 std::cout << "----------------------------------------------" << std::endl;
1083 std::cout << "----------------------------------------------" << std::endl;
1084 std::cout << std::endl;
1085
1086 int retval = EXIT_SUCCESS;
1087
1088 std::cout << std::endl;
1089 std::cout << "----------------------------------------------" << std::endl;
1090 std::cout << std::endl;
1091 {
1092 std::cout << "# Testing setup:" << std::endl;
1093 std::cout << " numeric: unsigned int" << std::endl;
1094 retval = test<unsigned int>();
1095 if ( retval == EXIT_SUCCESS )
1096 std::cout << "# Test passed" << std::endl;
1097 else
1098 return retval;
1099 }
1100 std::cout << std::endl;
1101 std::cout << "----------------------------------------------" << std::endl;
1102 std::cout << std::endl;
1103 {
1104 std::cout << "# Testing setup:" << std::endl;
1105 std::cout << " numeric: long" << std::endl;
1106 retval = test<unsigned long>();
1107 if ( retval == EXIT_SUCCESS )
1108 std::cout << "# Test passed" << std::endl;
1109 else
1110 return retval;
1111 }
1112 std::cout << std::endl;
1113 std::cout << "----------------------------------------------" << std::endl;
1114 std::cout << std::endl;
1115
1116 std::cout << std::endl;
1117 std::cout << "------- Test completed --------" << std::endl;
1118 std::cout << std::endl;
1119
1120 return retval;
1121 }
viennacl::linalg::element_div
viennacl::vector_expression< const vector_base< T >, const vector_base< T >, op_element_binary< op_div > > element_div(vector_base< T > const &v1, vector_base< T > const &v2)
viennacl::linalg::index_norm_inf
vcl_size_t index_norm_inf(vector_base< T > const &vec)
Computes the index of the first entry that is equal to the supremum-norm in modulus.
Definition: vector_operations.hpp:845
viennacl::scalar
This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type...
Definition: forwards.h:227
norm_2.hpp
Generic interface for the l^2-norm. See viennacl/linalg/vector_operations.hpp for implementations...
viennacl::linalg::sum
viennacl::scalar_expression< const viennacl::vector_base< NumericT >, const viennacl::vector_base< NumericT >, viennacl::op_sum > sum(viennacl::vector_base< NumericT > const &x)
User interface function for computing the sum of all elements of a vector.
Definition: sum.hpp:45
check
int check(T1 const &t1, T2 const &t2)
Definition: vector_uint.cpp:92
viennacl::backend::finish
void finish()
Synchronizes the execution. finish() will only return after all compute kernels (CUDA, OpenCL) have completed.
Definition: memory.hpp:54
viennacl::zero_vector
Definition: vector_def.hpp:93
viennacl::linalg::inner_prod
viennacl::enable_if< viennacl::is_stl< typename viennacl::traits::tag_of< VectorT1 >::type >::value, typename VectorT1::value_type >::type inner_prod(VectorT1 const &v1, VectorT2 const &v2)
Definition: inner_prod.hpp:100
s2
viennacl::scalar< int > s2
Definition: global_variables.cpp:58
s1
viennacl::scalar< float > s1
Definition: global_variables.cpp:57
inner_prod.hpp
Generic interface for the computation of inner products. See viennacl/linalg/vector_operations.hpp for implementations.
test
int test(STLVectorType &std_v1, STLVectorType &std_v2, ViennaCLVectorType1 &vcl_v1, ViennaCLVectorType2 &vcl_v2)
Definition: vector_uint.cpp:109
norm_1.hpp
Generic interface for the l^1-norm. See viennacl/linalg/vector_operations.hpp for implementations...
NumericT
float NumericT
Definition: bisect.cpp:40
v1
viennacl::vector< float > v1
Definition: global_variables.cpp:60
maxmin.hpp
viennacl::traits::size
vcl_size_t size(VectorType const &vec)
Generic routine for obtaining the size of a vector (ViennaCL, uBLAS, etc.)
Definition: size.hpp:239
viennacl::vector_range
Class for representing non-strided subvectors of a bigger vector x.
Definition: forwards.h:434
viennacl::vector_slice
Class for representing strided subvectors of a bigger vector x.
Definition: forwards.h:437
viennacl::vector< NumericT >
vector_proxy.hpp
Proxy classes for vectors.
viennacl::linalg::cuda::swap
viennacl::enable_if< viennacl::is_scalar< ScalarT1 >::value &&viennacl::is_scalar< ScalarT2 >::value >::type swap(ScalarT1 &s1, ScalarT2 &s2)
Swaps the contents of two scalars, data is copied.
Definition: scalar_operations.hpp:361
main
int main()
Definition: vector_uint.cpp:1076
diff
ScalarType diff(ScalarType const &s1, ScalarType const &s2)
Definition: vector_uint.cpp:48
viennacl::unit_vector
Represents a vector consisting of 1 at a given index and zeros otherwise.
Definition: vector_def.hpp:76
sum.hpp
Stub routines for the summation of elements in a vector, or all elements in either a row or column of...
v2
viennacl::vector< int > v2
Definition: global_variables.cpp:61
vector.hpp
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
viennacl::scalar_vector
Represents a vector consisting of scalars 's' only, i.e. v[i] = s for all i. To be used as an initial...
Definition: vector_def.hpp:87
viennacl::linalg::max
NumericT max(std::vector< NumericT > const &v1)
Definition: maxmin.hpp:47
viennacl::linalg::norm_inf
T norm_inf(std::vector< T, A > const &v1)
Definition: norm_inf.hpp:60
viennacl::copy
void copy(std::vector< NumericT > &cpu_vec, circulant_matrix< NumericT, AlignmentV > &gpu_mat)
Copies a circulant matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU) ...
Definition: circulant_matrix.hpp:150
viennacl::linalg::norm_1
T norm_1(std::vector< T, A > const &v1)
Definition: norm_1.hpp:61
viennacl::basic_range
A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
Definition: forwards.h:424
ScalarType
float ScalarType
Definition: fft_1d.cpp:42
viennacl::linalg::element_prod
viennacl::vector_expression< const vector_base< T >, const vector_base< T >, op_element_binary< op_prod > > element_prod(vector_base< T > const &v1, vector_base< T > const &v2)
viennacl::basic_slice
A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
Definition: forwards.h:429
viennacl::entry_proxy
A proxy class for a single element of a vector or matrix. This proxy should not be noticed by end-use...
Definition: forwards.h:233
norm_inf.hpp
Generic interface for the l^infty-norm. See viennacl/linalg/vector_operations.hpp for implementations...
viennacl::linalg::min
NumericT min(std::vector< NumericT > const &v1)
Definition: maxmin.hpp:91
viennacl::fast_copy
void fast_copy(const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_begin, const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_end, CPU_ITERATOR cpu_begin)