ViennaCL - The Vienna Computing Library  1.6.1
Free open-source GPU-accelerated linear algebra and solver library.
vector_int.cpp
Go to the documentation of this file.
1 /* =========================================================================
2  Copyright (c) 2010-2014, 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 
23 //
24 // *** System
25 //
26 #include <iostream>
27 #include <iomanip>
28 
29 //
30 // *** Boost
31 //
32 #include <boost/numeric/ublas/io.hpp>
33 #include <boost/numeric/ublas/vector.hpp>
34 #include <boost/numeric/ublas/vector_proxy.hpp>
35 
36 //
37 // *** ViennaCL
38 //
39 //#define VIENNACL_DEBUG_ALL
40 #define VIENNACL_WITH_UBLAS 1
41 #include "viennacl/vector.hpp"
48 
49 #include "Random.hpp"
50 
51 using namespace boost::numeric;
52 
53 
54 //
55 // -------------------------------------------------------------
56 //
57 template<typename ScalarType>
59 {
61  return s1 - s2;
62 }
63 //
64 // -------------------------------------------------------------
65 //
66 template<typename ScalarType>
68 {
70  return s1 - s2;
71 }
72 //
73 // -------------------------------------------------------------
74 //
75 template<typename ScalarType>
77 {
79  return s1 - s2;
80 }
81 //
82 // -------------------------------------------------------------
83 //
84 template<typename ScalarType, typename VCLVectorType>
85 ScalarType diff(ublas::vector<ScalarType> const & v1, VCLVectorType const & v2)
86 {
87  ublas::vector<ScalarType> v2_cpu(v2.size());
88  viennacl::backend::finish(); //workaround for a bug in APP SDK 2.7 on Trinity APUs (with Catalyst 12.8)
89  viennacl::copy(v2.begin(), v2.end(), v2_cpu.begin());
90 
91  for (unsigned int i=0;i<v1.size(); ++i)
92  {
93  if (v2_cpu[i] != v1[i])
94  return 1;
95  }
96 
97  return 0;
98 }
99 
100 template<typename T1, typename T2>
101 int check(T1 const & t1, T2 const & t2)
102 {
103  int retval = EXIT_SUCCESS;
104 
105  if (diff(t1, t2) != 0)
106  {
107  std::cout << "# Error! Difference: " << std::abs(diff(t1, t2)) << std::endl;
108  retval = EXIT_FAILURE;
109  }
110  return retval;
111 }
112 
113 
114 //
115 // -------------------------------------------------------------
116 //
117 template< typename NumericT, typename UblasVectorType, typename ViennaCLVectorType1, typename ViennaCLVectorType2 >
118 int test(UblasVectorType & ublas_v1, UblasVectorType & ublas_v2,
119  ViennaCLVectorType1 & vcl_v1, ViennaCLVectorType2 & vcl_v2)
120 {
121  int retval = EXIT_SUCCESS;
122 
123  NumericT cpu_result = 42;
124  viennacl::scalar<NumericT> gpu_result = 43;
125 
126  //
127  // Initializer:
128  //
129  std::cout << "Checking for zero_vector initializer..." << std::endl;
130  //ublas_v1 = ublas::zero_vector<NumericT>(ublas_v1.size());
131  for (std::size_t i=0; i<ublas_v1.size(); ++i)
132  ublas_v1[i] = 0;
133  vcl_v1 = viennacl::zero_vector<NumericT>(vcl_v1.size());
134  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
135  return EXIT_FAILURE;
136 
137  std::cout << "Checking for scalar_vector initializer..." << std::endl;
138  //ublas_v1 = ublas::scalar_vector<NumericT>(ublas_v1.size(), cpu_result);
139  for (std::size_t i=0; i<ublas_v1.size(); ++i)
140  ublas_v1[i] = cpu_result;
141  vcl_v1 = viennacl::scalar_vector<NumericT>(vcl_v1.size(), cpu_result);
142  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
143  return EXIT_FAILURE;
144 
145  //ublas_v1 = ublas::scalar_vector<NumericT>(ublas_v1.size(), gpu_result);
146  for (std::size_t i=0; i<ublas_v1.size(); ++i)
147  ublas_v1[i] = cpu_result + 1;
148  vcl_v1 = viennacl::scalar_vector<NumericT>(vcl_v1.size(), gpu_result);
149  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
150  return EXIT_FAILURE;
151 
152  std::cout << "Checking for unit_vector initializer..." << std::endl;
153  //ublas_v1 = ublas::unit_vector<NumericT>(ublas_v1.size(), 5);
154  for (std::size_t i=0; i<ublas_v1.size(); ++i)
155  ublas_v1[i] = (i == 5) ? 1 : 0;
156  vcl_v1 = viennacl::unit_vector<NumericT>(vcl_v1.size(), 5);
157  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
158  return EXIT_FAILURE;
159 
160  for (std::size_t i=0; i<ublas_v1.size(); ++i)
161  {
162  ublas_v1[i] = NumericT(i);
163  ublas_v2[i] = NumericT(i+42);
164  }
165 
166  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin()); //resync
167  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
168 
169  std::cout << "Checking for successful copy..." << std::endl;
170  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
171  return EXIT_FAILURE;
172  if (check(ublas_v2, vcl_v2) != EXIT_SUCCESS)
173  return EXIT_FAILURE;
174 
175  //
176  // Part 1: Norms and inner product
177  //
178 
179  // --------------------------------------------------------------------------
180  std::cout << "Testing inner_prod..." << std::endl;
181  cpu_result = viennacl::linalg::inner_prod(ublas_v1, ublas_v2);
182  NumericT cpu_result2 = viennacl::linalg::inner_prod(vcl_v1, vcl_v2);
183  gpu_result = viennacl::linalg::inner_prod(vcl_v1, vcl_v2);
184 
185  if (check(cpu_result, cpu_result2) != EXIT_SUCCESS)
186  return EXIT_FAILURE;
187  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
188  return EXIT_FAILURE;
189 
190  cpu_result = inner_prod(ublas_v1 + ublas_v2, ublas_v2 - ublas_v1);
191  NumericT cpu_result3 = viennacl::linalg::inner_prod(vcl_v1 + vcl_v2, vcl_v2 - vcl_v1);
192  gpu_result = viennacl::linalg::inner_prod(vcl_v1 + vcl_v2, vcl_v2 - vcl_v1);
193 
194  if (check(cpu_result, cpu_result3) != EXIT_SUCCESS)
195  return EXIT_FAILURE;
196  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
197  return EXIT_FAILURE;
198 
199  // --------------------------------------------------------------------------
200  std::cout << "Testing norm_1..." << std::endl;
201  cpu_result = ublas::norm_1(ublas_v1);
202  gpu_result = viennacl::linalg::norm_1(vcl_v1);
203 
204  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
205  return EXIT_FAILURE;
206 
207  gpu_result = 2 * cpu_result; //reset
208  gpu_result = ublas::norm_1(ublas_v1);
209  cpu_result = viennacl::linalg::norm_1(vcl_v1);
210 
211  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
212  return EXIT_FAILURE;
213 
214  gpu_result = ublas::norm_1(ublas_v1 + ublas_v2);
215  cpu_result = viennacl::linalg::norm_1(vcl_v1 + vcl_v2);
216 
217  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
218  return EXIT_FAILURE;
219 
220  // --------------------------------------------------------------------------
221  std::cout << "Testing norm_inf..." << std::endl;
222  cpu_result = ublas::norm_inf(ublas_v1);
223  gpu_result = viennacl::linalg::norm_inf(vcl_v1);
224 
225  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
226  return EXIT_FAILURE;
227 
228  gpu_result = 2 * cpu_result; //reset
229  gpu_result = ublas::norm_inf(ublas_v1);
230  cpu_result = viennacl::linalg::norm_inf(vcl_v1);
231 
232  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
233  return EXIT_FAILURE;
234 
235  gpu_result = ublas::norm_inf(ublas_v1 + ublas_v2);
236  cpu_result = viennacl::linalg::norm_inf(vcl_v1 + vcl_v2);
237 
238  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
239  return EXIT_FAILURE;
240 
241  // --------------------------------------------------------------------------
242  std::cout << "Testing index_norm_inf..." << std::endl;
243  std::size_t cpu_index = ublas::index_norm_inf(ublas_v1);
244  std::size_t gpu_index = viennacl::linalg::index_norm_inf(vcl_v1);
245 
246  if (check(static_cast<NumericT>(cpu_index), static_cast<NumericT>(gpu_index)) != EXIT_SUCCESS)
247  return EXIT_FAILURE;
248  // --------------------------------------------------------------------------
249  cpu_result = ublas_v1[index_norm_inf(ublas_v1)];
250  gpu_result = vcl_v1[viennacl::linalg::index_norm_inf(vcl_v1)];
251 
252  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
253  return EXIT_FAILURE;
254 
255  cpu_result = ublas_v1[index_norm_inf(ublas_v1 + ublas_v2)];
256  gpu_result = vcl_v1[viennacl::linalg::index_norm_inf(vcl_v1 + vcl_v2)];
257 
258  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
259  return EXIT_FAILURE;
260 
261  // --------------------------------------------------------------------------
262  std::cout << "Testing max..." << std::endl;
263  cpu_result = ublas_v1[0];
264  for (std::size_t i=0; i<ublas_v1.size(); ++i)
265  cpu_result = std::max<NumericT>(cpu_result, ublas_v1[i]);
266  gpu_result = viennacl::linalg::max(vcl_v1);
267 
268  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
269  return EXIT_FAILURE;
270 
271  cpu_result = ublas_v1[0];
272  for (std::size_t i=0; i<ublas_v1.size(); ++i)
273  cpu_result = std::max<NumericT>(cpu_result, ublas_v1[i]);
274  gpu_result = cpu_result;
275  cpu_result *= 2; //reset
276  cpu_result = viennacl::linalg::max(vcl_v1);
277 
278  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
279  return EXIT_FAILURE;
280 
281  cpu_result = ublas_v1[0] + ublas_v2[0];
282  for (std::size_t i=0; i<ublas_v1.size(); ++i)
283  cpu_result = std::max<NumericT>(cpu_result, ublas_v1[i] + ublas_v2[i]);
284  gpu_result = cpu_result;
285  cpu_result *= 2; //reset
286  cpu_result = viennacl::linalg::max(vcl_v1 + vcl_v2);
287 
288  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
289  return EXIT_FAILURE;
290 
291 
292  // --------------------------------------------------------------------------
293  std::cout << "Testing min..." << std::endl;
294  cpu_result = ublas_v1[0];
295  for (std::size_t i=0; i<ublas_v1.size(); ++i)
296  cpu_result = std::min<NumericT>(cpu_result, ublas_v1[i]);
297  gpu_result = viennacl::linalg::min(vcl_v1);
298 
299  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
300  return EXIT_FAILURE;
301 
302  cpu_result = ublas_v1[0];
303  for (std::size_t i=0; i<ublas_v1.size(); ++i)
304  cpu_result = std::min<NumericT>(cpu_result, ublas_v1[i]);
305  gpu_result = cpu_result;
306  cpu_result *= 2; //reset
307  cpu_result = viennacl::linalg::min(vcl_v1);
308 
309  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
310  return EXIT_FAILURE;
311 
312  cpu_result = ublas_v1[0] + ublas_v2[0];
313  for (std::size_t i=0; i<ublas_v1.size(); ++i)
314  cpu_result = std::min<NumericT>(cpu_result, ublas_v1[i] + ublas_v2[i]);
315  gpu_result = cpu_result;
316  cpu_result *= 2; //reset
317  cpu_result = viennacl::linalg::min(vcl_v1 + vcl_v2);
318 
319  if (check(cpu_result, gpu_result) != EXIT_SUCCESS)
320  return EXIT_FAILURE;
321 
322 
323 
324  //
325  // Plane rotation and assignments
326  //
327 
328  // --------------------------------------------------------------------------
329 
330  ublas::vector<NumericT> x = ublas_v1;
331  ublas::vector<NumericT> y = ublas_v2;
332  ublas::vector<NumericT> t = ublas_v1;
333  t.assign ( NumericT(1) * x + NumericT(2) * y),
334  y.assign (- NumericT(2) * x + NumericT(1) * y),
335  x.assign (t);
336 
337  viennacl::linalg::plane_rotation(vcl_v1, vcl_v2, NumericT(1), NumericT(2));
338 
339  if (check(x, vcl_v1) != EXIT_SUCCESS)
340  return EXIT_FAILURE;
341  if (check(y, vcl_v2) != EXIT_SUCCESS)
342  return EXIT_FAILURE;
343 
344  // --------------------------------------------------------------------------
345 
346  std::cout << "Testing assignments..." << std::endl;
347  NumericT val = static_cast<NumericT>(1);
348  for (size_t i=0; i < ublas_v1.size(); ++i)
349  ublas_v1(i) = val;
350 
351  for (size_t i=0; i < vcl_v1.size(); ++i)
352  vcl_v1(i) = val;
353 
354  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
355  return EXIT_FAILURE;
356 
357 
358  //
359  // multiplication and division of vectors by scalars
360  //
361  std::cout << "Testing scaling with CPU scalar..." << std::endl;
362  NumericT alpha = static_cast<NumericT>(3);
363  viennacl::scalar<NumericT> gpu_alpha = alpha;
364 
365  ublas_v1 *= alpha;
366  vcl_v1 *= alpha;
367 
368  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
369  return EXIT_FAILURE;
370 
371  std::cout << "Testing scaling with GPU scalar..." << std::endl;
372  ublas_v1 *= alpha;
373  vcl_v1 *= gpu_alpha;
374 
375  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
376  return EXIT_FAILURE;
377 
378  NumericT beta = static_cast<NumericT>(2);
379  viennacl::scalar<NumericT> gpu_beta = beta;
380 
381  std::cout << "Testing shrinking with CPU scalar..." << std::endl;
382  ublas_v1 /= beta;
383  vcl_v1 /= beta;
384 
385  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
386  return EXIT_FAILURE;
387 
388  std::cout << "Testing shrinking with GPU scalar..." << std::endl;
389  ublas_v1 /= beta;
390  vcl_v1 /= gpu_beta;
391 
392  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
393  return EXIT_FAILURE;
394 
395 
396  //
397  // add and inplace_add of vectors
398  //
399  for (size_t i=0; i < ublas_v1.size(); ++i)
400  ublas_v1(i) = NumericT(i);
401  ublas_v2 = 3 * ublas_v1;
402  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin()); //resync
403  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
404 
405  std::cout << "Testing add on vector..." << std::endl;
406 
407  std::cout << "Checking for successful copy..." << std::endl;
408  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
409  return EXIT_FAILURE;
410  if (check(ublas_v2, vcl_v2) != EXIT_SUCCESS)
411  return EXIT_FAILURE;
412 
413  ublas_v1 = ublas_v1 + ublas_v2;
414  vcl_v1 = vcl_v1 + vcl_v2;
415 
416  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
417  return EXIT_FAILURE;
418 
419  std::cout << "Testing add on vector with flipsign..." << std::endl;
420  ublas_v1 = - ublas_v1 + ublas_v2;
421  vcl_v1 = - vcl_v1 + vcl_v2;
422 
423  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
424  return EXIT_FAILURE;
425 
426  std::cout << "Testing inplace-add on vector..." << std::endl;
427  ublas_v1 += ublas_v2;
428  vcl_v1 += vcl_v2;
429 
430  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
431  return EXIT_FAILURE;
432 
433  //
434  // subtract and inplace_subtract of vectors
435  //
436  std::cout << "Testing sub on vector..." << std::endl;
437  ublas_v2 = 3 * ublas_v1;
438  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
439  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
440 
441  ublas_v1 = ublas_v1 - ublas_v2;
442  vcl_v1 = vcl_v1 - vcl_v2;
443 
444  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
445  return EXIT_FAILURE;
446 
447  std::cout << "Testing inplace-sub on vector..." << std::endl;
448  ublas_v1 -= ublas_v2;
449  vcl_v1 -= vcl_v2;
450 
451  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
452  return EXIT_FAILURE;
453 
454 
455 
456  //
457  // multiply-add
458  //
459  std::cout << "Testing multiply-add on vector with CPU scalar (right)..." << std::endl;
460  for (size_t i=0; i < ublas_v1.size(); ++i)
461  ublas_v1(i) = NumericT(i);
462  ublas_v2 = 3 * ublas_v1;
463  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
464  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
465 
466  ublas_v1 = ublas_v1 + alpha * ublas_v2;
467  vcl_v1 = vcl_v1 + alpha * vcl_v2;
468 
469  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
470  return EXIT_FAILURE;
471 
472  std::cout << "Testing multiply-add on vector with CPU scalar (left)..." << std::endl;
473  ublas_v2 = 3 * ublas_v1;
474  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
475  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
476 
477  ublas_v1 = alpha * ublas_v1 + ublas_v2;
478  vcl_v1 = alpha * vcl_v1 + vcl_v2;
479 
480  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
481  return EXIT_FAILURE;
482 
483  std::cout << "Testing multiply-add on vector with CPU scalar (both)..." << std::endl;
484  ublas_v2 = 3 * ublas_v1;
485  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
486  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
487 
488  ublas_v1 = alpha * ublas_v1 + beta * ublas_v2;
489  vcl_v1 = alpha * vcl_v1 + beta * vcl_v2;
490 
491  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
492  return EXIT_FAILURE;
493 
494 
495  std::cout << "Testing inplace multiply-add on vector with CPU scalar..." << std::endl;
496  ublas_v2 = 3 * ublas_v1;
497  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
498  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
499 
500  ublas_v1 += alpha * ublas_v2;
501  vcl_v1 += alpha * vcl_v2;
502 
503  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
504  return EXIT_FAILURE;
505 
506 
507  std::cout << "Testing multiply-add on vector with GPU scalar (right)..." << std::endl;
508  ublas_v2 = 3 * ublas_v1;
509  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
510  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
511 
512  ublas_v1 = ublas_v1 + alpha * ublas_v2;
513  vcl_v1 = vcl_v1 + gpu_alpha * vcl_v2;
514 
515  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
516  return EXIT_FAILURE;
517 
518  std::cout << "Testing multiply-add on vector with GPU scalar (left)..." << std::endl;
519  ublas_v2 = 3 * ublas_v1;
520  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
521  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
522 
523  ublas_v1 = ublas_v1 + alpha * ublas_v2;
524  vcl_v1 = vcl_v1 + gpu_alpha * vcl_v2;
525 
526  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
527  return EXIT_FAILURE;
528 
529  std::cout << "Testing multiply-add on vector with GPU scalar (both)..." << std::endl;
530  ublas_v2 = 3 * ublas_v1;
531  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
532  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
533 
534  ublas_v1 = alpha * ublas_v1 + beta * ublas_v2;
535  vcl_v1 = gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
536 
537  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
538  return EXIT_FAILURE;
539 
540 
541  std::cout << "Testing inplace multiply-add on vector with GPU scalar (both, adding)..." << std::endl;
542  ublas_v2 = 3 * ublas_v1;
543  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
544  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
545 
546  ublas_v1 += alpha * ublas_v1 + beta * ublas_v2;
547  vcl_v1 += gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
548 
549  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
550  return EXIT_FAILURE;
551 
552  std::cout << "Testing inplace multiply-add on vector with GPU scalar (both, subtracting)..." << std::endl;
553  ublas_v2 = 3 * ublas_v1;
554  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
555  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
556 
557  ublas_v1 += alpha * ublas_v1 - beta * ublas_v2;
558  vcl_v1 += gpu_alpha * vcl_v1 - gpu_beta * vcl_v2;
559 
560  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
561  return EXIT_FAILURE;
562 
563 
564 
565  std::cout << "Testing inplace multiply-add on vector with GPU scalar..." << std::endl;
566  ublas_v2 = 3 * ublas_v1;
567  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
568  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
569 
570  ublas_v1 += alpha * ublas_v2;
571  vcl_v1 += gpu_alpha * vcl_v2;
572 
573  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
574  return EXIT_FAILURE;
575 
576 
577  //
578  // division-add
579  //
580  std::cout << "Testing division-add on vector with CPU scalar (right)..." << std::endl;
581  for (size_t i=0; i < ublas_v1.size(); ++i)
582  ublas_v1(i) = NumericT(i);
583  ublas_v2 = 3 * ublas_v1;
584  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
585  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
586 
587  ublas_v1 = ublas_v1 + ublas_v2 / alpha;
588  vcl_v1 = vcl_v1 + vcl_v2 / alpha;
589 
590  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
591  return EXIT_FAILURE;
592 
593 
594  std::cout << "Testing division-add on vector with CPU scalar (left)..." << std::endl;
595  ublas_v2 = 3 * ublas_v1;
596  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
597  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
598 
599  ublas_v1 = ublas_v1 / alpha + ublas_v2;
600  vcl_v1 = vcl_v1 / alpha + vcl_v2;
601 
602  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
603  return EXIT_FAILURE;
604 
605  std::cout << "Testing division-add on vector with CPU scalar (both)..." << std::endl;
606  ublas_v2 = 3 * ublas_v1;
607  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
608  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
609 
610  ublas_v1 = ublas_v1 / alpha + ublas_v2 / beta;
611  vcl_v1 = vcl_v1 / alpha + vcl_v2 / beta;
612 
613  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
614  return EXIT_FAILURE;
615 
616  std::cout << "Testing division-multiply-add on vector with CPU scalar..." << std::endl;
617  ublas_v2 = 3 * ublas_v1;
618  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
619  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
620 
621  ublas_v1 = ublas_v1 / alpha + ublas_v2 * beta;
622  vcl_v1 = vcl_v1 / alpha + vcl_v2 * beta;
623 
624  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
625  return EXIT_FAILURE;
626 
627 
628  std::cout << "Testing multiply-division-add on vector with CPU scalar..." << std::endl;
629  ublas_v2 = 3 * ublas_v1;
630  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
631  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
632 
633  ublas_v1 = ublas_v1 * alpha + ublas_v2 / beta;
634  vcl_v1 = vcl_v1 * alpha + vcl_v2 / beta;
635 
636  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
637  return EXIT_FAILURE;
638 
639 
640 
641  std::cout << "Testing inplace division-add on vector with CPU scalar..." << std::endl;
642  ublas_v2 = 3 * ublas_v1;
643  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
644  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
645 
646  ublas_v1 += ublas_v2 / alpha;
647  vcl_v1 += vcl_v2 / alpha;
648 
649  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
650  return EXIT_FAILURE;
651 
652 
653  std::cout << "Testing division-add on vector with GPU scalar (right)..." << std::endl;
654  ublas_v2 = 3 * ublas_v1;
655  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
656  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
657 
658  ublas_v1 = ublas_v1 + ublas_v2 / alpha;
659  vcl_v1 = vcl_v1 + vcl_v2 / gpu_alpha;
660 
661  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
662  return EXIT_FAILURE;
663 
664  std::cout << "Testing division-add on vector with GPU scalar (left)..." << std::endl;
665  ublas_v2 = 3 * ublas_v1;
666  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
667  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
668 
669  ublas_v1 = ublas_v1 + ublas_v2 / alpha;
670  vcl_v1 = vcl_v1 + vcl_v2 / gpu_alpha;
671 
672  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
673  return EXIT_FAILURE;
674 
675  std::cout << "Testing division-add on vector with GPU scalar (both)..." << std::endl;
676  ublas_v2 = 3 * ublas_v1;
677  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
678  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
679 
680  ublas_v1 = ublas_v1 / alpha + ublas_v2 / beta;
681  vcl_v1 = vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
682 
683  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
684  return EXIT_FAILURE;
685 
686 
687  std::cout << "Testing inplace division-add on vector with GPU scalar (both, adding)..." << std::endl;
688  ublas_v2 = 3 * ublas_v1;
689  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
690  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
691 
692  ublas_v1 += ublas_v1 / alpha + ublas_v2 / beta;
693  vcl_v1 += vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
694 
695  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
696  return EXIT_FAILURE;
697 
698  std::cout << "Testing inplace division-add on vector with GPU scalar (both, subtracting)..." << std::endl;
699  ublas_v2 = 3 * ublas_v1;
700  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
701  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
702 
703  ublas_v1 += ublas_v1 / alpha - ublas_v2 / beta;
704  vcl_v1 += vcl_v1 / gpu_alpha - vcl_v2 / gpu_beta;
705 
706  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
707  return EXIT_FAILURE;
708 
709  std::cout << "Testing inplace division-multiply-add on vector with GPU scalar (adding)..." << std::endl;
710  ublas_v2 = 3 * ublas_v1;
711  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
712  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
713 
714  ublas_v1 += ublas_v1 / alpha + ublas_v2 * beta;
715  vcl_v1 += vcl_v1 / gpu_alpha + vcl_v2 * gpu_beta;
716 
717  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
718  return EXIT_FAILURE;
719 
720  std::cout << "Testing inplace multiply-division-add on vector with GPU scalar (subtracting)..." << std::endl;
721  ublas_v2 = 3 * ublas_v1;
722  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
723  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
724 
725  ublas_v1 += ublas_v1 * alpha - ublas_v2 / beta;
726  vcl_v1 += vcl_v1 * gpu_alpha - vcl_v2 / gpu_beta;
727 
728  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
729  return EXIT_FAILURE;
730 
731 
732 
733  std::cout << "Testing inplace division-add on vector with GPU scalar..." << std::endl;
734  ublas_v2 = 3 * ublas_v1;
735  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
736  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
737 
738  ublas_v1 += ublas_v2 * alpha;
739  vcl_v1 += vcl_v2 * gpu_alpha;
740 
741  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
742  return EXIT_FAILURE;
743 
744  //
745  // multiply-subtract
746  //
747  std::cout << "Testing multiply-subtract on vector with CPU scalar (right)..." << std::endl;
748  for (size_t i=0; i < ublas_v1.size(); ++i)
749  ublas_v1(i) = NumericT(i);
750  ublas_v2 = 3 * ublas_v1;
751  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
752  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
753 
754  ublas_v1 = ublas_v1 - alpha * ublas_v2;
755  vcl_v1 = vcl_v1 - alpha * vcl_v2;
756 
757  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
758  return EXIT_FAILURE;
759 
760 
761  std::cout << "Testing multiply-subtract on vector with CPU scalar (left)..." << std::endl;
762  ublas_v2 = 3 * ublas_v1;
763  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
764  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
765 
766  ublas_v1 = alpha * ublas_v1 - ublas_v2;
767  vcl_v1 = alpha * vcl_v1 - vcl_v2;
768 
769  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
770  return EXIT_FAILURE;
771 
772  std::cout << "Testing multiply-subtract on vector with CPU scalar (both)..." << std::endl;
773  ublas_v2 = 3 * ublas_v1;
774  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
775  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
776 
777  ublas_v1 = alpha * ublas_v1 - beta * ublas_v2;
778  vcl_v1 = alpha * vcl_v1 - beta * vcl_v2;
779 
780  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
781  return EXIT_FAILURE;
782 
783 
784  std::cout << "Testing inplace multiply-subtract on vector with CPU scalar..." << std::endl;
785  ublas_v2 = 3 * ublas_v1;
786  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
787  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
788 
789  ublas_v1 -= alpha * ublas_v2;
790  vcl_v1 -= alpha * vcl_v2;
791 
792  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
793  return EXIT_FAILURE;
794 
795 
796  std::cout << "Testing multiply-subtract on vector with GPU scalar (right)..." << std::endl;
797  ublas_v2 = 3 * ublas_v1;
798  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
799  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
800 
801  ublas_v1 = ublas_v1 - alpha * ublas_v2;
802  vcl_v1 = vcl_v1 - gpu_alpha * vcl_v2;
803 
804  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
805  return EXIT_FAILURE;
806 
807  std::cout << "Testing multiply-subtract on vector with GPU scalar (left)..." << std::endl;
808  ublas_v2 = 3 * ublas_v1;
809  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
810  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
811 
812  ublas_v1 = ublas_v1 - alpha * ublas_v2;
813  vcl_v1 = vcl_v1 - gpu_alpha * vcl_v2;
814 
815  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
816  return EXIT_FAILURE;
817 
818  std::cout << "Testing multiply-subtract on vector with GPU scalar (both)..." << std::endl;
819  ublas_v2 = 3 * ublas_v1;
820  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
821  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
822 
823  ublas_v1 = alpha * ublas_v1 - beta * ublas_v2;
824  vcl_v1 = gpu_alpha * vcl_v1 - gpu_beta * vcl_v2;
825 
826  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
827  return EXIT_FAILURE;
828 
829  std::cout << "Testing inplace multiply-subtract on vector with GPU scalar (both, adding)..." << std::endl;
830  ublas_v2 = 3 * ublas_v1;
831  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
832  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
833 
834  ublas_v1 -= alpha * ublas_v1 + beta * ublas_v2;
835  vcl_v1 -= gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
836 
837  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
838  return EXIT_FAILURE;
839 
840  std::cout << "Testing inplace multiply-subtract on vector with GPU scalar (both, subtracting)..." << std::endl;
841  ublas_v2 = 3 * ublas_v1;
842  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
843  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
844 
845  ublas_v1 -= alpha * ublas_v1 - beta * ublas_v2;
846  vcl_v1 -= gpu_alpha * vcl_v1 - gpu_beta * vcl_v2;
847 
848  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
849  return EXIT_FAILURE;
850 
851 
852  std::cout << "Testing inplace multiply-subtract on vector with GPU scalar..." << std::endl;
853  ublas_v2 = 3 * ublas_v1;
854  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
855  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
856 
857  ublas_v1 -= alpha * ublas_v2;
858  vcl_v1 -= gpu_alpha * vcl_v2;
859 
860  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
861  return EXIT_FAILURE;
862 
863 
864 
865  //
866  // division-subtract
867  //
868  std::cout << "Testing division-subtract on vector with CPU scalar (right)..." << std::endl;
869  for (size_t i=0; i < ublas_v1.size(); ++i)
870  ublas_v1(i) = NumericT(i);
871  ublas_v2 = 3 * ublas_v1;
872  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
873  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
874 
875  ublas_v1 = ublas_v1 - ublas_v2 / alpha;
876  vcl_v1 = vcl_v1 - vcl_v2 / alpha;
877 
878  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
879  return EXIT_FAILURE;
880 
881 
882  std::cout << "Testing division-subtract on vector with CPU scalar (left)..." << std::endl;
883  ublas_v2 = 3 * ublas_v1;
884  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
885  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
886 
887  ublas_v1 = ublas_v1 / alpha - ublas_v2;
888  vcl_v1 = vcl_v1 / alpha - vcl_v2;
889 
890  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
891  return EXIT_FAILURE;
892 
893  std::cout << "Testing division-subtract on vector with CPU scalar (both)..." << std::endl;
894  ublas_v2 = 3 * ublas_v1;
895  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
896  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
897 
898  ublas_v1 = ublas_v1 / alpha - ublas_v2 / alpha;
899  vcl_v1 = vcl_v1 / alpha - vcl_v2 / alpha;
900 
901  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
902  return EXIT_FAILURE;
903 
904 
905  std::cout << "Testing inplace division-subtract on vector with CPU scalar..." << std::endl;
906  ublas_v2 = 3 * ublas_v1;
907  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
908  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
909 
910  ublas_v1 -= ublas_v2 / alpha;
911  vcl_v1 -= vcl_v2 / alpha;
912 
913  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
914  return EXIT_FAILURE;
915 
916  std::cout << "Testing inplace division-subtract on vector with GPU scalar..." << std::endl;
917  ublas_v2 = 3 * ublas_v1;
918  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
919  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
920 
921  ublas_v1 -= ublas_v2 / alpha;
922  vcl_v1 -= vcl_v2 / gpu_alpha;
923 
924  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
925  return EXIT_FAILURE;
926 
927 
928  std::cout << "Testing division-subtract on vector with GPU scalar (right)..." << std::endl;
929  ublas_v2 = 3 * ublas_v1;
930  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
931  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
932 
933  ublas_v1 = ublas_v1 - ublas_v2 / alpha;
934  vcl_v1 = vcl_v1 - vcl_v2 / gpu_alpha;
935 
936  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
937  return EXIT_FAILURE;
938 
939  std::cout << "Testing division-subtract on vector with GPU scalar (left)..." << std::endl;
940  ublas_v2 = 3 * ublas_v1;
941  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
942  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
943 
944  ublas_v1 = ublas_v1 - ublas_v2 / alpha;
945  vcl_v1 = vcl_v1 - vcl_v2 / gpu_alpha;
946 
947  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
948  return EXIT_FAILURE;
949 
950  std::cout << "Testing division-subtract on vector with GPU scalar (both)..." << std::endl;
951  ublas_v2 = 3 * ublas_v1;
952  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
953  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
954 
955  ublas_v1 = ublas_v1 / alpha - ublas_v2 / beta;
956  vcl_v1 = vcl_v1 / gpu_alpha - vcl_v2 / gpu_beta;
957 
958  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
959  return EXIT_FAILURE;
960 
961  std::cout << "Testing inplace division-subtract on vector with GPU scalar (both, adding)..." << std::endl;
962  ublas_v2 = 3 * ublas_v1;
963  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
964  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
965 
966  ublas_v1 -= ublas_v1 / alpha + ublas_v2 / beta;
967  vcl_v1 -= vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
968 
969  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
970  return EXIT_FAILURE;
971 
972  std::cout << "Testing inplace division-subtract on vector with GPU scalar (both, subtracting)..." << std::endl;
973  ublas_v2 = 3 * ublas_v1;
974  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
975  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
976 
977  ublas_v1 -= ublas_v1 / alpha - ublas_v2 / beta;
978  vcl_v1 -= vcl_v1 / gpu_alpha - vcl_v2 / gpu_beta;
979 
980  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
981  return EXIT_FAILURE;
982 
983  std::cout << "Testing multiply-division-subtract on vector with GPU scalar..." << std::endl;
984  ublas_v2 = 3 * ublas_v1;
985  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
986  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
987 
988  ublas_v1 = ublas_v1 * alpha - ublas_v2 / beta;
989  vcl_v1 = vcl_v1 * gpu_alpha - vcl_v2 / gpu_beta;
990 
991  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
992  return EXIT_FAILURE;
993 
994  std::cout << "Testing division-multiply-subtract on vector with GPU scalar..." << std::endl;
995  ublas_v2 = 3 * ublas_v1;
996  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
997  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
998 
999  ublas_v1 = ublas_v1 / alpha - ublas_v2 * beta;
1000  vcl_v1 = vcl_v1 / gpu_alpha - vcl_v2 * gpu_beta;
1001 
1002  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1003  return EXIT_FAILURE;
1004 
1005  std::cout << "Testing inplace multiply-division-subtract on vector with GPU scalar (adding)..." << std::endl;
1006  ublas_v2 = 3 * ublas_v1;
1007  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1008  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1009 
1010  ublas_v1 -= ublas_v1 * alpha + ublas_v2 / beta;
1011  vcl_v1 -= vcl_v1 * gpu_alpha + vcl_v2 / gpu_beta;
1012 
1013  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1014  return EXIT_FAILURE;
1015 
1016  std::cout << "Testing inplace division-multiply-subtract on vector with GPU scalar (adding)..." << std::endl;
1017  ublas_v2 = 3 * ublas_v1;
1018  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1019  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1020 
1021  ublas_v1 -= ublas_v1 / alpha + ublas_v2 * beta;
1022  vcl_v1 -= vcl_v1 / gpu_alpha + vcl_v2 * gpu_beta;
1023 
1024  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1025  return EXIT_FAILURE;
1026 
1027  std::cout << "Testing inplace multiply-division-subtract on vector with GPU scalar (subtracting)..." << std::endl;
1028  ublas_v2 = 3 * ublas_v1;
1029  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1030  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1031 
1032  ublas_v1 -= ublas_v1 * alpha - ublas_v2 / beta;
1033  vcl_v1 -= vcl_v1 * gpu_alpha - vcl_v2 / gpu_beta;
1034 
1035  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1036  return EXIT_FAILURE;
1037 
1038  std::cout << "Testing inplace division-multiply-subtract on vector with GPU scalar (subtracting)..." << std::endl;
1039  ublas_v2 = 3 * ublas_v1;
1040  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1041  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1042 
1043  ublas_v1 -= ublas_v1 / alpha - ublas_v2 * beta;
1044  vcl_v1 -= vcl_v1 / gpu_alpha - vcl_v2 * gpu_beta;
1045 
1046  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1047  return EXIT_FAILURE;
1048 
1049 
1050  std::cout << "Testing inplace division-subtract on vector with GPU scalar..." << std::endl;
1051  ublas_v2 = 3 * ublas_v1;
1052  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1053  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1054 
1055  ublas_v1 -= alpha * ublas_v2;
1056  vcl_v1 -= gpu_alpha * vcl_v2;
1057 
1058  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1059  return EXIT_FAILURE;
1060 
1061 
1062 
1063  //
1064  // More complicated expressions (for ensuring the operator overloads work correctly)
1065  //
1066  for (size_t i=0; i < ublas_v1.size(); ++i)
1067  ublas_v1(i) = NumericT(i);
1068  ublas_v2 = 3 * ublas_v1;
1069  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1070  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1071 
1072  std::cout << "Testing three vector additions..." << std::endl;
1073  ublas_v1 = ublas_v2 + ublas_v1 + ublas_v2;
1074  vcl_v1 = vcl_v2 + vcl_v1 + vcl_v2;
1075 
1076  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1077  return EXIT_FAILURE;
1078 
1079 
1080  ublas_v2 = 3 * ublas_v1;
1081  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1082  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1083 
1084  std::cout << "Testing complicated vector expression with CPU scalar..." << std::endl;
1085  ublas_v1 = beta * (ublas_v1 - alpha * ublas_v2);
1086  vcl_v1 = beta * (vcl_v1 - alpha * vcl_v2);
1087 
1088  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1089  return EXIT_FAILURE;
1090 
1091  std::cout << "Testing complicated vector expression with GPU scalar..." << std::endl;
1092  ublas_v1 = beta * (ublas_v1 - alpha * ublas_v2);
1093  vcl_v1 = gpu_beta * (vcl_v1 - gpu_alpha * vcl_v2);
1094 
1095  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1096  return EXIT_FAILURE;
1097 
1098  // --------------------------------------------------------------------------
1099  ublas_v2 = 3 * ublas_v1;
1100  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1101  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1102 
1103  std::cout << "Testing swap..." << std::endl;
1104  swap(ublas_v1, ublas_v2);
1105  swap(vcl_v1, vcl_v2);
1106 
1107  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1108  return EXIT_FAILURE;
1109 
1110  // --------------------------------------------------------------------------
1111  for (std::size_t i=0; i<ublas_v1.size(); ++i)
1112  {
1113  ublas_v1[i] = NumericT(1.0) + NumericT(i);
1114  ublas_v2[i] = NumericT(5.0) + NumericT(i);
1115  }
1116 
1117  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1118  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1119 
1120  std::cout << "Testing unary operator-..." << std::endl;
1121  ublas_v1 = - ublas_v2;
1122  vcl_v1 = - vcl_v2;
1123 
1124  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1125  return EXIT_FAILURE;
1126 
1127 
1128  std::cout << "Testing elementwise multiplication..." << std::endl;
1129  std::cout << " v1 = element_prod(v1, v2);" << std::endl;
1130  ublas_v1 = ublas::element_prod(ublas_v1, ublas_v2);
1131  vcl_v1 = viennacl::linalg::element_prod(vcl_v1, vcl_v2);
1132 
1133  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1134  return EXIT_FAILURE;
1135 
1136  std::cout << " v1 += element_prod(v1, v2);" << std::endl;
1137  ublas_v1 += ublas::element_prod(ublas_v1, ublas_v2);
1138  vcl_v1 += viennacl::linalg::element_prod(vcl_v1, vcl_v2);
1139 
1140  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1141  return EXIT_FAILURE;
1142 
1143  std::cout << " v1 -= element_prod(v1, v2);" << std::endl;
1144  ublas_v1 -= ublas::element_prod(ublas_v1, ublas_v2);
1145  vcl_v1 -= viennacl::linalg::element_prod(vcl_v1, vcl_v2);
1146 
1147  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1148  return EXIT_FAILURE;
1149 
1151  std::cout << " v1 = element_prod(v1 + v2, v2);" << std::endl;
1152  ublas_v1 = ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2);
1153  vcl_v1 = viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2);
1154 
1155  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1156  return EXIT_FAILURE;
1157 
1158  std::cout << " v1 += element_prod(v1 + v2, v2);" << std::endl;
1159  ublas_v1 += ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2);
1160  vcl_v1 += viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2);
1161 
1162  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1163  return EXIT_FAILURE;
1164 
1165  std::cout << " v1 -= element_prod(v1 + v2, v2);" << std::endl;
1166  ublas_v1 -= ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2);
1167  vcl_v1 -= viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2);
1168 
1169  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1170  return EXIT_FAILURE;
1171 
1173  std::cout << " v1 = element_prod(v1, v2 + v1);" << std::endl;
1174  ublas_v1 = ublas::element_prod(ublas_v1, ublas_v2 + ublas_v1);
1175  vcl_v1 = viennacl::linalg::element_prod(vcl_v1, vcl_v2 + vcl_v1);
1176 
1177  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1178  return EXIT_FAILURE;
1179 
1180  std::cout << " v1 += element_prod(v1, v2 + v1);" << std::endl;
1181  ublas_v1 += ublas::element_prod(ublas_v1, ublas_v2 + ublas_v1);
1182  vcl_v1 += viennacl::linalg::element_prod(vcl_v1, vcl_v2 + vcl_v1);
1183 
1184  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1185  return EXIT_FAILURE;
1186 
1187  std::cout << " v1 -= element_prod(v1, v2 + v1);" << std::endl;
1188  ublas_v1 -= ublas::element_prod(ublas_v1, ublas_v2 + ublas_v1);
1189  vcl_v1 -= viennacl::linalg::element_prod(vcl_v1, vcl_v2 + vcl_v1);
1190 
1191  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1192  return EXIT_FAILURE;
1193 
1195  std::cout << " v1 = element_prod(v1 + v2, v2 + v1);" << std::endl;
1196  ublas_v1 = ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1197  vcl_v1 = viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1198 
1199  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1200  return EXIT_FAILURE;
1201 
1202  std::cout << " v1 += element_prod(v1 + v2, v2 + v1);" << std::endl;
1203  ublas_v1 += ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1204  vcl_v1 += viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1205 
1206  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1207  return EXIT_FAILURE;
1208 
1209  std::cout << " v1 -= element_prod(v1 + v2, v2 + v1);" << std::endl;
1210  ublas_v1 -= ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1211  vcl_v1 -= viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1212 
1213  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1214  return EXIT_FAILURE;
1215 
1216 
1217  std::cout << "Testing elementwise division..." << std::endl;
1218  for (std::size_t i=0; i<ublas_v1.size(); ++i)
1219  {
1220  ublas_v1[i] = NumericT(1 + i);
1221  ublas_v2[i] = NumericT(5 + i);
1222  }
1223 
1224  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1225  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1226 
1227  ublas_v1 = ublas::element_div(ublas_v1, ublas_v2);
1228  vcl_v1 = viennacl::linalg::element_div(vcl_v1, vcl_v2);
1229 
1230  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1231  return EXIT_FAILURE;
1232 
1233  ublas_v1 += ublas::element_div(ublas_v1, ublas_v2);
1234  vcl_v1 += viennacl::linalg::element_div(vcl_v1, vcl_v2);
1235 
1236  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1237  return EXIT_FAILURE;
1238 
1239  ublas_v1 -= ublas::element_div(ublas_v1, ublas_v2);
1240  vcl_v1 -= viennacl::linalg::element_div(vcl_v1, vcl_v2);
1241 
1242  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1243  return EXIT_FAILURE;
1244 
1246  ublas_v1 = ublas::element_div(ublas_v1 + ublas_v2, ublas_v2);
1247  vcl_v1 = viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2);
1248 
1249  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1250  return EXIT_FAILURE;
1251 
1252  ublas_v1 += ublas::element_div(ublas_v1 + ublas_v2, ublas_v2);
1253  vcl_v1 += viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2);
1254 
1255  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1256  return EXIT_FAILURE;
1257 
1258  ublas_v1 -= ublas::element_div(ublas_v1 + ublas_v2, ublas_v2);
1259  vcl_v1 -= viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2);
1260 
1261  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1262  return EXIT_FAILURE;
1263 
1265  ublas_v1 = ublas::element_div(ublas_v1, ublas_v2 + ublas_v1);
1266  vcl_v1 = viennacl::linalg::element_div(vcl_v1, vcl_v2 + vcl_v1);
1267 
1268  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1269  return EXIT_FAILURE;
1270 
1271  ublas_v1 += ublas::element_div(ublas_v1, ublas_v2 + ublas_v1);
1272  vcl_v1 += viennacl::linalg::element_div(vcl_v1, vcl_v2 + vcl_v1);
1273 
1274  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1275  return EXIT_FAILURE;
1276 
1277  ublas_v1 -= ublas::element_div(ublas_v1, ublas_v2 + ublas_v1);
1278  vcl_v1 -= viennacl::linalg::element_div(vcl_v1, vcl_v2 + vcl_v1);
1279 
1280  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1281  return EXIT_FAILURE;
1282 
1284  ublas_v1 = ublas::element_div(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1285  vcl_v1 = viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1286 
1287  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1288  return EXIT_FAILURE;
1289 
1290  ublas_v1 += ublas::element_div(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1291  vcl_v1 += viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1292 
1293  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1294  return EXIT_FAILURE;
1295 
1296  ublas_v1 -= ublas::element_div(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1297  vcl_v1 -= viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1298 
1299  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1300  return EXIT_FAILURE;
1301 
1302  std::cout << "Testing unary elementwise operations..." << std::endl;
1303 
1304 #define GENERATE_UNARY_OP_TEST(FUNCNAME) \
1305  ublas_v2 = 3 * ublas_v1; \
1306  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin()); \
1307  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin()); \
1308  \
1309  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1310  ublas_v1[i] = std::FUNCNAME(ublas_v2[i]); \
1311  vcl_v1 = viennacl::linalg::element_##FUNCNAME(vcl_v2); \
1312  \
1313  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS) \
1314  { \
1315  std::cout << "Failure at v1 = " << #FUNCNAME << "(v2)" << std::endl; \
1316  return EXIT_FAILURE; \
1317  } \
1318  \
1319  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1320  ublas_v1[i] = std::FUNCNAME(ublas_v1[i] + ublas_v2[i]); \
1321  vcl_v1 = viennacl::linalg::element_##FUNCNAME(vcl_v1 + vcl_v2); \
1322  \
1323  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS) \
1324  { \
1325  std::cout << "Failure at v1 = " << #FUNCNAME << "(v1 + v2)" << std::endl; \
1326  return EXIT_FAILURE; \
1327  } \
1328  \
1329  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1330  ublas_v1[i] += std::FUNCNAME(ublas_v1[i]); \
1331  vcl_v1 += viennacl::linalg::element_##FUNCNAME(vcl_v1); \
1332  \
1333  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS) \
1334  { \
1335  std::cout << "Failure at v1 += " << #FUNCNAME << "(v2)" << std::endl; \
1336  return EXIT_FAILURE; \
1337  } \
1338  \
1339  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1340  ublas_v1[i] += std::FUNCNAME(ublas_v1[i] + ublas_v2[i]); \
1341  vcl_v1 += viennacl::linalg::element_##FUNCNAME(vcl_v1 + vcl_v2); \
1342  \
1343  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS) \
1344  { \
1345  std::cout << "Failure at v1 += " << #FUNCNAME << "(v1 + v2)" << std::endl; \
1346  return EXIT_FAILURE; \
1347  } \
1348  \
1349  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1350  ublas_v1[i] -= std::FUNCNAME(ublas_v2[i]); \
1351  vcl_v1 -= viennacl::linalg::element_##FUNCNAME(vcl_v2); \
1352  \
1353  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS) \
1354  { \
1355  std::cout << "Failure at v1 -= " << #FUNCNAME << "(v2)" << std::endl; \
1356  return EXIT_FAILURE; \
1357  } \
1358  \
1359  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1360  ublas_v1[i] -= std::FUNCNAME(ublas_v1[i] + ublas_v2[i]); \
1361  vcl_v1 -= viennacl::linalg::element_##FUNCNAME(vcl_v1 + vcl_v2); \
1362  \
1363  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS) \
1364  { \
1365  std::cout << "Failure at v1 -= " << #FUNCNAME << "(v1 + v2)" << std::endl; \
1366  return EXIT_FAILURE; \
1367  } \
1368 
1369  //GENERATE_UNARY_OP_TEST(cos);
1370  //GENERATE_UNARY_OP_TEST(cosh);
1371  //GENERATE_UNARY_OP_TEST(exp);
1372  //GENERATE_UNARY_OP_TEST(floor);
1373  //GENERATE_UNARY_OP_TEST(fabs);
1374  //GENERATE_UNARY_OP_TEST(log);
1375  //GENERATE_UNARY_OP_TEST(log10);
1376  //GENERATE_UNARY_OP_TEST(sin);
1377  //GENERATE_UNARY_OP_TEST(sinh);
1378  //GENERATE_UNARY_OP_TEST(fabs);
1380  //GENERATE_UNARY_OP_TEST(sqrt);
1381  //GENERATE_UNARY_OP_TEST(tan);
1382  //GENERATE_UNARY_OP_TEST(tanh);
1383 
1384  std::cout << "Testing lenghty sum of scaled vectors..." << std::endl;
1385  ublas_v2 = 3 * ublas_v1;
1386  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1387  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1388 
1389  ublas_v1 = ublas_v2 / alpha + beta * ublas_v1 - alpha * ublas_v2 + beta * ublas_v1 - alpha * ublas_v1;
1390  vcl_v1 = vcl_v2 / gpu_alpha + gpu_beta * vcl_v1 - alpha * vcl_v2 + beta * vcl_v1 - alpha * vcl_v1;
1391 
1392  if (check(ublas_v1, vcl_v1) != EXIT_SUCCESS)
1393  return EXIT_FAILURE;
1394 
1395  // --------------------------------------------------------------------------
1396  return retval;
1397 }
1398 
1399 
1400 template< typename NumericT >
1401 int test()
1402 {
1403  int retval = EXIT_SUCCESS;
1404  std::size_t size = 12345;
1405 
1406  std::cout << "Running tests for vector of size " << size << std::endl;
1407 
1408  //
1409  // Set up UBLAS objects
1410  //
1411  ublas::vector<NumericT> ublas_full_vec(size);
1412  ublas::vector<NumericT> ublas_full_vec2(ublas_full_vec.size());
1413 
1414  for (std::size_t i=0; i<ublas_full_vec.size(); ++i)
1415  {
1416  ublas_full_vec[i] = NumericT(1.0) + NumericT(i);
1417  ublas_full_vec2[i] = NumericT(2.0) + NumericT(i) / NumericT(2);
1418  }
1419 
1420  ublas::range r1( ublas_full_vec.size() / 4, 2 * ublas_full_vec.size() / 4);
1421  ublas::range r2(2 * ublas_full_vec2.size() / 4, 3 * ublas_full_vec2.size() / 4);
1422  ublas::vector_range< ublas::vector<NumericT> > ublas_range_vec(ublas_full_vec, r1);
1423  ublas::vector_range< ublas::vector<NumericT> > ublas_range_vec2(ublas_full_vec2, r2);
1424 
1425  ublas::slice s1( ublas_full_vec.size() / 4, 3, ublas_full_vec.size() / 4);
1426  ublas::slice s2(2 * ublas_full_vec2.size() / 4, 2, ublas_full_vec2.size() / 4);
1427  ublas::vector_slice< ublas::vector<NumericT> > ublas_slice_vec(ublas_full_vec, s1);
1428  ublas::vector_slice< ublas::vector<NumericT> > ublas_slice_vec2(ublas_full_vec2, s2);
1429 
1430  //
1431  // Set up ViennaCL objects
1432  //
1433  viennacl::vector<NumericT> vcl_full_vec(ublas_full_vec.size());
1434  viennacl::vector<NumericT> vcl_full_vec2(ublas_full_vec2.size());
1435 
1436  viennacl::fast_copy(ublas_full_vec.begin(), ublas_full_vec.end(), vcl_full_vec.begin());
1437  viennacl::copy(ublas_full_vec2.begin(), ublas_full_vec2.end(), vcl_full_vec2.begin());
1438 
1439  viennacl::range vcl_r1( vcl_full_vec.size() / 4, 2 * vcl_full_vec.size() / 4);
1440  viennacl::range vcl_r2(2 * vcl_full_vec2.size() / 4, 3 * vcl_full_vec2.size() / 4);
1441  viennacl::vector_range< viennacl::vector<NumericT> > vcl_range_vec(vcl_full_vec, vcl_r1);
1442  viennacl::vector_range< viennacl::vector<NumericT> > vcl_range_vec2(vcl_full_vec2, vcl_r2);
1443 
1444  {
1445  viennacl::vector<NumericT> vcl_short_vec(vcl_range_vec);
1446  viennacl::vector<NumericT> vcl_short_vec2 = vcl_range_vec2;
1447 
1448  ublas::vector<NumericT> ublas_short_vec(ublas_range_vec);
1449  ublas::vector<NumericT> ublas_short_vec2(ublas_range_vec2);
1450 
1451  std::cout << "Testing creation of vectors from range..." << std::endl;
1452  if (check(ublas_short_vec, vcl_short_vec) != EXIT_SUCCESS)
1453  return EXIT_FAILURE;
1454  if (check(ublas_short_vec2, vcl_short_vec2) != EXIT_SUCCESS)
1455  return EXIT_FAILURE;
1456  }
1457 
1458  viennacl::slice vcl_s1( vcl_full_vec.size() / 4, 3, vcl_full_vec.size() / 4);
1459  viennacl::slice vcl_s2(2 * vcl_full_vec2.size() / 4, 2, vcl_full_vec2.size() / 4);
1460  viennacl::vector_slice< viennacl::vector<NumericT> > vcl_slice_vec(vcl_full_vec, vcl_s1);
1461  viennacl::vector_slice< viennacl::vector<NumericT> > vcl_slice_vec2(vcl_full_vec2, vcl_s2);
1462 
1463  viennacl::vector<NumericT> vcl_short_vec(vcl_slice_vec);
1464  viennacl::vector<NumericT> vcl_short_vec2 = vcl_slice_vec2;
1465 
1466  ublas::vector<NumericT> ublas_short_vec(ublas_slice_vec);
1467  ublas::vector<NumericT> ublas_short_vec2(ublas_slice_vec2);
1468 
1469  std::cout << "Testing creation of vectors from slice..." << std::endl;
1470  if (check(ublas_short_vec, vcl_short_vec) != EXIT_SUCCESS)
1471  return EXIT_FAILURE;
1472  if (check(ublas_short_vec2, vcl_short_vec2) != EXIT_SUCCESS)
1473  return EXIT_FAILURE;
1474 
1475 
1476  //
1477  // Now start running tests for vectors, ranges and slices:
1478  //
1479 
1480  std::cout << " ** vcl_v1 = vector, vcl_v2 = vector **" << std::endl;
1481  retval = test<NumericT>(ublas_short_vec, ublas_short_vec2,
1482  vcl_short_vec, vcl_short_vec2);
1483  if (retval != EXIT_SUCCESS)
1484  return EXIT_FAILURE;
1485 
1486  std::cout << " ** vcl_v1 = vector, vcl_v2 = range **" << std::endl;
1487  retval = test<NumericT>(ublas_short_vec, ublas_short_vec2,
1488  vcl_short_vec, vcl_range_vec2);
1489  if (retval != EXIT_SUCCESS)
1490  return EXIT_FAILURE;
1491 
1492  std::cout << " ** vcl_v1 = vector, vcl_v2 = slice **" << std::endl;
1493  retval = test<NumericT>(ublas_short_vec, ublas_short_vec2,
1494  vcl_short_vec, vcl_slice_vec2);
1495  if (retval != EXIT_SUCCESS)
1496  return EXIT_FAILURE;
1497 
1499 
1500  std::cout << " ** vcl_v1 = range, vcl_v2 = vector **" << std::endl;
1501  retval = test<NumericT>(ublas_short_vec, ublas_short_vec2,
1502  vcl_range_vec, vcl_short_vec2);
1503  if (retval != EXIT_SUCCESS)
1504  return EXIT_FAILURE;
1505 
1506  std::cout << " ** vcl_v1 = range, vcl_v2 = range **" << std::endl;
1507  retval = test<NumericT>(ublas_short_vec, ublas_short_vec2,
1508  vcl_range_vec, vcl_range_vec2);
1509  if (retval != EXIT_SUCCESS)
1510  return EXIT_FAILURE;
1511 
1512  std::cout << " ** vcl_v1 = range, vcl_v2 = slice **" << std::endl;
1513  retval = test<NumericT>(ublas_short_vec, ublas_short_vec2,
1514  vcl_range_vec, vcl_slice_vec2);
1515  if (retval != EXIT_SUCCESS)
1516  return EXIT_FAILURE;
1517 
1519 
1520  std::cout << " ** vcl_v1 = slice, vcl_v2 = vector **" << std::endl;
1521  retval = test<NumericT>(ublas_short_vec, ublas_short_vec2,
1522  vcl_slice_vec, vcl_short_vec2);
1523  if (retval != EXIT_SUCCESS)
1524  return EXIT_FAILURE;
1525 
1526  std::cout << " ** vcl_v1 = slice, vcl_v2 = range **" << std::endl;
1527  retval = test<NumericT>(ublas_short_vec, ublas_short_vec2,
1528  vcl_slice_vec, vcl_range_vec2);
1529  if (retval != EXIT_SUCCESS)
1530  return EXIT_FAILURE;
1531 
1532  std::cout << " ** vcl_v1 = slice, vcl_v2 = slice **" << std::endl;
1533  retval = test<NumericT>(ublas_short_vec, ublas_short_vec2,
1534  vcl_slice_vec, vcl_slice_vec2);
1535  if (retval != EXIT_SUCCESS)
1536  return EXIT_FAILURE;
1537 
1538  return EXIT_SUCCESS;
1539 }
1540 
1541 
1542 
1543 //
1544 // -------------------------------------------------------------
1545 //
1546 int main()
1547 {
1548  std::cout << std::endl;
1549  std::cout << "----------------------------------------------" << std::endl;
1550  std::cout << "----------------------------------------------" << std::endl;
1551  std::cout << "## Test :: Vector with Integer types" << std::endl;
1552  std::cout << "----------------------------------------------" << std::endl;
1553  std::cout << "----------------------------------------------" << std::endl;
1554  std::cout << std::endl;
1555 
1556  int retval = EXIT_SUCCESS;
1557 
1558  std::cout << std::endl;
1559  std::cout << "----------------------------------------------" << std::endl;
1560  std::cout << std::endl;
1561  {
1562  std::cout << "# Testing setup:" << std::endl;
1563  std::cout << " numeric: int" << std::endl;
1564  retval = test<int>();
1565  if ( retval == EXIT_SUCCESS )
1566  std::cout << "# Test passed" << std::endl;
1567  else
1568  return retval;
1569  }
1570  std::cout << std::endl;
1571  std::cout << "----------------------------------------------" << std::endl;
1572  std::cout << std::endl;
1573  {
1574  std::cout << "# Testing setup:" << std::endl;
1575  std::cout << " numeric: long" << std::endl;
1576  retval = test<long>();
1577  if ( retval == EXIT_SUCCESS )
1578  std::cout << "# Test passed" << std::endl;
1579  else
1580  return retval;
1581  }
1582  std::cout << std::endl;
1583  std::cout << "----------------------------------------------" << std::endl;
1584  std::cout << std::endl;
1585 
1586  std::cout << std::endl;
1587  std::cout << "------- Test completed --------" << std::endl;
1588  std::cout << std::endl;
1589 
1590  return retval;
1591 }
int test(UblasVectorType &ublas_v1, UblasVectorType &ublas_v2, ViennaCLVectorType1 &vcl_v1, ViennaCLVectorType2 &vcl_v2)
Definition: vector_int.cpp:118
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)
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.
This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type...
Definition: forwards.h:226
Generic interface for the l^2-norm. See viennacl/linalg/vector_operations.hpp for implementations...
void plane_rotation(vector_base< T > &vec1, vector_base< T > &vec2, T alpha, T beta)
Computes a plane rotation of two vectors.
void finish()
Synchronizes the execution. finish() will only return after all compute kernels (CUDA, OpenCL) have completed.
Definition: memory.hpp:54
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:89
viennacl::scalar< int > s2
viennacl::scalar< float > s1
Generic interface for the computation of inner products. See viennacl/linalg/vector_operations.hpp for implementations.
Generic interface for the l^1-norm. See viennacl/linalg/vector_operations.hpp for implementations...
#define GENERATE_UNARY_OP_TEST(FUNCNAME)
basic_range range
Definition: forwards.h:423
int check(T1 const &t1, T2 const &t2)
Definition: vector_int.cpp:101
viennacl::vector< float > v1
vcl_size_t size(VectorType const &vec)
Generic routine for obtaining the size of a vector (ViennaCL, uBLAS, etc.)
Definition: size.hpp:144
Class for representing non-strided subvectors of a bigger vector x.
Definition: forwards.h:433
int main()
Class for representing strided subvectors of a bigger vector x.
Definition: forwards.h:436
ScalarType diff(ScalarType const &s1, ScalarType const &s2)
Definition: vector_int.cpp:58
Proxy classes for vectors.
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.
Represents a vector consisting of 1 at a given index and zeros otherwise.
Definition: vector_def.hpp:76
viennacl::vector< int > v2
basic_slice slice
Definition: forwards.h:428
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
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
NumericT max(std::vector< NumericT > const &v1)
Definition: maxmin.hpp:47
T norm_inf(std::vector< T, A > const &v1)
Definition: norm_inf.hpp:60
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) ...
T norm_1(std::vector< T, A > const &v1)
Definition: norm_1.hpp:61
A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
Definition: forwards.h:423
float ScalarType
Definition: fft_1d.cpp:42
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)
A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
Definition: forwards.h:428
A proxy class for a single element of a vector or matrix. This proxy should not be noticed by end-use...
Definition: forwards.h:232
Generic interface for the l^infty-norm. See viennacl/linalg/vector_operations.hpp for implementations...
NumericT min(std::vector< NumericT > const &v1)
Definition: maxmin.hpp:91
void fast_copy(const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_begin, const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_end, CPU_ITERATOR cpu_begin)