ViennaCL - The Vienna Computing Library  1.6.0
Free open-source GPU-accelerated linear algebra and solver library.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
vector_float_double.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 #include <cmath>
29 
30 // We don't need debug mode in UBLAS:
31 #ifndef NDEBUG
32  #define BOOST_UBLAS_NDEBUG
33 #endif
34 
35 //
36 // *** Boost
37 //
38 #include <boost/numeric/ublas/io.hpp>
39 #include <boost/numeric/ublas/vector.hpp>
40 #include <boost/numeric/ublas/vector_proxy.hpp>
41 
42 //
43 // *** ViennaCL
44 //
45 //#define VIENNACL_DEBUG_ALL
46 #define VIENNACL_WITH_UBLAS 1
47 #include "viennacl/vector.hpp"
54 
55 #include "Random.hpp"
56 
57 using namespace boost::numeric;
58 
59 
60 //
61 // -------------------------------------------------------------
62 //
63 template<typename ScalarType>
65 {
67  if (std::fabs(s1 - s2) > 0 )
68  return (s1 - s2) / std::max(std::fabs(s1), std::fabs(s2));
69  return 0;
70 }
71 //
72 // -------------------------------------------------------------
73 //
74 template<typename ScalarType>
76 {
78  if (std::fabs(s1 - s2) > 0 )
79  return (s1 - s2) / std::max(std::fabs(s1), std::fabs(s2));
80  return 0;
81 }
82 //
83 // -------------------------------------------------------------
84 //
85 template<typename ScalarType>
87 {
89  if (std::fabs(s1 - s2) > 0 )
90  return (s1 - s2) / std::max(std::fabs(s1), std::fabs(s2));
91  return 0;
92 }
93 //
94 // -------------------------------------------------------------
95 //
96 template<typename ScalarType, typename ViennaCLVectorType>
97 ScalarType diff(ublas::vector<ScalarType> const & v1, ViennaCLVectorType const & vcl_vec)
98 {
99  ublas::vector<ScalarType> v2_cpu(vcl_vec.size());
101  viennacl::copy(vcl_vec, v2_cpu);
102 
103  for (unsigned int i=0;i<v1.size(); ++i)
104  {
105  if ( std::max( std::fabs(v2_cpu[i]), std::fabs(v1[i]) ) > 0 )
106  v2_cpu[i] = std::fabs(v2_cpu[i] - v1[i]) / std::max( std::fabs(v2_cpu[i]), std::fabs(v1[i]) );
107  else
108  v2_cpu[i] = 0.0;
109  }
110 
111  return ublas::norm_inf(v2_cpu);
112 }
113 
114 
115 template<typename T1, typename T2>
116 int check(T1 const & t1, T2 const & t2, double epsilon)
117 {
118  int retval = EXIT_SUCCESS;
119 
120  double temp = std::fabs(diff(t1, t2));
121  if (temp > epsilon)
122  {
123  std::cout << "# Error! Relative difference: " << temp << std::endl;
124  retval = EXIT_FAILURE;
125  }
126  return retval;
127 }
128 
129 
130 //
131 // -------------------------------------------------------------
132 //
133 template< typename NumericT, typename Epsilon, typename UblasVectorType, typename ViennaCLVectorType1, typename ViennaCLVectorType2 >
134 int test(Epsilon const& epsilon,
135  UblasVectorType & ublas_v1, UblasVectorType & ublas_v2,
136  ViennaCLVectorType1 & vcl_v1, ViennaCLVectorType2 & vcl_v2)
137 {
138  int retval = EXIT_SUCCESS;
139 
140  NumericT cpu_result = 42.0;
141  viennacl::scalar<NumericT> gpu_result = 43.0;
142 
143  //
144  // Initializer:
145  //
146  std::cout << "Checking for zero_vector initializer..." << std::endl;
147  ublas_v1 = ublas::zero_vector<NumericT>(ublas_v1.size());
148  vcl_v1 = viennacl::zero_vector<NumericT>(vcl_v1.size());
149  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
150  return EXIT_FAILURE;
151 
152  std::cout << "Checking for scalar_vector initializer..." << std::endl;
153  ublas_v1 = ublas::scalar_vector<NumericT>(ublas_v1.size(), cpu_result);
154  vcl_v1 = viennacl::scalar_vector<NumericT>(vcl_v1.size(), cpu_result);
155  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
156  return EXIT_FAILURE;
157 
158  ublas_v1 = ublas::scalar_vector<NumericT>(ublas_v1.size(), gpu_result);
159  vcl_v1 = viennacl::scalar_vector<NumericT>(vcl_v1.size(), gpu_result);
160  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
161  return EXIT_FAILURE;
162 
163  std::cout << "Checking for unit_vector initializer..." << std::endl;
164  ublas_v1 = ublas::unit_vector<NumericT>(ublas_v1.size(), 5);
165  vcl_v1 = viennacl::unit_vector<NumericT>(vcl_v1.size(), 5);
166  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
167  return EXIT_FAILURE;
168 
169 
170  for (std::size_t i=0; i<ublas_v1.size(); ++i)
171  {
172  ublas_v1[i] = NumericT(1.0) + random<NumericT>();
173  ublas_v2[i] = NumericT(1.0) + random<NumericT>();
174  }
175 
176  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin()); //resync
177  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
178 
179  std::cout << "Checking for successful copy..." << std::endl;
180  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
181  return EXIT_FAILURE;
182  if (check(ublas_v2, vcl_v2, epsilon) != EXIT_SUCCESS)
183  return EXIT_FAILURE;
184 
185  //
186  // Part 1: Norms and inner product
187  //
188 
189  // --------------------------------------------------------------------------
190  std::cout << "Testing inner_prod..." << std::endl;
191  cpu_result = viennacl::linalg::inner_prod(ublas_v1, ublas_v2);
192  NumericT cpu_result2 = viennacl::linalg::inner_prod(vcl_v1, vcl_v2);
193  gpu_result = viennacl::linalg::inner_prod(vcl_v1, vcl_v2);
194 
195  if (check(cpu_result, cpu_result2, epsilon) != EXIT_SUCCESS)
196  return EXIT_FAILURE;
197  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
198  return EXIT_FAILURE;
199 
200  cpu_result = inner_prod(ublas_v1 + ublas_v2, ublas_v2 - ublas_v1);
201  NumericT cpu_result3 = viennacl::linalg::inner_prod(vcl_v1 + vcl_v2, vcl_v2 - vcl_v1);
202  gpu_result = viennacl::linalg::inner_prod(vcl_v1 + vcl_v2, vcl_v2 - vcl_v1);
203 
204  if (check(cpu_result, cpu_result3, epsilon) != EXIT_SUCCESS)
205  return EXIT_FAILURE;
206  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
207  return EXIT_FAILURE;
208 
209  // --------------------------------------------------------------------------
210  std::cout << "Testing norm_1..." << std::endl;
211  cpu_result = ublas::norm_1(ublas_v1);
212  gpu_result = viennacl::linalg::norm_1(vcl_v1);
213 
214  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
215  return EXIT_FAILURE;
216 
217  gpu_result = 2 * cpu_result; //reset
218  gpu_result = ublas::norm_1(ublas_v1);
219  cpu_result = viennacl::linalg::norm_1(vcl_v1);
220 
221  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
222  return EXIT_FAILURE;
223 
224  gpu_result = ublas::norm_1(ublas_v1 + ublas_v2);
225  cpu_result = viennacl::linalg::norm_1(vcl_v1 + vcl_v2);
226 
227  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
228  return EXIT_FAILURE;
229 
230  // --------------------------------------------------------------------------
231  std::cout << "Testing norm_2..." << std::endl;
232  cpu_result = ublas::norm_2(ublas_v1);
233  gpu_result = viennacl::linalg::norm_2(vcl_v1);
234 
235  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
236  return EXIT_FAILURE;
237 
238  gpu_result = 2 * cpu_result; //reset
239  gpu_result = ublas::norm_2(ublas_v1);
240  cpu_result = viennacl::linalg::norm_2(vcl_v1);
241 
242  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
243  return EXIT_FAILURE;
244 
245  gpu_result = ublas::norm_2(ublas_v1 + ublas_v2);
246  cpu_result = viennacl::linalg::norm_2(vcl_v1 + vcl_v2);
247 
248  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
249  return EXIT_FAILURE;
250 
251  // --------------------------------------------------------------------------
252  std::cout << "Testing norm_inf..." << std::endl;
253  cpu_result = ublas::norm_inf(ublas_v1);
254  gpu_result = viennacl::linalg::norm_inf(vcl_v1);
255 
256  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
257  return EXIT_FAILURE;
258 
259  gpu_result = 2 * cpu_result; //reset
260  gpu_result = ublas::norm_inf(ublas_v1);
261  cpu_result = viennacl::linalg::norm_inf(vcl_v1);
262 
263  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
264  return EXIT_FAILURE;
265 
266  gpu_result = ublas::norm_inf(ublas_v1 + ublas_v2);
267  cpu_result = viennacl::linalg::norm_inf(vcl_v1 + vcl_v2);
268 
269  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
270  return EXIT_FAILURE;
271 
272  // --------------------------------------------------------------------------
273  std::cout << "Testing index_norm_inf..." << std::endl;
274  std::size_t cpu_index = ublas::index_norm_inf(ublas_v1);
275  std::size_t gpu_index = viennacl::linalg::index_norm_inf(vcl_v1);
276 
277  if (check(static_cast<NumericT>(cpu_index), static_cast<NumericT>(gpu_index), epsilon) != EXIT_SUCCESS)
278  return EXIT_FAILURE;
279  // --------------------------------------------------------------------------
280  cpu_result = ublas_v1[index_norm_inf(ublas_v1)];
281  gpu_result = vcl_v1[viennacl::linalg::index_norm_inf(vcl_v1)];
282 
283  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
284  return EXIT_FAILURE;
285 
286  cpu_result = ublas_v1[index_norm_inf(ublas_v1 + ublas_v2)];
287  gpu_result = vcl_v1[viennacl::linalg::index_norm_inf(vcl_v1 + vcl_v2)];
288 
289  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
290  return EXIT_FAILURE;
291 
292 
293  // --------------------------------------------------------------------------
294  std::cout << "Testing max..." << std::endl;
295  cpu_result = ublas_v1[0];
296  for (std::size_t i=0; i<ublas_v1.size(); ++i)
297  cpu_result = std::max<NumericT>(cpu_result, ublas_v1[i]);
298  gpu_result = viennacl::linalg::max(vcl_v1);
299 
300  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
301  return EXIT_FAILURE;
302 
303  cpu_result = ublas_v1[0];
304  for (std::size_t i=0; i<ublas_v1.size(); ++i)
305  cpu_result = std::max<NumericT>(cpu_result, ublas_v1[i]);
306  gpu_result = cpu_result;
307  cpu_result *= 2; //reset
308  cpu_result = viennacl::linalg::max(vcl_v1);
309 
310  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
311  return EXIT_FAILURE;
312 
313  cpu_result = ublas_v1[0] + ublas_v2[0];
314  for (std::size_t i=0; i<ublas_v1.size(); ++i)
315  cpu_result = std::max<NumericT>(cpu_result, ublas_v1[i] + ublas_v2[i]);
316  gpu_result = cpu_result;
317  cpu_result *= 2; //reset
318  cpu_result = viennacl::linalg::max(vcl_v1 + vcl_v2);
319 
320  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
321  return EXIT_FAILURE;
322 
323 
324  // --------------------------------------------------------------------------
325  std::cout << "Testing min..." << std::endl;
326  cpu_result = ublas_v1[0];
327  for (std::size_t i=0; i<ublas_v1.size(); ++i)
328  cpu_result = std::min<NumericT>(cpu_result, ublas_v1[i]);
329  gpu_result = viennacl::linalg::min(vcl_v1);
330 
331  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
332  return EXIT_FAILURE;
333 
334  cpu_result = ublas_v1[0];
335  for (std::size_t i=0; i<ublas_v1.size(); ++i)
336  cpu_result = std::min<NumericT>(cpu_result, ublas_v1[i]);
337  gpu_result = cpu_result;
338  cpu_result *= 2; //reset
339  cpu_result = viennacl::linalg::min(vcl_v1);
340 
341  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
342  return EXIT_FAILURE;
343 
344  cpu_result = ublas_v1[0] + ublas_v2[0];
345  for (std::size_t i=0; i<ublas_v1.size(); ++i)
346  cpu_result = std::min<NumericT>(cpu_result, ublas_v1[i] + ublas_v2[i]);
347  gpu_result = cpu_result;
348  cpu_result *= 2; //reset
349  cpu_result = viennacl::linalg::min(vcl_v1 + vcl_v2);
350 
351  if (check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
352  return EXIT_FAILURE;
353 
354 
355 
356  //
357  // Plane rotation and assignments
358  //
359 
360  // --------------------------------------------------------------------------
361 
362  ublas::vector<NumericT> x = ublas_v1;
363  ublas::vector<NumericT> y = ublas_v2;
364  ublas::vector<NumericT> t = ublas_v1;
365  t.assign (NumericT(1.1) * x + NumericT(2.3) * y),
366  y.assign (- NumericT(2.3) * x + NumericT(1.1) * y),
367  x.assign (t);
368 
369  viennacl::linalg::plane_rotation(vcl_v1, vcl_v2, NumericT(1.1), NumericT(2.3));
370 
371  if (check(x, vcl_v1, epsilon) != EXIT_SUCCESS)
372  return EXIT_FAILURE;
373  if (check(y, vcl_v2, epsilon) != EXIT_SUCCESS)
374  return EXIT_FAILURE;
375 
376  // --------------------------------------------------------------------------
377 
378  std::cout << "Testing assignments..." << std::endl;
379  NumericT val = static_cast<NumericT>(1e-1);
380  for (size_t i=0; i < ublas_v1.size(); ++i)
381  ublas_v1(i) = val;
382 
383  for (size_t i=0; i < vcl_v1.size(); ++i)
384  vcl_v1(i) = val;
385 
386  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
387  return EXIT_FAILURE;
388 
389  std::cout << "Testing assignments via iterators..." << std::endl;
390 
391  ublas_v1[2] = static_cast<NumericT>(1.9);
392  vcl_v1[2] = static_cast<NumericT>(1.9);
393 
394  typename UblasVectorType::iterator ublas_v1_it = ublas_v1.begin();
395  ++ublas_v1_it;
396  ++ublas_v1_it;
397  *ublas_v1_it = static_cast<NumericT>(1.5);
398  typename ViennaCLVectorType1::iterator vcl_v1_it = vcl_v1.begin();
399  ++vcl_v1_it;
400  ++vcl_v1_it;
401  *vcl_v1_it = static_cast<NumericT>(1.5);
402 
403  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
404  return EXIT_FAILURE;
405 
406  //
407  // multiplication and division of vectors by scalars
408  //
409  for (size_t i=0; i < ublas_v1.size(); ++i)
410  ublas_v1(i) = NumericT(1.0) + random<NumericT>();
411  ublas_v2 = NumericT(3.1415) * ublas_v1;
412  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin()); //resync
413  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
414 
415  std::cout << "Testing scaling with CPU scalar..." << std::endl;
416  NumericT alpha = static_cast<NumericT>(1.7182);
417  viennacl::scalar<NumericT> gpu_alpha = alpha;
418 
419  ublas_v1 *= long(alpha);
420  vcl_v1 *= long(alpha);
421 
422  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
423  return EXIT_FAILURE;
424 
425  ublas_v1 *= float(alpha);
426  vcl_v1 *= float(alpha);
427 
428  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
429  return EXIT_FAILURE;
430 
431  ublas_v1 *= double(alpha);
432  vcl_v1 *= double(alpha);
433 
434  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
435  return EXIT_FAILURE;
436 
437 
438  std::cout << "Testing scaling with GPU scalar..." << std::endl;
439  ublas_v1 *= alpha;
440  vcl_v1 *= gpu_alpha;
441 
442  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
443  return EXIT_FAILURE;
444 
445  std::cout << "Testing scaling with scalar expression..." << std::endl;
446  ublas_v1 *= inner_prod(ublas_v1, ublas_v2);
447  vcl_v1 *= viennacl::linalg::inner_prod(vcl_v1, vcl_v2);
448 
449  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
450  return EXIT_FAILURE;
451 
452  NumericT beta = static_cast<NumericT>(1.4153);
453  viennacl::scalar<NumericT> gpu_beta = beta;
454 
455  std::cout << "Testing shrinking with CPU scalar..." << std::endl;
456  ublas_v1 /= long(beta);
457  vcl_v1 /= long(beta);
458 
459  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
460  return EXIT_FAILURE;
461 
462  ublas_v1 /= float(beta);
463  vcl_v1 /= float(beta);
464 
465  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
466  return EXIT_FAILURE;
467 
468  ublas_v1 /= double(beta);
469  vcl_v1 /= double(beta);
470 
471  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
472  return EXIT_FAILURE;
473 
474 
475  std::cout << "Testing shrinking with GPU scalar..." << std::endl;
476  ublas_v1 /= beta;
477  vcl_v1 /= gpu_beta;
478 
479  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
480  return EXIT_FAILURE;
481 
482 
483 
484  //
485  // add and inplace_add of vectors
486  //
487  for (size_t i=0; i < ublas_v1.size(); ++i)
488  ublas_v1(i) = NumericT(1.0) + random<NumericT>();
489  ublas_v2 = NumericT(3.1415) * ublas_v1;
490  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin()); //resync
491  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
492 
493  std::cout << "Testing add on vector..." << std::endl;
494 
495  std::cout << "Checking for successful copy..." << std::endl;
496  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
497  return EXIT_FAILURE;
498  if (check(ublas_v2, vcl_v2, epsilon) != EXIT_SUCCESS)
499  return EXIT_FAILURE;
500 
501  ublas_v1 = ublas_v1 + ublas_v2;
502  vcl_v1 = vcl_v1 + vcl_v2;
503 
504  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
505  return EXIT_FAILURE;
506 
507  std::cout << "Testing add on vector with flipsign..." << std::endl;
508  ublas_v1 = - ublas_v1 + ublas_v2;
509  vcl_v1 = - vcl_v1 + vcl_v2;
510 
511  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
512  return EXIT_FAILURE;
513 
514  std::cout << "Testing inplace-add on vector..." << std::endl;
515  ublas_v1 += ublas_v2;
516  vcl_v1 += vcl_v2;
517 
518  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
519  return EXIT_FAILURE;
520 
521  std::cout << "Testing assignment to vector with vector multiplied by scalar expression..." << std::endl;
522  ublas_v1 = inner_prod(ublas_v1, ublas_v2) * ublas_v2;
523  vcl_v1 = viennacl::linalg::inner_prod(vcl_v1, vcl_v2) * vcl_v2;
524 
525  //
526  // subtract and inplace_subtract of vectors
527  //
528  std::cout << "Testing sub on vector..." << std::endl;
529  ublas_v2 = NumericT(3.1415) * ublas_v1;
530  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
531  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
532 
533  ublas_v1 = ublas_v1 - ublas_v2;
534  vcl_v1 = vcl_v1 - vcl_v2;
535 
536  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
537  return EXIT_FAILURE;
538 
539  std::cout << "Testing inplace-sub on vector..." << std::endl;
540  ublas_v1 -= ublas_v2;
541  vcl_v1 -= vcl_v2;
542 
543  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
544  return EXIT_FAILURE;
545 
546 
547 
548  //
549  // multiply-add
550  //
551  std::cout << "Testing multiply-add on vector with CPU scalar (right)..." << std::endl;
552  for (size_t i=0; i < ublas_v1.size(); ++i)
553  ublas_v1(i) = NumericT(1.0) + random<NumericT>();
554  ublas_v2 = NumericT(3.1415) * ublas_v1;
555  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
556  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
557 
558  ublas_v1 = ublas_v1 + ublas_v2 * float(alpha);
559  vcl_v1 = vcl_v1 + vcl_v2 * float(alpha);
560 
561  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
562  return EXIT_FAILURE;
563 
564  ublas_v1 = ublas_v1 + ublas_v2 * double(alpha);
565  vcl_v1 = vcl_v1 + vcl_v2 * double(alpha);
566 
567  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
568  return EXIT_FAILURE;
569 
570 
571  std::cout << "Testing multiply-add on vector with CPU scalar (left)..." << std::endl;
572  ublas_v2 = NumericT(3.1415) * ublas_v1;
573  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
574  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
575 
576  ublas_v1 = long(alpha) * ublas_v1 + ublas_v2;
577  vcl_v1 = long(alpha) * vcl_v1 + vcl_v2;
578 
579  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
580  return EXIT_FAILURE;
581 
582  ublas_v1 = float(alpha) * ublas_v1 + ublas_v2;
583  vcl_v1 = float(alpha) * vcl_v1 + vcl_v2;
584 
585  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
586  return EXIT_FAILURE;
587 
588  ublas_v1 = double(alpha) * ublas_v1 + ublas_v2;
589  vcl_v1 = double(alpha) * vcl_v1 + vcl_v2;
590 
591  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
592  return EXIT_FAILURE;
593 
594 
595  std::cout << "Testing multiply-add on vector with CPU scalar (both)..." << std::endl;
596  ublas_v2 = NumericT(3.1415) * ublas_v1;
597  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
598  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
599 
600  ublas_v1 = long(alpha) * ublas_v1 + long(beta) * ublas_v2;
601  vcl_v1 = long(alpha) * vcl_v1 + long(beta) * vcl_v2;
602 
603  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
604  return EXIT_FAILURE;
605 
606  ublas_v1 = float(alpha) * ublas_v1 + float(beta) * ublas_v2;
607  vcl_v1 = float(alpha) * vcl_v1 + float(beta) * vcl_v2;
608 
609  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
610  return EXIT_FAILURE;
611 
612  ublas_v1 = double(alpha) * ublas_v1 + double(beta) * ublas_v2;
613  vcl_v1 = double(alpha) * vcl_v1 + double(beta) * vcl_v2;
614 
615  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
616  return EXIT_FAILURE;
617 
618 
619  std::cout << "Testing inplace multiply-add on vector with CPU scalar..." << std::endl;
620  ublas_v2 = NumericT(3.1415) * ublas_v1;
621  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
622  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
623 
624  ublas_v1 += ublas_v2 * long(alpha);
625  vcl_v1 += vcl_v2 * long(alpha);
626 
627  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
628  return EXIT_FAILURE;
629 
630  ublas_v1 += ublas_v2 * float(alpha);
631  vcl_v1 += vcl_v2 * float(alpha);
632 
633  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
634  return EXIT_FAILURE;
635 
636  ublas_v1 += double(alpha) * ublas_v2;
637  vcl_v1 += double(alpha) * vcl_v2;
638 
639  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
640  return EXIT_FAILURE;
641 
642 
643  std::cout << "Testing multiply-add on vector with GPU scalar (right)..." << std::endl;
644  ublas_v2 = NumericT(3.1415) * ublas_v1;
645  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
646  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
647 
648  ublas_v1 = ublas_v1 + alpha * ublas_v2;
649  vcl_v1 = vcl_v1 + gpu_alpha * vcl_v2;
650 
651  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
652  return EXIT_FAILURE;
653 
654  std::cout << "Testing multiply-add on vector with GPU scalar (left)..." << std::endl;
655  ublas_v2 = NumericT(3.1415) * ublas_v1;
656  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
657  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
658 
659  ublas_v1 = ublas_v1 + alpha * ublas_v2;
660  vcl_v1 = vcl_v1 + gpu_alpha * vcl_v2;
661 
662  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
663  return EXIT_FAILURE;
664 
665  std::cout << "Testing multiply-add on vector with GPU scalar (both)..." << std::endl;
666  ublas_v2 = NumericT(3.1415) * ublas_v1;
667  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
668  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
669 
670  ublas_v1 = alpha * ublas_v1 + beta * ublas_v2;
671  vcl_v1 = gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
672 
673  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
674  return EXIT_FAILURE;
675 
676 
677  std::cout << "Testing inplace multiply-add on vector with GPU scalar (both, adding)..." << std::endl;
678  ublas_v2 = NumericT(3.1415) * ublas_v1;
679  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
680  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
681 
682  ublas_v1 += alpha * ublas_v1 + beta * ublas_v2;
683  vcl_v1 += gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
684 
685  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
686  return EXIT_FAILURE;
687 
688  std::cout << "Testing inplace multiply-add on vector with GPU scalar (both, subtracting)..." << std::endl;
689  ublas_v2 = NumericT(3.1415) * ublas_v1;
690  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
691  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
692 
693  ublas_v1 += alpha * ublas_v1 - beta * ublas_v2;
694  vcl_v1 += gpu_alpha * vcl_v1 - gpu_beta * vcl_v2;
695 
696  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
697  return EXIT_FAILURE;
698 
699 
700 
701  std::cout << "Testing inplace multiply-add on vector with GPU scalar..." << std::endl;
702  ublas_v2 = NumericT(3.1415) * ublas_v1;
703  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
704  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
705 
706  ublas_v1 += alpha * ublas_v2;
707  vcl_v1 += gpu_alpha * vcl_v2;
708 
709  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
710  return EXIT_FAILURE;
711 
712 
713  //
714  // division-add
715  //
716  std::cout << "Testing division-add on vector with CPU scalar (right)..." << std::endl;
717  for (size_t i=0; i < ublas_v1.size(); ++i)
718  ublas_v1(i) = NumericT(1.0) + random<NumericT>();
719  ublas_v2 = NumericT(3.1415) * ublas_v1;
720  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
721  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
722 
723  ublas_v1 = ublas_v1 + ublas_v2 / long(alpha);
724  vcl_v1 = vcl_v1 + vcl_v2 / long(alpha);
725 
726  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
727  return EXIT_FAILURE;
728 
729  ublas_v1 = ublas_v1 + ublas_v2 / float(alpha);
730  vcl_v1 = vcl_v1 + vcl_v2 / float(alpha);
731 
732  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
733  return EXIT_FAILURE;
734 
735  ublas_v1 = ublas_v1 + ublas_v2 / double(alpha);
736  vcl_v1 = vcl_v1 + vcl_v2 / double(alpha);
737 
738  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
739  return EXIT_FAILURE;
740 
741 
742  std::cout << "Testing division-add on vector with CPU scalar (left)..." << std::endl;
743  ublas_v2 = NumericT(3.1415) * ublas_v1;
744  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
745  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
746 
747  ublas_v1 = ublas_v1 / float(alpha) + ublas_v2;
748  vcl_v1 = vcl_v1 / float(alpha) + vcl_v2;
749 
750  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
751  return EXIT_FAILURE;
752 
753  ublas_v1 = ublas_v1 / double(alpha) + ublas_v2;
754  vcl_v1 = vcl_v1 / double(alpha) + vcl_v2;
755 
756  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
757  return EXIT_FAILURE;
758 
759 
760  std::cout << "Testing division-add on vector with CPU scalar (both)..." << std::endl;
761  ublas_v2 = NumericT(3.1415) * ublas_v1;
762  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
763  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
764 
765  ublas_v1 = ublas_v1 / float(alpha) + ublas_v2 / float(beta);
766  vcl_v1 = vcl_v1 / float(alpha) + vcl_v2 / float(beta);
767 
768  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
769  return EXIT_FAILURE;
770 
771  ublas_v1 = ublas_v1 / double(alpha) + ublas_v2 / double(beta);
772  vcl_v1 = vcl_v1 / double(alpha) + vcl_v2 / double(beta);
773 
774  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
775  return EXIT_FAILURE;
776 
777  std::cout << "Testing division-multiply-add on vector with CPU scalar..." << std::endl;
778  ublas_v2 = NumericT(3.1415) * ublas_v1;
779  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
780  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
781 
782  ublas_v1 = ublas_v1 / alpha + ublas_v2 * beta;
783  vcl_v1 = vcl_v1 / alpha + vcl_v2 * beta;
784 
785  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
786  return EXIT_FAILURE;
787 
788 
789  std::cout << "Testing multiply-division-add on vector with CPU scalar..." << std::endl;
790  ublas_v2 = NumericT(3.1415) * ublas_v1;
791  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
792  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
793 
794  ublas_v1 = ublas_v1 * alpha + ublas_v2 / beta;
795  vcl_v1 = vcl_v1 * alpha + vcl_v2 / beta;
796 
797  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
798  return EXIT_FAILURE;
799 
800 
801 
802  std::cout << "Testing inplace division-add on vector with CPU scalar..." << std::endl;
803  ublas_v2 = NumericT(3.1415) * ublas_v1;
804  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
805  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
806 
807  ublas_v1 += ublas_v2 / alpha;
808  vcl_v1 += vcl_v2 / alpha;
809 
810  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
811  return EXIT_FAILURE;
812 
813 
814  std::cout << "Testing division-add on vector with GPU scalar (right)..." << std::endl;
815  ublas_v2 = NumericT(3.1415) * ublas_v1;
816  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
817  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
818 
819  ublas_v1 = ublas_v1 + ublas_v2 / alpha;
820  vcl_v1 = vcl_v1 + vcl_v2 / gpu_alpha;
821 
822  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
823  return EXIT_FAILURE;
824 
825  std::cout << "Testing division-add on vector with GPU scalar (left)..." << std::endl;
826  ublas_v2 = NumericT(3.1415) * ublas_v1;
827  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
828  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
829 
830  ublas_v1 = ublas_v1 + ublas_v2 / alpha;
831  vcl_v1 = vcl_v1 + vcl_v2 / gpu_alpha;
832 
833  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
834  return EXIT_FAILURE;
835 
836  std::cout << "Testing division-add on vector with GPU scalar (both)..." << std::endl;
837  ublas_v2 = NumericT(3.1415) * ublas_v1;
838  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
839  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
840 
841  ublas_v1 = ublas_v1 / alpha + ublas_v2 / beta;
842  vcl_v1 = vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
843 
844  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
845  return EXIT_FAILURE;
846 
847 
848  std::cout << "Testing inplace division-add on vector with GPU scalar (both, adding)..." << std::endl;
849  ublas_v2 = NumericT(3.1415) * ublas_v1;
850  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
851  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
852 
853  ublas_v1 += ublas_v1 / alpha + ublas_v2 / beta;
854  vcl_v1 += vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
855 
856  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
857  return EXIT_FAILURE;
858 
859  std::cout << "Testing inplace division-add on vector with GPU scalar (both, subtracting)..." << std::endl;
860  ublas_v2 = NumericT(3.1415) * ublas_v1;
861  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
862  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
863 
864  ublas_v1 += ublas_v1 / alpha - ublas_v2 / beta;
865  vcl_v1 += vcl_v1 / gpu_alpha - vcl_v2 / gpu_beta;
866 
867  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
868  return EXIT_FAILURE;
869 
870  std::cout << "Testing inplace division-multiply-add on vector with GPU scalar (adding)..." << std::endl;
871  ublas_v2 = NumericT(3.1415) * 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 / alpha + ublas_v2 * beta;
876  vcl_v1 += vcl_v1 / gpu_alpha + vcl_v2 * gpu_beta;
877 
878  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
879  return EXIT_FAILURE;
880 
881  std::cout << "Testing inplace multiply-division-add on vector with GPU scalar (subtracting)..." << std::endl;
882  ublas_v2 = NumericT(3.1415) * ublas_v1;
883  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
884  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
885 
886  ublas_v1 += ublas_v1 * alpha - ublas_v2 / beta;
887  vcl_v1 += vcl_v1 * gpu_alpha - vcl_v2 / gpu_beta;
888 
889  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
890  return EXIT_FAILURE;
891 
892 
893 
894  std::cout << "Testing inplace division-add on vector with GPU scalar..." << std::endl;
895  ublas_v2 = NumericT(3.1415) * ublas_v1;
896  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
897  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
898 
899  ublas_v1 += ublas_v2 * alpha;
900  vcl_v1 += vcl_v2 * gpu_alpha;
901 
902  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
903  return EXIT_FAILURE;
904 
905 
906 
907  //
908  // multiply-subtract
909  //
910  std::cout << "Testing multiply-subtract on vector with CPU scalar (right)..." << std::endl;
911  for (size_t i=0; i < ublas_v1.size(); ++i)
912  ublas_v1(i) = NumericT(1.0) + random<NumericT>();
913  ublas_v2 = NumericT(3.1415) * ublas_v1;
914  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
915  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
916 
917  ublas_v1 = ublas_v1 - alpha * ublas_v2;
918  vcl_v1 = vcl_v1 - alpha * vcl_v2;
919 
920  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
921  return EXIT_FAILURE;
922 
923 
924  std::cout << "Testing multiply-subtract on vector with CPU scalar (left)..." << std::endl;
925  ublas_v2 = NumericT(3.1415) * ublas_v1;
926  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
927  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
928 
929  ublas_v1 = alpha * ublas_v1 - ublas_v2;
930  vcl_v1 = alpha * vcl_v1 - vcl_v2;
931 
932  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
933  return EXIT_FAILURE;
934 
935  std::cout << "Testing multiply-subtract on vector with CPU scalar (both)..." << std::endl;
936  ublas_v2 = NumericT(3.1415) * ublas_v1;
937  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
938  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
939 
940  ublas_v1 = alpha * ublas_v1 - beta * ublas_v2;
941  vcl_v1 = alpha * vcl_v1 - beta * vcl_v2;
942 
943  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
944  return EXIT_FAILURE;
945 
946 
947  std::cout << "Testing inplace multiply-subtract on vector with CPU scalar..." << std::endl;
948  ublas_v2 = NumericT(3.1415) * ublas_v1;
949  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
950  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
951 
952  ublas_v1 -= alpha * ublas_v2;
953  vcl_v1 -= alpha * vcl_v2;
954 
955  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
956  return EXIT_FAILURE;
957 
958 
959  std::cout << "Testing multiply-subtract on vector with GPU scalar (right)..." << std::endl;
960  ublas_v2 = NumericT(3.1415) * ublas_v1;
961  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
962  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
963 
964  ublas_v1 = ublas_v1 - alpha * ublas_v2;
965  vcl_v1 = vcl_v1 - gpu_alpha * vcl_v2;
966 
967  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
968  return EXIT_FAILURE;
969 
970  std::cout << "Testing multiply-subtract on vector with GPU scalar (left)..." << std::endl;
971  ublas_v2 = NumericT(3.1415) * ublas_v1;
972  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
973  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
974 
975  ublas_v1 = ublas_v1 - alpha * ublas_v2;
976  vcl_v1 = vcl_v1 - gpu_alpha * vcl_v2;
977 
978  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
979  return EXIT_FAILURE;
980 
981  std::cout << "Testing multiply-subtract on vector with GPU scalar (both)..." << std::endl;
982  ublas_v2 = NumericT(3.1415) * ublas_v1;
983  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
984  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
985 
986  ublas_v1 = alpha * ublas_v1 - beta * ublas_v2;
987  vcl_v1 = gpu_alpha * vcl_v1 - gpu_beta * vcl_v2;
988 
989  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
990  return EXIT_FAILURE;
991 
992  std::cout << "Testing inplace multiply-subtract on vector with GPU scalar (both, adding)..." << std::endl;
993  ublas_v2 = NumericT(3.1415) * ublas_v1;
994  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
995  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
996 
997  ublas_v1 -= alpha * ublas_v1 + beta * ublas_v2;
998  vcl_v1 -= gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
999 
1000  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1001  return EXIT_FAILURE;
1002 
1003  std::cout << "Testing inplace multiply-subtract on vector with GPU scalar (both, subtracting)..." << std::endl;
1004  ublas_v2 = NumericT(3.1415) * ublas_v1;
1005  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1006  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1007 
1008  ublas_v1 -= alpha * ublas_v1 - beta * ublas_v2;
1009  vcl_v1 -= gpu_alpha * vcl_v1 - gpu_beta * vcl_v2;
1010 
1011  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1012  return EXIT_FAILURE;
1013 
1014 
1015  std::cout << "Testing inplace multiply-subtract on vector with GPU scalar..." << std::endl;
1016  ublas_v2 = NumericT(3.1415) * ublas_v1;
1017  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1018  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1019 
1020  ublas_v1 -= alpha * ublas_v2;
1021  vcl_v1 -= gpu_alpha * vcl_v2;
1022 
1023  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1024  return EXIT_FAILURE;
1025 
1026 
1027 
1028  //
1029  // division-subtract
1030  //
1031  std::cout << "Testing division-subtract on vector with CPU scalar (right)..." << std::endl;
1032  for (size_t i=0; i < ublas_v1.size(); ++i)
1033  ublas_v1(i) = NumericT(1.0) + random<NumericT>();
1034  ublas_v2 = NumericT(3.1415) * ublas_v1;
1035  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1036  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1037 
1038  ublas_v1 = ublas_v1 - ublas_v2 / alpha;
1039  vcl_v1 = vcl_v1 - vcl_v2 / alpha;
1040 
1041  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1042  return EXIT_FAILURE;
1043 
1044 
1045  std::cout << "Testing division-subtract on vector with CPU scalar (left)..." << std::endl;
1046  ublas_v2 = NumericT(3.1415) * ublas_v1;
1047  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1048  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1049 
1050  ublas_v1 = ublas_v1 / alpha - ublas_v2;
1051  vcl_v1 = vcl_v1 / alpha - vcl_v2;
1052 
1053  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1054  return EXIT_FAILURE;
1055 
1056  std::cout << "Testing division-subtract on vector with CPU scalar (both)..." << std::endl;
1057  ublas_v2 = NumericT(3.1415) * ublas_v1;
1058  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1059  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1060 
1061  ublas_v1 = ublas_v1 / alpha - ublas_v2 / alpha;
1062  vcl_v1 = vcl_v1 / alpha - vcl_v2 / alpha;
1063 
1064  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1065  return EXIT_FAILURE;
1066 
1067 
1068  std::cout << "Testing inplace division-subtract on vector with CPU scalar..." << std::endl;
1069  ublas_v2 = NumericT(3.1415) * ublas_v1;
1070  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1071  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1072 
1073  ublas_v1 -= ublas_v2 / alpha;
1074  vcl_v1 -= vcl_v2 / alpha;
1075 
1076  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1077  return EXIT_FAILURE;
1078 
1079  std::cout << "Testing inplace division-subtract on vector with GPU scalar..." << std::endl;
1080  ublas_v2 = NumericT(3.1415) * 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  ublas_v1 -= ublas_v2 / alpha;
1085  vcl_v1 -= vcl_v2 / gpu_alpha;
1086 
1087  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1088  return EXIT_FAILURE;
1089 
1090 
1091  std::cout << "Testing division-subtract on vector with GPU scalar (right)..." << std::endl;
1092  ublas_v2 = NumericT(3.1415) * ublas_v1;
1093  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1094  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1095 
1096  ublas_v1 = ublas_v1 - ublas_v2 / alpha;
1097  vcl_v1 = vcl_v1 - vcl_v2 / gpu_alpha;
1098 
1099  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1100  return EXIT_FAILURE;
1101 
1102  std::cout << "Testing division-subtract on vector with GPU scalar (left)..." << std::endl;
1103  ublas_v2 = NumericT(3.1415) * ublas_v1;
1104  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1105  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1106 
1107  ublas_v1 = ublas_v1 - ublas_v2 / alpha;
1108  vcl_v1 = vcl_v1 - vcl_v2 / gpu_alpha;
1109 
1110  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1111  return EXIT_FAILURE;
1112 
1113  std::cout << "Testing division-subtract on vector with GPU scalar (both)..." << std::endl;
1114  ublas_v2 = NumericT(3.1415) * ublas_v1;
1115  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1116  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1117 
1118  ublas_v1 = ublas_v1 / alpha - ublas_v2 / beta;
1119  vcl_v1 = vcl_v1 / gpu_alpha - vcl_v2 / gpu_beta;
1120 
1121  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1122  return EXIT_FAILURE;
1123 
1124  std::cout << "Testing inplace division-subtract on vector with GPU scalar (both, adding)..." << std::endl;
1125  ublas_v2 = NumericT(3.1415) * ublas_v1;
1126  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1127  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1128 
1129  ublas_v1 -= ublas_v1 / alpha + ublas_v2 / beta;
1130  vcl_v1 -= vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
1131 
1132  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1133  return EXIT_FAILURE;
1134 
1135  std::cout << "Testing inplace division-subtract on vector with GPU scalar (both, subtracting)..." << std::endl;
1136  ublas_v2 = NumericT(3.1415) * ublas_v1;
1137  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1138  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1139 
1140  ublas_v1 -= ublas_v1 / alpha - ublas_v2 / beta;
1141  vcl_v1 -= vcl_v1 / gpu_alpha - vcl_v2 / gpu_beta;
1142 
1143  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1144  return EXIT_FAILURE;
1145 
1146  std::cout << "Testing multiply-division-subtract on vector with GPU scalar..." << std::endl;
1147  ublas_v2 = NumericT(3.1415) * ublas_v1;
1148  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1149  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1150 
1151  ublas_v1 = ublas_v1 * alpha - ublas_v2 / beta;
1152  vcl_v1 = vcl_v1 * gpu_alpha - vcl_v2 / gpu_beta;
1153 
1154  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1155  return EXIT_FAILURE;
1156 
1157  std::cout << "Testing division-multiply-subtract on vector with GPU scalar..." << std::endl;
1158  ublas_v2 = NumericT(3.1415) * ublas_v1;
1159  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1160  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1161 
1162  ublas_v1 = ublas_v1 / alpha - ublas_v2 * beta;
1163  vcl_v1 = vcl_v1 / gpu_alpha - vcl_v2 * gpu_beta;
1164 
1165  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1166  return EXIT_FAILURE;
1167 
1168  std::cout << "Testing inplace multiply-division-subtract on vector with GPU scalar (adding)..." << std::endl;
1169  ublas_v2 = NumericT(3.1415) * ublas_v1;
1170  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1171  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1172 
1173  ublas_v1 -= ublas_v1 * alpha + ublas_v2 / beta;
1174  vcl_v1 -= vcl_v1 * gpu_alpha + vcl_v2 / gpu_beta;
1175 
1176  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1177  return EXIT_FAILURE;
1178 
1179  std::cout << "Testing inplace division-multiply-subtract on vector with GPU scalar (adding)..." << std::endl;
1180  ublas_v2 = NumericT(3.1415) * ublas_v1;
1181  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1182  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1183 
1184  ublas_v1 -= ublas_v1 / alpha + ublas_v2 * beta;
1185  vcl_v1 -= vcl_v1 / gpu_alpha + vcl_v2 * gpu_beta;
1186 
1187  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1188  return EXIT_FAILURE;
1189 
1190  std::cout << "Testing inplace multiply-division-subtract on vector with GPU scalar (subtracting)..." << std::endl;
1191  ublas_v2 = NumericT(3.1415) * ublas_v1;
1192  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1193  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1194 
1195  ublas_v1 -= ublas_v1 * alpha - ublas_v2 / beta;
1196  vcl_v1 -= vcl_v1 * gpu_alpha - vcl_v2 / gpu_beta;
1197 
1198  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1199  return EXIT_FAILURE;
1200 
1201  std::cout << "Testing inplace division-multiply-subtract on vector with GPU scalar (subtracting)..." << std::endl;
1202  ublas_v2 = NumericT(3.1415) * ublas_v1;
1203  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1204  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1205 
1206  ublas_v1 -= ublas_v1 / alpha - ublas_v2 * beta;
1207  vcl_v1 -= vcl_v1 / gpu_alpha - vcl_v2 * gpu_beta;
1208 
1209  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1210  return EXIT_FAILURE;
1211 
1212 
1213  std::cout << "Testing inplace division-subtract on vector with GPU scalar..." << std::endl;
1214  ublas_v2 = NumericT(3.1415) * ublas_v1;
1215  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1216  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1217 
1218  ublas_v1 -= alpha * ublas_v2;
1219  vcl_v1 -= gpu_alpha * vcl_v2;
1220 
1221  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1222  return EXIT_FAILURE;
1223 
1224 
1225 
1226  //
1227  // More complicated expressions (for ensuring the operator overloads work correctly)
1228  //
1229  for (size_t i=0; i < ublas_v1.size(); ++i)
1230  ublas_v1(i) = NumericT(1.0) + random<NumericT>();
1231  ublas_v2 = NumericT(3.1415) * ublas_v1;
1232  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1233  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1234 
1235  std::cout << "Testing three vector additions..." << std::endl;
1236  ublas_v1 = ublas_v2 + ublas_v1 + ublas_v2;
1237  vcl_v1 = vcl_v2 + vcl_v1 + vcl_v2;
1238 
1239  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1240  return EXIT_FAILURE;
1241 
1242 
1243  ublas_v2 = NumericT(3.1415) * ublas_v1;
1244  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1245  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1246 
1247  std::cout << "Testing complicated vector expression with CPU scalar..." << std::endl;
1248  ublas_v1 = beta * (ublas_v1 - alpha * ublas_v2);
1249  vcl_v1 = beta * (vcl_v1 - alpha * vcl_v2);
1250 
1251  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1252  return EXIT_FAILURE;
1253 
1254  std::cout << "Testing complicated vector expression with GPU scalar..." << std::endl;
1255  ublas_v1 = beta * (ublas_v1 - alpha * ublas_v2);
1256  vcl_v1 = gpu_beta * (vcl_v1 - gpu_alpha * vcl_v2);
1257 
1258  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1259  return EXIT_FAILURE;
1260 
1261  // --------------------------------------------------------------------------
1262  ublas_v2 = NumericT(3.1415) * ublas_v1;
1263  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1264  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1265 
1266  std::cout << "Testing swap..." << std::endl;
1267  swap(ublas_v1, ublas_v2);
1268  swap(vcl_v1, vcl_v2);
1269 
1270  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1271  return EXIT_FAILURE;
1272 
1273  // --------------------------------------------------------------------------
1274  for (std::size_t i=0; i<ublas_v1.size(); ++i)
1275  {
1276  ublas_v1[i] = NumericT(1.0) + random<NumericT>();
1277  ublas_v2[i] = NumericT(5.0) + random<NumericT>();
1278  }
1279 
1280  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1281  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1282 
1283  std::cout << "Testing unary operator-..." << std::endl;
1284  ublas_v1 = - ublas_v2;
1285  vcl_v1 = - vcl_v2;
1286 
1287  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1288  return EXIT_FAILURE;
1289 
1290 
1291  std::cout << "Testing elementwise multiplication..." << std::endl;
1292  std::cout << " v1 = element_prod(v1, v2);" << std::endl;
1293  ublas_v1 = ublas::element_prod(ublas_v1, ublas_v2);
1294  vcl_v1 = viennacl::linalg::element_prod(vcl_v1, vcl_v2);
1295 
1296  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1297  return EXIT_FAILURE;
1298 
1299  std::cout << " v1 += element_prod(v1, v2);" << std::endl;
1300  ublas_v1 += ublas::element_prod(ublas_v1, ublas_v2);
1301  vcl_v1 += viennacl::linalg::element_prod(vcl_v1, vcl_v2);
1302 
1303  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1304  return EXIT_FAILURE;
1305 
1306  std::cout << " v1 -= element_prod(v1, v2);" << std::endl;
1307  ublas_v1 -= ublas::element_prod(ublas_v1, ublas_v2);
1308  vcl_v1 -= viennacl::linalg::element_prod(vcl_v1, vcl_v2);
1309 
1310  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1311  return EXIT_FAILURE;
1312 
1314  std::cout << " v1 = element_prod(v1 + v2, v2);" << std::endl;
1315  ublas_v1 = ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2);
1316  vcl_v1 = viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2);
1317 
1318  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1319  return EXIT_FAILURE;
1320 
1321  std::cout << " v1 += element_prod(v1 + v2, v2);" << std::endl;
1322  ublas_v1 += ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2);
1323  vcl_v1 += viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2);
1324 
1325  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1326  return EXIT_FAILURE;
1327 
1328  std::cout << " v1 -= element_prod(v1 + v2, v2);" << std::endl;
1329  ublas_v1 -= ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2);
1330  vcl_v1 -= viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2);
1331 
1332  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1333  return EXIT_FAILURE;
1334 
1336  std::cout << " v1 = element_prod(v1, v2 + v1);" << std::endl;
1337  ublas_v1 = ublas::element_prod(ublas_v1, ublas_v2 + ublas_v1);
1338  vcl_v1 = viennacl::linalg::element_prod(vcl_v1, vcl_v2 + vcl_v1);
1339 
1340  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1341  return EXIT_FAILURE;
1342 
1343  std::cout << " v1 += element_prod(v1, v2 + v1);" << std::endl;
1344  ublas_v1 += ublas::element_prod(ublas_v1, ublas_v2 + ublas_v1);
1345  vcl_v1 += viennacl::linalg::element_prod(vcl_v1, vcl_v2 + vcl_v1);
1346 
1347  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1348  return EXIT_FAILURE;
1349 
1350  std::cout << " v1 -= element_prod(v1, v2 + v1);" << std::endl;
1351  ublas_v1 -= ublas::element_prod(ublas_v1, ublas_v2 + ublas_v1);
1352  vcl_v1 -= viennacl::linalg::element_prod(vcl_v1, vcl_v2 + vcl_v1);
1353 
1354  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1355  return EXIT_FAILURE;
1356 
1358  std::cout << " v1 = element_prod(v1 + v2, v2 + v1);" << std::endl;
1359  ublas_v1 = ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1360  vcl_v1 = viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1361 
1362  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1363  return EXIT_FAILURE;
1364 
1365  std::cout << " v1 += element_prod(v1 + v2, v2 + v1);" << std::endl;
1366  ublas_v1 += ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1367  vcl_v1 += viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1368 
1369  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1370  return EXIT_FAILURE;
1371 
1372  std::cout << " v1 -= element_prod(v1 + v2, v2 + v1);" << std::endl;
1373  ublas_v1 -= ublas::element_prod(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1374  vcl_v1 -= viennacl::linalg::element_prod(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1375 
1376  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1377  return EXIT_FAILURE;
1378 
1379 
1380  std::cout << "Testing elementwise division..." << std::endl;
1381  for (std::size_t i=0; i<ublas_v1.size(); ++i)
1382  {
1383  ublas_v1[i] = NumericT(1.0) + random<NumericT>();
1384  ublas_v2[i] = NumericT(5.0) + random<NumericT>();
1385  }
1386 
1387  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1388  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1389 
1390  ublas_v1 = ublas::element_div(ublas_v1, ublas_v2);
1391  vcl_v1 = viennacl::linalg::element_div(vcl_v1, vcl_v2);
1392 
1393  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1394  return EXIT_FAILURE;
1395 
1396  ublas_v1 += ublas::element_div(ublas_v1, ublas_v2);
1397  vcl_v1 += viennacl::linalg::element_div(vcl_v1, vcl_v2);
1398 
1399  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1400  return EXIT_FAILURE;
1401 
1402  ublas_v1 -= ublas::element_div(ublas_v1, ublas_v2);
1403  vcl_v1 -= viennacl::linalg::element_div(vcl_v1, vcl_v2);
1404 
1405  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1406  return EXIT_FAILURE;
1407 
1409  ublas_v1 = ublas::element_div(ublas_v1 + ublas_v2, ublas_v2);
1410  vcl_v1 = viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2);
1411 
1412  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1413  return EXIT_FAILURE;
1414 
1415  ublas_v1 += ublas::element_div(ublas_v1 + ublas_v2, ublas_v2);
1416  vcl_v1 += viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2);
1417 
1418  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1419  return EXIT_FAILURE;
1420 
1421  ublas_v1 -= ublas::element_div(ublas_v1 + ublas_v2, ublas_v2);
1422  vcl_v1 -= viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2);
1423 
1424  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1425  return EXIT_FAILURE;
1426 
1428  ublas_v1 = ublas::element_div(ublas_v1, ublas_v2 + ublas_v1);
1429  vcl_v1 = viennacl::linalg::element_div(vcl_v1, vcl_v2 + vcl_v1);
1430 
1431  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1432  return EXIT_FAILURE;
1433 
1434  ublas_v1 += ublas::element_div(ublas_v1, ublas_v2 + ublas_v1);
1435  vcl_v1 += viennacl::linalg::element_div(vcl_v1, vcl_v2 + vcl_v1);
1436 
1437  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1438  return EXIT_FAILURE;
1439 
1440  ublas_v1 -= ublas::element_div(ublas_v1, ublas_v2 + ublas_v1);
1441  vcl_v1 -= viennacl::linalg::element_div(vcl_v1, vcl_v2 + vcl_v1);
1442 
1443  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1444  return EXIT_FAILURE;
1445 
1447  ublas_v1 = ublas::element_div(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1448  vcl_v1 = viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1449 
1450  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1451  return EXIT_FAILURE;
1452 
1453  ublas_v1 += ublas::element_div(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1454  vcl_v1 += viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1455 
1456  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1457  return EXIT_FAILURE;
1458 
1459  ublas_v1 -= ublas::element_div(ublas_v1 + ublas_v2, ublas_v2 + ublas_v1);
1460  vcl_v1 -= viennacl::linalg::element_div(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1461 
1462  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1463  return EXIT_FAILURE;
1464 
1465 
1466  std::cout << "Testing elementwise power function..." << std::endl;
1467  for (std::size_t i=0; i<ublas_v1.size(); ++i)
1468  {
1469  ublas_v1[i] = NumericT(1.1) + NumericT(0.5) * random<NumericT>();
1470  ublas_v2[i] = NumericT(1.1) + NumericT(0.5) * random<NumericT>();
1471  }
1472  UblasVectorType ublas_v3 = ublas_v1;
1473 
1474  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1475  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1476 
1477  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1478  ublas_v3[i] = std::pow(ublas_v1[i], ublas_v2[i]);
1479  vcl_v1 = viennacl::linalg::element_pow(vcl_v1, vcl_v2);
1480 
1481  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1482  {
1483  std::cerr << "** Failure in v1 = pow(v1, v2);" << std::endl;
1484  return EXIT_FAILURE;
1485  }
1486 
1487  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1488  ublas_v3 = ublas_v1;
1489  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1490  ublas_v3[i] += std::pow(ublas_v1[i], ublas_v2[i]);
1491  vcl_v1 += viennacl::linalg::element_pow(vcl_v1, vcl_v2);
1492 
1493  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1494  {
1495  std::cerr << "** Failure in v1 += pow(v1, v2);" << std::endl;
1496  return EXIT_FAILURE;
1497  }
1498 
1499  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1500  ublas_v3 = ublas_v1;
1501  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1502  ublas_v3[i] -= std::pow(ublas_v1[i], ublas_v2[i]);
1503  vcl_v1 -= viennacl::linalg::element_pow(vcl_v1, vcl_v2);
1504 
1505  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1506  {
1507  std::cerr << "** Failure in v1 -= pow(v1, v2);" << std::endl;
1508  return EXIT_FAILURE;
1509  }
1510 
1512  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1513  ublas_v3 = ublas_v1;
1514  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1515  ublas_v3[i] = std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i]);
1516  vcl_v1 = viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2);
1517 
1518  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1519  {
1520  std::cerr << "** Failure in v1 = pow(v1 + v2, v2);" << std::endl;
1521  return EXIT_FAILURE;
1522  }
1523 
1524  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1525  ublas_v3 = ublas_v1;
1526  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1527  ublas_v3[i] += std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i]);
1528  vcl_v1 += viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2);
1529 
1530  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1531  {
1532  std::cerr << "** Failure in v1 += pow(v1 + v2, v2);" << std::endl;
1533  return EXIT_FAILURE;
1534  }
1535 
1536  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1537  ublas_v3 = ublas_v1;
1538  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1539  ublas_v3[i] -= std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i]);
1540  vcl_v1 -= viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2);
1541 
1542  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1543  {
1544  std::cerr << "** Failure in v1 -= pow(v1 + v2, v2);" << std::endl;
1545  return EXIT_FAILURE;
1546  }
1547 
1549  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1550  ublas_v3 = ublas_v1;
1551  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1552  ublas_v3[i] = std::pow(ublas_v1[i], ublas_v2[i] + ublas_v1[i]);
1553  vcl_v1 = viennacl::linalg::element_pow(vcl_v1, vcl_v2 + vcl_v1);
1554 
1555  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1556  {
1557  std::cerr << "** Failure in v1 = pow(v1, v2 + v1);" << std::endl;
1558  return EXIT_FAILURE;
1559  }
1560 
1561  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1562  ublas_v3 = ublas_v1;
1563  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1564  ublas_v3[i] += std::pow(ublas_v1[i], ublas_v2[i] + ublas_v1[i]);
1565  vcl_v1 += viennacl::linalg::element_pow(vcl_v1, vcl_v2 + vcl_v1);
1566 
1567  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1568  {
1569  std::cerr << "** Failure in v1 += pow(v1, v2 + v1);" << std::endl;
1570  return EXIT_FAILURE;
1571  }
1572 
1573  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1574  ublas_v3 = ublas_v1;
1575  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1576  ublas_v3[i] -= std::pow(ublas_v1[i], ublas_v2[i] + ublas_v1[i]);
1577  vcl_v1 -= viennacl::linalg::element_pow(vcl_v1, vcl_v2 + vcl_v1);
1578 
1579  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1580  {
1581  std::cerr << "** Failure in v1 -= pow(v1, v2 + v1);" << std::endl;
1582  return EXIT_FAILURE;
1583  }
1584 
1586  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1587  ublas_v3 = ublas_v1;
1588  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1589  ublas_v3[i] = std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i] + ublas_v1[i]);
1590  vcl_v1 = viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1591 
1592  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1593  {
1594  std::cerr << "** Failure in v1 = pow(v1 + v2, v2 + v1);" << std::endl;
1595  return EXIT_FAILURE;
1596  }
1597 
1598  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1599  ublas_v3 = ublas_v1;
1600  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1601  ublas_v3[i] += std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i] + ublas_v1[i]);
1602  vcl_v1 += viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1603 
1604  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1605  {
1606  std::cerr << "** Failure in v1 += pow(v1 + v2, v2 + v1);" << std::endl;
1607  return EXIT_FAILURE;
1608  }
1609 
1610  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1611  ublas_v3 = ublas_v1;
1612  for (std::size_t i=0; i<ublas_v3.size(); ++i)
1613  ublas_v3[i] -= std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i] + ublas_v1[i]);
1614  vcl_v1 -= viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1615 
1616  if (check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1617  {
1618  std::cerr << "** Failure in v1 -= pow(v1 + v2, v2 + v1);" << std::endl;
1619  return EXIT_FAILURE;
1620  }
1621 
1622  std::cout << "Testing unary elementwise operations..." << std::endl;
1623  for (size_t i=0; i < ublas_v1.size(); ++i)
1624  ublas_v1(i) = random<NumericT>() / NumericT(4);
1625 
1626 #define GENERATE_UNARY_OP_TEST(FUNCNAME) \
1627  ublas_v2 = NumericT(3.1415) * ublas_v1; \
1628  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin()); \
1629  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin()); \
1630  \
1631  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1632  ublas_v1[i] = std::FUNCNAME(ublas_v2[i]); \
1633  vcl_v1 = viennacl::linalg::element_##FUNCNAME(vcl_v2); \
1634  \
1635  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1636  { \
1637  std::cout << "Failure at v1 = " << #FUNCNAME << "(v2)" << std::endl; \
1638  return EXIT_FAILURE; \
1639  } \
1640  \
1641  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1642  ublas_v1[i] = std::FUNCNAME(ublas_v1[i] + ublas_v2[i]); \
1643  vcl_v1 = viennacl::linalg::element_##FUNCNAME(vcl_v1 + vcl_v2); \
1644  \
1645  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1646  { \
1647  std::cout << "Failure at v1 = " << #FUNCNAME << "(v1 + v2)" << std::endl; \
1648  return EXIT_FAILURE; \
1649  } \
1650  \
1651  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1652  ublas_v1[i] += std::FUNCNAME(ublas_v1[i]); \
1653  vcl_v1 += viennacl::linalg::element_##FUNCNAME(vcl_v1); \
1654  \
1655  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1656  { \
1657  std::cout << "Failure at v1 += " << #FUNCNAME << "(v2)" << std::endl; \
1658  return EXIT_FAILURE; \
1659  } \
1660  \
1661  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1662  ublas_v1[i] += std::FUNCNAME(ublas_v1[i] + ublas_v2[i]); \
1663  vcl_v1 += viennacl::linalg::element_##FUNCNAME(vcl_v1 + vcl_v2); \
1664  \
1665  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1666  { \
1667  std::cout << "Failure at v1 += " << #FUNCNAME << "(v1 + v2)" << std::endl; \
1668  return EXIT_FAILURE; \
1669  } \
1670  \
1671  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1672  ublas_v1[i] -= std::FUNCNAME(ublas_v2[i]); \
1673  vcl_v1 -= viennacl::linalg::element_##FUNCNAME(vcl_v2); \
1674  \
1675  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1676  { \
1677  std::cout << "Failure at v1 -= " << #FUNCNAME << "(v2)" << std::endl; \
1678  return EXIT_FAILURE; \
1679  } \
1680  \
1681  for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1682  ublas_v1[i] -= std::FUNCNAME(ublas_v1[i] + ublas_v2[i]); \
1683  vcl_v1 -= viennacl::linalg::element_##FUNCNAME(vcl_v1 + vcl_v2); \
1684  \
1685  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1686  { \
1687  std::cout << "Failure at v1 -= " << #FUNCNAME << "(v1 + v2)" << std::endl; \
1688  return EXIT_FAILURE; \
1689  } \
1690 
1692  GENERATE_UNARY_OP_TEST(cosh);
1693  for (size_t i=0; i < ublas_v1.size(); ++i)
1694  ublas_v1(i) = random<NumericT>() / NumericT(4);
1696  GENERATE_UNARY_OP_TEST(floor);
1697  GENERATE_UNARY_OP_TEST(fabs);
1699  GENERATE_UNARY_OP_TEST(log10);
1701  GENERATE_UNARY_OP_TEST(sinh);
1702  GENERATE_UNARY_OP_TEST(fabs);
1703  //GENERATE_UNARY_OP_TEST(abs); //OpenCL allows abs on integers only
1704  GENERATE_UNARY_OP_TEST(sqrt);
1706  GENERATE_UNARY_OP_TEST(tanh);
1707 
1708  // --------------------------------------------------------------------------
1709  ublas_v2 = NumericT(3.1415) * ublas_v1;
1710  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1711  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1712 
1713  std::cout << "Testing another complicated vector expression with CPU scalars..." << std::endl;
1714  ublas_v1 = ublas_v2 / alpha + beta * (ublas_v1 - alpha*ublas_v2);
1715  vcl_v1 = vcl_v2 / alpha + beta * (vcl_v1 - alpha*vcl_v2);
1716 
1717  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1718  return EXIT_FAILURE;
1719 
1720  std::cout << "Testing another complicated vector expression with GPU scalars..." << std::endl;
1721  ublas_v2 = NumericT(3.1415) * ublas_v1;
1722  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1723  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1724 
1725  ublas_v1 = ublas_v2 / alpha + beta * (ublas_v1 - alpha*ublas_v2);
1726  vcl_v1 = vcl_v2 / gpu_alpha + gpu_beta * (vcl_v1 - gpu_alpha*vcl_v2);
1727 
1728  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1729  return EXIT_FAILURE;
1730 
1731 
1732  std::cout << "Testing lenghty sum of scaled vectors..." << std::endl;
1733  ublas_v2 = NumericT(3.1415) * ublas_v1;
1734  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1735  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1736 
1737  ublas_v1 = ublas_v2 / alpha + beta * ublas_v1 - alpha * ublas_v2 + beta * ublas_v1 - alpha * ublas_v1;
1738  vcl_v1 = vcl_v2 / gpu_alpha + gpu_beta * vcl_v1 - alpha * vcl_v2 + beta * vcl_v1 - alpha * vcl_v1;
1739 
1740  if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1741  return EXIT_FAILURE;
1742 
1743  // --------------------------------------------------------------------------
1744  return retval;
1745 }
1746 
1747 
1748 template< typename NumericT, typename Epsilon >
1749 int test(Epsilon const& epsilon)
1750 {
1751  int retval = EXIT_SUCCESS;
1752  std::size_t size = 24656;
1753 
1754  std::cout << "Running tests for vector of size " << size << std::endl;
1755 
1756  //
1757  // Set up UBLAS objects
1758  //
1759  ublas::vector<NumericT> ublas_full_vec(size);
1760  ublas::vector<NumericT> ublas_full_vec2(ublas_full_vec.size());
1761 
1762  for (std::size_t i=0; i<ublas_full_vec.size(); ++i)
1763  {
1764  ublas_full_vec[i] = NumericT(1.0) + random<NumericT>();
1765  ublas_full_vec2[i] = NumericT(1.0) + random<NumericT>();
1766  }
1767 
1768  ublas::range r1( ublas_full_vec.size() / 4, 2 * ublas_full_vec.size() / 4);
1769  ublas::range r2(2 * ublas_full_vec2.size() / 4, 3 * ublas_full_vec2.size() / 4);
1770  ublas::vector_range< ublas::vector<NumericT> > ublas_range_vec(ublas_full_vec, r1);
1771  ublas::vector_range< ublas::vector<NumericT> > ublas_range_vec2(ublas_full_vec2, r2);
1772 
1773  ublas::slice s1( ublas_full_vec.size() / 4, 3, ublas_full_vec.size() / 4);
1774  ublas::slice s2(2 * ublas_full_vec2.size() / 4, 2, ublas_full_vec2.size() / 4);
1775  ublas::vector_slice< ublas::vector<NumericT> > ublas_slice_vec(ublas_full_vec, s1);
1776  ublas::vector_slice< ublas::vector<NumericT> > ublas_slice_vec2(ublas_full_vec2, s2);
1777 
1778  //
1779  // Set up ViennaCL objects
1780  //
1781  viennacl::vector<NumericT> vcl_full_vec(ublas_full_vec.size());
1782  viennacl::vector<NumericT> vcl_full_vec2(ublas_full_vec2.size());
1783 
1784  viennacl::fast_copy(ublas_full_vec.begin(), ublas_full_vec.end(), vcl_full_vec.begin());
1785  viennacl::copy(ublas_full_vec2.begin(), ublas_full_vec2.end(), vcl_full_vec2.begin());
1786 
1787  viennacl::range vcl_r1( vcl_full_vec.size() / 4, 2 * vcl_full_vec.size() / 4);
1788  viennacl::range vcl_r2(2 * vcl_full_vec2.size() / 4, 3 * vcl_full_vec2.size() / 4);
1789  viennacl::vector_range< viennacl::vector<NumericT> > vcl_range_vec(vcl_full_vec, vcl_r1);
1790  viennacl::vector_range< viennacl::vector<NumericT> > vcl_range_vec2(vcl_full_vec2, vcl_r2);
1791 
1792  {
1793  viennacl::vector<NumericT> vcl_short_vec(vcl_range_vec);
1794  viennacl::vector<NumericT> vcl_short_vec2 = vcl_range_vec2;
1795 
1796  ublas::vector<NumericT> ublas_short_vec(ublas_range_vec);
1797  ublas::vector<NumericT> ublas_short_vec2(ublas_range_vec2);
1798 
1799  std::cout << "Testing creation of vectors from range..." << std::endl;
1800  if (check(ublas_short_vec, vcl_short_vec, epsilon) != EXIT_SUCCESS)
1801  return EXIT_FAILURE;
1802  if (check(ublas_short_vec2, vcl_short_vec2, epsilon) != EXIT_SUCCESS)
1803  return EXIT_FAILURE;
1804  }
1805 
1806  viennacl::slice vcl_s1( vcl_full_vec.size() / 4, 3, vcl_full_vec.size() / 4);
1807  viennacl::slice vcl_s2(2 * vcl_full_vec2.size() / 4, 2, vcl_full_vec2.size() / 4);
1808  viennacl::vector_slice< viennacl::vector<NumericT> > vcl_slice_vec(vcl_full_vec, vcl_s1);
1809  viennacl::vector_slice< viennacl::vector<NumericT> > vcl_slice_vec2(vcl_full_vec2, vcl_s2);
1810 
1811  viennacl::vector<NumericT> vcl_short_vec(vcl_slice_vec);
1812  viennacl::vector<NumericT> vcl_short_vec2 = vcl_slice_vec2;
1813 
1814  ublas::vector<NumericT> ublas_short_vec(ublas_slice_vec);
1815  ublas::vector<NumericT> ublas_short_vec2(ublas_slice_vec2);
1816 
1817  std::cout << "Testing creation of vectors from slice..." << std::endl;
1818  if (check(ublas_short_vec, vcl_short_vec, epsilon) != EXIT_SUCCESS)
1819  return EXIT_FAILURE;
1820  if (check(ublas_short_vec2, vcl_short_vec2, epsilon) != EXIT_SUCCESS)
1821  return EXIT_FAILURE;
1822 
1823 
1824  //
1825  // Now start running tests for vectors, ranges and slices:
1826  //
1827 
1828  std::cout << " ** vcl_v1 = vector, vcl_v2 = vector **" << std::endl;
1829  retval = test<NumericT>(epsilon,
1830  ublas_short_vec, ublas_short_vec2,
1831  vcl_short_vec, vcl_short_vec2);
1832  if (retval != EXIT_SUCCESS)
1833  return EXIT_FAILURE;
1834 
1835  std::cout << " ** vcl_v1 = vector, vcl_v2 = range **" << std::endl;
1836  retval = test<NumericT>(epsilon,
1837  ublas_short_vec, ublas_short_vec2,
1838  vcl_short_vec, vcl_range_vec2);
1839  if (retval != EXIT_SUCCESS)
1840  return EXIT_FAILURE;
1841 
1842  std::cout << " ** vcl_v1 = vector, vcl_v2 = slice **" << std::endl;
1843  retval = test<NumericT>(epsilon,
1844  ublas_short_vec, ublas_short_vec2,
1845  vcl_short_vec, vcl_slice_vec2);
1846  if (retval != EXIT_SUCCESS)
1847  return EXIT_FAILURE;
1848 
1850 
1851  std::cout << " ** vcl_v1 = range, vcl_v2 = vector **" << std::endl;
1852  retval = test<NumericT>(epsilon,
1853  ublas_short_vec, ublas_short_vec2,
1854  vcl_range_vec, vcl_short_vec2);
1855  if (retval != EXIT_SUCCESS)
1856  return EXIT_FAILURE;
1857 
1858  std::cout << " ** vcl_v1 = range, vcl_v2 = range **" << std::endl;
1859  retval = test<NumericT>(epsilon,
1860  ublas_short_vec, ublas_short_vec2,
1861  vcl_range_vec, vcl_range_vec2);
1862  if (retval != EXIT_SUCCESS)
1863  return EXIT_FAILURE;
1864 
1865  std::cout << " ** vcl_v1 = range, vcl_v2 = slice **" << std::endl;
1866  retval = test<NumericT>(epsilon,
1867  ublas_short_vec, ublas_short_vec2,
1868  vcl_range_vec, vcl_slice_vec2);
1869  if (retval != EXIT_SUCCESS)
1870  return EXIT_FAILURE;
1871 
1873 
1874  std::cout << " ** vcl_v1 = slice, vcl_v2 = vector **" << std::endl;
1875  retval = test<NumericT>(epsilon,
1876  ublas_short_vec, ublas_short_vec2,
1877  vcl_slice_vec, vcl_short_vec2);
1878  if (retval != EXIT_SUCCESS)
1879  return EXIT_FAILURE;
1880 
1881  std::cout << " ** vcl_v1 = slice, vcl_v2 = range **" << std::endl;
1882  retval = test<NumericT>(epsilon,
1883  ublas_short_vec, ublas_short_vec2,
1884  vcl_slice_vec, vcl_range_vec2);
1885  if (retval != EXIT_SUCCESS)
1886  return EXIT_FAILURE;
1887 
1888  std::cout << " ** vcl_v1 = slice, vcl_v2 = slice **" << std::endl;
1889  retval = test<NumericT>(epsilon,
1890  ublas_short_vec, ublas_short_vec2,
1891  vcl_slice_vec, vcl_slice_vec2);
1892  if (retval != EXIT_SUCCESS)
1893  return EXIT_FAILURE;
1894 
1895  return EXIT_SUCCESS;
1896 }
1897 
1898 
1899 //
1900 // -------------------------------------------------------------
1901 //
1902 int main()
1903 {
1904  std::cout << std::endl;
1905  std::cout << "----------------------------------------------" << std::endl;
1906  std::cout << "----------------------------------------------" << std::endl;
1907  std::cout << "## Test :: Vector" << std::endl;
1908  std::cout << "----------------------------------------------" << std::endl;
1909  std::cout << "----------------------------------------------" << std::endl;
1910  std::cout << std::endl;
1911 
1912  int retval = EXIT_SUCCESS;
1913 
1914  std::cout << std::endl;
1915  std::cout << "----------------------------------------------" << std::endl;
1916  std::cout << std::endl;
1917  {
1918  typedef float NumericT;
1919  NumericT epsilon = static_cast<NumericT>(1.0E-2);
1920  std::cout << "# Testing setup:" << std::endl;
1921  std::cout << " eps: " << epsilon << std::endl;
1922  std::cout << " numeric: float" << std::endl;
1923  retval = test<NumericT>(epsilon);
1924  if ( retval == EXIT_SUCCESS )
1925  std::cout << "# Test passed" << std::endl;
1926  else
1927  return retval;
1928  }
1929  std::cout << std::endl;
1930  std::cout << "----------------------------------------------" << std::endl;
1931  std::cout << std::endl;
1932  #ifdef VIENNACL_WITH_OPENCL
1934  #endif
1935  {
1936  {
1937  typedef double NumericT;
1938  NumericT epsilon = 1.0E-10;
1939  std::cout << "# Testing setup:" << std::endl;
1940  std::cout << " eps: " << epsilon << std::endl;
1941  std::cout << " numeric: double" << std::endl;
1942  retval = test<NumericT>(epsilon);
1943  if ( retval == EXIT_SUCCESS )
1944  std::cout << "# Test passed" << std::endl;
1945  else
1946  return retval;
1947  }
1948  std::cout << std::endl;
1949  std::cout << "----------------------------------------------" << std::endl;
1950  std::cout << std::endl;
1951  }
1952 
1953  std::cout << std::endl;
1954  std::cout << "------- Test completed --------" << std::endl;
1955  std::cout << std::endl;
1956 
1957 
1958  return retval;
1959 }
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)
T norm_2(std::vector< T, A > const &v1)
Definition: norm_2.hpp:86
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
ScalarType diff(ScalarType const &s1, ScalarType const &s2)
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
#define GENERATE_UNARY_OP_TEST(FUNCNAME)
viennacl::scalar< int > s2
viennacl::scalar< float > s1
T max(const T &lhs, const T &rhs)
Maximum.
Definition: util.hpp:59
viennacl::ocl::device const & current_device()
Convenience function for returning the active device in the current context.
Definition: backend.hpp:351
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...
basic_range range
Definition: forwards.h:423
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 check(T1 const &t1, T2 const &t2, double epsilon)
Class for representing strided subvectors of a bigger vector x.
Definition: forwards.h:436
bool double_support() const
ViennaCL convenience function: Returns true if the device supports double precision.
Definition: device.hpp:956
Proxy classes for vectors.
int main()
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
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)
int test(Epsilon const &epsilon, UblasVectorType &ublas_v1, UblasVectorType &ublas_v2, ViennaCLVectorType1 &vcl_v1, ViennaCLVectorType2 &vcl_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)