ViennaCL - The Vienna Computing Library  1.6.1
Free open-source GPU-accelerated linear algebra and solver library.
matrix_int.hpp
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 #define VIENNACL_WITH_UBLAS
19 //#define NDEBUG
20 //#define VIENNACL_BUILD_INFO
21 
22 #include <utility>
23 #include <iostream>
24 #include <fstream>
25 #include <string>
26 #include <cmath>
27 #include <algorithm>
28 #include <stdio.h>
29 #include <time.h>
30 //#include "../benchmarks/benchmark-utils.hpp"
31 #include "viennacl/scalar.hpp"
32 #include "viennacl/matrix.hpp"
33 #include "viennacl/linalg/prod.hpp"
34 /*#include "viennacl/compressed_matrix.hpp"
35 #include "viennacl/linalg/cg.hpp"
36 #include "viennacl/linalg/inner_prod.hpp"
37 #include "viennacl/linalg/ilu.hpp"
38 #include "viennacl/linalg/norm_2.hpp"
39 #include "viennacl/io/matrix_market.hpp"*/
42 #include "boost/numeric/ublas/vector.hpp"
43 #include "boost/numeric/ublas/matrix.hpp"
44 #include "boost/numeric/ublas/matrix_proxy.hpp"
45 #include "boost/numeric/ublas/vector_proxy.hpp"
46 #include "boost/numeric/ublas/io.hpp"
47 
48 template<typename MatrixType, typename VCLMatrixType>
49 bool check_for_equality(MatrixType const & ublas_A, VCLMatrixType const & vcl_A)
50 {
51  typedef typename MatrixType::value_type value_type;
52 
53  boost::numeric::ublas::matrix<value_type> vcl_A_cpu(vcl_A.size1(), vcl_A.size2());
54  viennacl::backend::finish(); //workaround for a bug in APP SDK 2.7 on Trinity APUs (with Catalyst 12.8)
55  viennacl::copy(vcl_A, vcl_A_cpu);
56 
57  for (std::size_t i=0; i<ublas_A.size1(); ++i)
58  {
59  for (std::size_t j=0; j<ublas_A.size2(); ++j)
60  {
61  if (ublas_A(i,j) != vcl_A_cpu(i,j))
62  {
63  std::cout << "Error at index (" << i << ", " << j << "): " << ublas_A(i,j) << " vs " << vcl_A_cpu(i,j) << std::endl;
64  std::cout << std::endl << "TEST failed!" << std::endl;
65  return false;
66  }
67  }
68  }
69 
70  std::cout << "PASSED!" << std::endl;
71  return true;
72 }
73 
74 
75 
76 
77 template<typename UBLASMatrixType,
78  typename ViennaCLMatrixType1, typename ViennaCLMatrixType2, typename ViennaCLMatrixType3>
79 int run_test(UBLASMatrixType & ublas_A, UBLASMatrixType & ublas_B, UBLASMatrixType & ublas_C,
80  ViennaCLMatrixType1 & vcl_A, ViennaCLMatrixType2 & vcl_B, ViennaCLMatrixType3 vcl_C)
81 {
82 
84 
85  cpu_value_type alpha = 3;
86  viennacl::scalar<cpu_value_type> gpu_alpha = alpha;
87 
88  cpu_value_type beta = 2;
89  viennacl::scalar<cpu_value_type> gpu_beta = beta;
90 
91 
92  //
93  // Initializer:
94  //
95  std::cout << "Checking for zero_matrix initializer..." << std::endl;
96  ublas_A = boost::numeric::ublas::zero_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2());
97  vcl_A = viennacl::zero_matrix<cpu_value_type>(vcl_A.size1(), vcl_A.size2());
98  if (!check_for_equality(ublas_A, vcl_A))
99  return EXIT_FAILURE;
100 
101  std::cout << "Checking for scalar_matrix initializer..." << std::endl;
102  ublas_A = boost::numeric::ublas::scalar_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2(), alpha);
103  vcl_A = viennacl::scalar_matrix<cpu_value_type>(vcl_A.size1(), vcl_A.size2(), alpha);
104  if (!check_for_equality(ublas_A, vcl_A))
105  return EXIT_FAILURE;
106 
107  ublas_A = boost::numeric::ublas::scalar_matrix<cpu_value_type>(ublas_A.size1(), ublas_A.size2(), gpu_beta);
108  vcl_A = viennacl::scalar_matrix<cpu_value_type>( vcl_A.size1(), vcl_A.size2(), gpu_beta);
109  if (!check_for_equality(ublas_A, vcl_A))
110  return EXIT_FAILURE;
111 
112  /*
113  std::cout << "Checking for identity initializer..." << std::endl;
114  ublas_A = boost::numeric::ublas::identity_matrix<cpu_value_type>(ublas_A.size1());
115  vcl_A = viennacl::identity_matrix<cpu_value_type>(vcl_A.size1());
116  if (!check_for_equality(ublas_A, vcl_A))
117  return EXIT_FAILURE; */
118 
119 
120  std::cout << std::endl;
121  //std::cout << "//" << std::endl;
122  //std::cout << "////////// Test: Assignments //////////" << std::endl;
123  //std::cout << "//" << std::endl;
124 
125  if (!check_for_equality(ublas_B, vcl_B))
126  return EXIT_FAILURE;
127 
128  std::cout << "Testing matrix assignment... ";
129  //std::cout << ublas_B(0,0) << " vs. " << vcl_B(0,0) << std::endl;
130  ublas_A = ublas_B;
131  vcl_A = vcl_B;
132  if (!check_for_equality(ublas_A, vcl_A))
133  return EXIT_FAILURE;
134 
135 
136 
137  //std::cout << std::endl;
138  //std::cout << "//" << std::endl;
139  //std::cout << "////////// Test 1: Copy to GPU //////////" << std::endl;
140  //std::cout << "//" << std::endl;
141 
142  ublas_A = ublas_B;
143  viennacl::copy(ublas_B, vcl_A);
144  std::cout << "Testing upper left copy to GPU... ";
145  if (!check_for_equality(ublas_A, vcl_A))
146  return EXIT_FAILURE;
147 
148 
149  ublas_C = ublas_B;
150  viennacl::copy(ublas_B, vcl_C);
151  std::cout << "Testing lower right copy to GPU... ";
152  if (!check_for_equality(ublas_C, vcl_C))
153  return EXIT_FAILURE;
154 
155 
156  //std::cout << std::endl;
157  //std::cout << "//" << std::endl;
158  //std::cout << "////////// Test 2: Copy from GPU //////////" << std::endl;
159  //std::cout << "//" << std::endl;
160 
161  std::cout << "Testing upper left copy to A... ";
162  if (!check_for_equality(ublas_A, vcl_A))
163  return EXIT_FAILURE;
164 
165  std::cout << "Testing lower right copy to C... ";
166  if (!check_for_equality(ublas_C, vcl_C))
167  return EXIT_FAILURE;
168 
169 
170 
171  //std::cout << "//" << std::endl;
172  //std::cout << "////////// Test 3: Addition //////////" << std::endl;
173  //std::cout << "//" << std::endl;
174  viennacl::copy(ublas_C, vcl_C);
175 
176  std::cout << "Inplace add: ";
177  ublas_C += ublas_C;
178  vcl_C += vcl_C;
179 
180  if (!check_for_equality(ublas_C, vcl_C))
181  return EXIT_FAILURE;
182 
183  std::cout << "Scaled inplace add: ";
184  ublas_C += beta * ublas_A;
185  vcl_C += gpu_beta * vcl_A;
186 
187  if (!check_for_equality(ublas_C, vcl_C))
188  return EXIT_FAILURE;
189 
190  std::cout << "Add: ";
191  ublas_C = ublas_A + ublas_B;
192  vcl_C = vcl_A + vcl_B;
193 
194  if (!check_for_equality(ublas_C, vcl_C))
195  return EXIT_FAILURE;
196 
197  std::cout << "Add with flipsign: ";
198  ublas_C = - ublas_A + ublas_B;
199  vcl_C = - vcl_A + vcl_B;
200 
201  if (!check_for_equality(ublas_C, vcl_C))
202  return EXIT_FAILURE;
203 
204 
205  std::cout << "Scaled add (left): ";
206  ublas_C = alpha * ublas_A + ublas_B;
207  vcl_C = alpha * vcl_A + vcl_B;
208 
209  if (!check_for_equality(ublas_C, vcl_C))
210  return EXIT_FAILURE;
211 
212  std::cout << "Scaled add (left): ";
213  vcl_C = gpu_alpha * vcl_A + vcl_B;
214  if (!check_for_equality(ublas_C, vcl_C))
215  return EXIT_FAILURE;
216 
217 
218  std::cout << "Scaled add (right): ";
219  ublas_C = ublas_A + beta * ublas_B;
220  vcl_C = vcl_A + beta * vcl_B;
221 
222  if (!check_for_equality(ublas_C, vcl_C))
223  return EXIT_FAILURE;
224 
225  std::cout << "Scaled add (right): ";
226  vcl_C = vcl_A + gpu_beta * vcl_B;
227  if (!check_for_equality(ublas_C, vcl_C))
228  return EXIT_FAILURE;
229 
230 
231 
232  std::cout << "Scaled add (both): ";
233  ublas_C = alpha * ublas_A + beta * ublas_B;
234  vcl_C = alpha * vcl_A + beta * vcl_B;
235 
236  if (!check_for_equality(ublas_C, vcl_C))
237  return EXIT_FAILURE;
238 
239  std::cout << "Scaled add (both): ";
240  vcl_C = gpu_alpha * vcl_A + gpu_beta * vcl_B;
241  if (!check_for_equality(ublas_C, vcl_C))
242  return EXIT_FAILURE;
243 
244  //std::cout << "//" << std::endl;
245  //std::cout << "////////// Test 4: Subtraction //////////" << std::endl;
246  //std::cout << "//" << std::endl;
247  viennacl::copy(ublas_C, vcl_C);
248 
249  std::cout << "Inplace sub: ";
250  ublas_C -= ublas_B;
251  vcl_C -= vcl_B;
252 
253  if (!check_for_equality(ublas_C, vcl_C))
254  return EXIT_FAILURE;
255 
256  std::cout << "Scaled Inplace sub: ";
257  ublas_C -= alpha * ublas_B;
258  vcl_C -= alpha * vcl_B;
259 
260  if (!check_for_equality(ublas_C, vcl_C))
261  return EXIT_FAILURE;
262 
263 
264 
265 
266  std::cout << "Sub: ";
267  ublas_C = ublas_A - ublas_B;
268  vcl_C = vcl_A - vcl_B;
269 
270  if (!check_for_equality(ublas_C, vcl_C))
271  return EXIT_FAILURE;
272 
273  std::cout << "Scaled sub (left): ";
274  ublas_B = alpha * ublas_A - ublas_C;
275  vcl_B = alpha * vcl_A - vcl_C;
276 
277  if (!check_for_equality(ublas_B, vcl_B))
278  return EXIT_FAILURE;
279 
280  std::cout << "Scaled sub (left): ";
281  vcl_B = gpu_alpha * vcl_A - vcl_C;
282  if (!check_for_equality(ublas_B, vcl_B))
283  return EXIT_FAILURE;
284 
285 
286  std::cout << "Scaled sub (right): ";
287  ublas_B = ublas_A - beta * ublas_C;
288  vcl_B = vcl_A - vcl_C * beta;
289 
290  if (!check_for_equality(ublas_B, vcl_B))
291  return EXIT_FAILURE;
292 
293  std::cout << "Scaled sub (right): ";
294  vcl_B = vcl_A - vcl_C * gpu_beta;
295  if (!check_for_equality(ublas_B, vcl_B))
296  return EXIT_FAILURE;
297 
298 
299  std::cout << "Scaled sub (both): ";
300  ublas_B = alpha * ublas_A - beta * ublas_C;
301  vcl_B = alpha * vcl_A - vcl_C * beta;
302 
303  if (!check_for_equality(ublas_B, vcl_B))
304  return EXIT_FAILURE;
305 
306  std::cout << "Scaled sub (both): ";
307  vcl_B = gpu_alpha * vcl_A - vcl_C * gpu_beta;
308  if (!check_for_equality(ublas_B, vcl_B))
309  return EXIT_FAILURE;
310 
311 
312  std::cout << "Unary operator-: ";
313  ublas_C = - ublas_A;
314  vcl_C = - vcl_A;
315 
316  if (!check_for_equality(ublas_C, vcl_C))
317  return EXIT_FAILURE;
318 
319 
320 
321  //std::cout << "//" << std::endl;
322  //std::cout << "////////// Test 5: Scaling //////////" << std::endl;
323  //std::cout << "//" << std::endl;
324  viennacl::copy(ublas_A, vcl_A);
325 
326  std::cout << "Multiplication with CPU scalar: ";
327  ublas_A *= alpha;
328  vcl_A *= alpha;
329 
330  if (!check_for_equality(ublas_A, vcl_A))
331  return EXIT_FAILURE;
332 
333  std::cout << "Multiplication with GPU scalar: ";
334  ublas_A *= beta;
335  vcl_A *= gpu_beta;
336 
337  if (!check_for_equality(ublas_A, vcl_A))
338  return EXIT_FAILURE;
339 
340 
341  std::cout << "Division with CPU scalar: ";
342  ublas_A /= alpha;
343  vcl_A /= alpha;
344 
345  if (!check_for_equality(ublas_A, vcl_A))
346  return EXIT_FAILURE;
347 
348  std::cout << "Division with GPU scalar: ";
349  ublas_A /= beta;
350  vcl_A /= gpu_beta;
351 
352  if (!check_for_equality(ublas_A, vcl_A))
353  return EXIT_FAILURE;
354 
355 
356 
357  std::cout << "Testing elementwise multiplication..." << std::endl;
358  ublas_B = boost::numeric::ublas::scalar_matrix<cpu_value_type>(ublas_B.size1(), ublas_B.size2(), 2);
359  ublas_A = 3 * ublas_B;
360  viennacl::copy(ublas_A, vcl_A);
361  viennacl::copy(ublas_B, vcl_B);
362  viennacl::copy(ublas_B, vcl_B);
363  ublas_A = boost::numeric::ublas::element_prod(ublas_A, ublas_B);
364  vcl_A = viennacl::linalg::element_prod(vcl_A, vcl_B);
365 
366  if (!check_for_equality(ublas_A, vcl_A))
367  return EXIT_FAILURE;
368 
369  ublas_A += boost::numeric::ublas::element_prod(ublas_A, ublas_B);
370  vcl_A += viennacl::linalg::element_prod(vcl_A, vcl_B);
371 
372  if (!check_for_equality(ublas_A, vcl_A))
373  return EXIT_FAILURE;
374 
375  ublas_A -= boost::numeric::ublas::element_prod(ublas_A, ublas_B);
376  vcl_A -= viennacl::linalg::element_prod(vcl_A, vcl_B);
377 
378  if (!check_for_equality(ublas_A, vcl_A))
379  return EXIT_FAILURE;
380 
382  ublas_A = boost::numeric::ublas::element_prod(ublas_A + ublas_B, ublas_B);
383  vcl_A = viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B);
384 
385  if (!check_for_equality(ublas_A, vcl_A))
386  return EXIT_FAILURE;
387 
388  ublas_A += boost::numeric::ublas::element_prod(ublas_A + ublas_B, ublas_B);
389  vcl_A += viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B);
390 
391  if (!check_for_equality(ublas_A, vcl_A))
392  return EXIT_FAILURE;
393 
394  ublas_A -= boost::numeric::ublas::element_prod(ublas_A + ublas_B, ublas_B);
395  vcl_A -= viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B);
396 
397  if (!check_for_equality(ublas_A, vcl_A))
398  return EXIT_FAILURE;
399 
401  ublas_A = boost::numeric::ublas::element_prod(ublas_A, ublas_B + ublas_A);
402  vcl_A = viennacl::linalg::element_prod(vcl_A, vcl_B + vcl_A);
403 
404  if (!check_for_equality(ublas_A, vcl_A))
405  return EXIT_FAILURE;
406 
407  ublas_A += boost::numeric::ublas::element_prod(ublas_A, ublas_B + ublas_A);
408  vcl_A += viennacl::linalg::element_prod(vcl_A, vcl_B + vcl_A);
409 
410  if (!check_for_equality(ublas_A, vcl_A))
411  return EXIT_FAILURE;
412 
413  ublas_A -= boost::numeric::ublas::element_prod(ublas_A, ublas_B + ublas_A);
414  vcl_A -= viennacl::linalg::element_prod(vcl_A, vcl_B + vcl_A);
415 
416  if (!check_for_equality(ublas_A, vcl_A))
417  return EXIT_FAILURE;
418 
420  ublas_A = boost::numeric::ublas::element_prod(ublas_A + ublas_B, ublas_B + ublas_A);
421  vcl_A = viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B + vcl_A);
422 
423  if (!check_for_equality(ublas_A, vcl_A))
424  return EXIT_FAILURE;
425 
426  ublas_A += boost::numeric::ublas::element_prod(ublas_A + ublas_B, ublas_B + ublas_A);
427  vcl_A += viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B + vcl_A);
428 
429  if (!check_for_equality(ublas_A, vcl_A))
430  return EXIT_FAILURE;
431 
432  ublas_A -= boost::numeric::ublas::element_prod(ublas_A + ublas_B, ublas_B + ublas_A);
433  vcl_A -= viennacl::linalg::element_prod(vcl_A + vcl_B, vcl_B + vcl_A);
434 
435  if (!check_for_equality(ublas_A, vcl_A))
436  return EXIT_FAILURE;
437 
438 
439  ublas_B = boost::numeric::ublas::scalar_matrix<cpu_value_type>(ublas_B.size1(), ublas_B.size2(), 2);
440  ublas_A = 3 * ublas_B;
441  viennacl::copy(ublas_A, vcl_A);
442  viennacl::copy(ublas_B, vcl_B);
443  viennacl::copy(ublas_B, vcl_B);
444 
445  ublas_A = boost::numeric::ublas::element_div(ublas_A, ublas_B);
446  vcl_A = viennacl::linalg::element_div(vcl_A, vcl_B);
447 
448  if (!check_for_equality(ublas_A, vcl_A))
449  return EXIT_FAILURE;
450 
451  ublas_A += boost::numeric::ublas::element_div(ublas_A, ublas_B);
452  vcl_A += viennacl::linalg::element_div(vcl_A, vcl_B);
453 
454  if (!check_for_equality(ublas_A, vcl_A))
455  return EXIT_FAILURE;
456 
457  ublas_A -= boost::numeric::ublas::element_div(ublas_A, ublas_B);
458  vcl_A -= viennacl::linalg::element_div(vcl_A, vcl_B);
459 
460  if (!check_for_equality(ublas_A, vcl_A))
461  return EXIT_FAILURE;
462 
464  ublas_A = boost::numeric::ublas::element_div(ublas_A + ublas_B, ublas_B);
465  vcl_A = viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B);
466 
467  if (!check_for_equality(ublas_A, vcl_A))
468  return EXIT_FAILURE;
469 
470  ublas_A += boost::numeric::ublas::element_div(ublas_A + ublas_B, ublas_B);
471  vcl_A += viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B);
472 
473  if (!check_for_equality(ublas_A, vcl_A))
474  return EXIT_FAILURE;
475 
476  ublas_A -= boost::numeric::ublas::element_div(ublas_A + ublas_B, ublas_B);
477  vcl_A -= viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B);
478 
479  if (!check_for_equality(ublas_A, vcl_A))
480  return EXIT_FAILURE;
481 
483  ublas_A = boost::numeric::ublas::element_div(ublas_A, ublas_B + ublas_A);
484  vcl_A = viennacl::linalg::element_div(vcl_A, vcl_B + vcl_A);
485 
486  if (!check_for_equality(ublas_A, vcl_A))
487  return EXIT_FAILURE;
488 
489  ublas_A += boost::numeric::ublas::element_div(ublas_A, ublas_B + ublas_A);
490  vcl_A += viennacl::linalg::element_div(vcl_A, vcl_B + vcl_A);
491 
492  if (!check_for_equality(ublas_A, vcl_A))
493  return EXIT_FAILURE;
494 
495  ublas_A -= boost::numeric::ublas::element_div(ublas_A, ublas_B + ublas_A);
496  vcl_A -= viennacl::linalg::element_div(vcl_A, vcl_B + vcl_A);
497 
498  if (!check_for_equality(ublas_A, vcl_A))
499  return EXIT_FAILURE;
500 
502  ublas_A = boost::numeric::ublas::element_div(ublas_A + ublas_B, ublas_B + ublas_A);
503  vcl_A = viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B + vcl_A);
504 
505  if (!check_for_equality(ublas_A, vcl_A))
506  return EXIT_FAILURE;
507 
508  ublas_A += boost::numeric::ublas::element_div(ublas_A + ublas_B, ublas_B + ublas_A);
509  vcl_A += viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B + vcl_A);
510 
511  if (!check_for_equality(ublas_A, vcl_A))
512  return EXIT_FAILURE;
513 
514  ublas_A -= boost::numeric::ublas::element_div(ublas_A + ublas_B, ublas_B + ublas_A);
515  vcl_A -= viennacl::linalg::element_div(vcl_A + vcl_B, vcl_B + vcl_A);
516 
517  if (!check_for_equality(ublas_A, vcl_A))
518  return EXIT_FAILURE;
519 
520  std::cout << "Testing unary elementwise operations..." << std::endl;
521 
522 #define GENERATE_UNARY_OP_TEST(FUNCNAME) \
523  ublas_B = boost::numeric::ublas::scalar_matrix<cpu_value_type>(ublas_B.size1(), ublas_B.size2(), 1); \
524  ublas_A = 3 * ublas_B; \
525  ublas_C = 2 * ublas_A; \
526  viennacl::copy(ublas_A, vcl_A); \
527  viennacl::copy(ublas_B, vcl_B); \
528  viennacl::copy(ublas_C, vcl_C); \
529  viennacl::copy(ublas_B, vcl_B); \
530  \
531  for (std::size_t i=0; i<ublas_C.size1(); ++i) \
532  for (std::size_t j=0; j<ublas_C.size2(); ++j) \
533  ublas_C(i,j) = std::FUNCNAME(ublas_A(i,j)); \
534  vcl_C = viennacl::linalg::element_##FUNCNAME(vcl_A); \
535  \
536  if (!check_for_equality(ublas_C, vcl_C)) \
537  { \
538  std::cout << "Failure at C = " << #FUNCNAME << "(A)" << std::endl; \
539  return EXIT_FAILURE; \
540  } \
541  \
542  for (std::size_t i=0; i<ublas_C.size1(); ++i) \
543  for (std::size_t j=0; j<ublas_C.size2(); ++j) \
544  ublas_C(i,j) = std::FUNCNAME(ublas_A(i,j) + ublas_B(i,j)); \
545  vcl_C = viennacl::linalg::element_##FUNCNAME(vcl_A + vcl_B); \
546  \
547  if (!check_for_equality(ublas_C, vcl_C)) \
548  { \
549  std::cout << "Failure at C = " << #FUNCNAME << "(A + B)" << std::endl; \
550  return EXIT_FAILURE; \
551  } \
552  \
553  for (std::size_t i=0; i<ublas_C.size1(); ++i) \
554  for (std::size_t j=0; j<ublas_C.size2(); ++j) \
555  ublas_C(i,j) += std::FUNCNAME(ublas_A(i,j)); \
556  vcl_C += viennacl::linalg::element_##FUNCNAME(vcl_A); \
557  \
558  if (!check_for_equality(ublas_C, vcl_C)) \
559  { \
560  std::cout << "Failure at C += " << #FUNCNAME << "(A)" << std::endl; \
561  return EXIT_FAILURE; \
562  } \
563  \
564  for (std::size_t i=0; i<ublas_C.size1(); ++i) \
565  for (std::size_t j=0; j<ublas_C.size2(); ++j) \
566  ublas_C(i,j) += std::FUNCNAME(ublas_A(i,j) + ublas_B(i,j)); \
567  vcl_C += viennacl::linalg::element_##FUNCNAME(vcl_A + vcl_B); \
568  \
569  if (!check_for_equality(ublas_C, vcl_C)) \
570  { \
571  std::cout << "Failure at C += " << #FUNCNAME << "(A + B)" << std::endl; \
572  return EXIT_FAILURE; \
573  } \
574  \
575  for (std::size_t i=0; i<ublas_C.size1(); ++i) \
576  for (std::size_t j=0; j<ublas_C.size2(); ++j) \
577  ublas_C(i,j) -= std::FUNCNAME(ublas_A(i,j)); \
578  vcl_C -= viennacl::linalg::element_##FUNCNAME(vcl_A); \
579  \
580  if (!check_for_equality(ublas_C, vcl_C)) \
581  { \
582  std::cout << "Failure at C -= " << #FUNCNAME << "(A)" << std::endl; \
583  return EXIT_FAILURE; \
584  } \
585  \
586  for (std::size_t i=0; i<ublas_C.size1(); ++i) \
587  for (std::size_t j=0; j<ublas_C.size2(); ++j) \
588  ublas_C(i,j) -= std::FUNCNAME(ublas_A(i,j) + ublas_B(i,j)); \
589  vcl_C -= viennacl::linalg::element_##FUNCNAME(vcl_A + vcl_B); \
590  \
591  if (!check_for_equality(ublas_C, vcl_C)) \
592  { \
593  std::cout << "Failure at C -= " << #FUNCNAME << "(A + B)" << std::endl; \
594  return EXIT_FAILURE; \
595  } \
596  \
597 
599 
600  std::cout << "Complicated expressions: ";
601  //std::cout << "ublas_A: " << ublas_A << std::endl;
602  //std::cout << "ublas_B: " << ublas_B << std::endl;
603  //std::cout << "ublas_C: " << ublas_C << std::endl;
604  ublas_B += alpha * (- ublas_A - beta * ublas_C + ublas_A);
605  vcl_B += gpu_alpha * (- vcl_A - vcl_C * beta + vcl_A);
606 
607  if (!check_for_equality(ublas_B, vcl_B))
608  return EXIT_FAILURE;
609 
610  ublas_B += (- ublas_A - beta * ublas_C + ublas_A * beta) / gpu_alpha;
611  vcl_B += (- vcl_A - vcl_C * beta + gpu_beta * vcl_A) / gpu_alpha;
612 
613  if (!check_for_equality(ublas_B, vcl_B))
614  return EXIT_FAILURE;
615 
616 
617  ublas_B -= alpha * (- ublas_A - beta * ublas_C - ublas_A);
618  vcl_B -= gpu_alpha * (- vcl_A - vcl_C * beta - vcl_A);
619 
620  if (!check_for_equality(ublas_B, vcl_B))
621  return EXIT_FAILURE;
622 
623  ublas_B -= (- ublas_A - beta * ublas_C - ublas_A * beta) / alpha;
624  vcl_B -= (- vcl_A - vcl_C * beta - gpu_beta * vcl_A) / gpu_alpha;
625 
626  if (!check_for_equality(ublas_B, vcl_B))
627  return EXIT_FAILURE;
628 
629  std::cout << std::endl;
630  std::cout << "----------------------------------------------" << std::endl;
631  std::cout << std::endl;
632 
633 
634  return EXIT_SUCCESS;
635 }
636 
637 
638 
639 
640 template<typename T, typename ScalarType>
641 int run_test()
642 {
643  //typedef float ScalarType;
644  typedef boost::numeric::ublas::matrix<ScalarType> MatrixType;
645 
646  typedef viennacl::matrix<ScalarType, T> VCLMatrixType;
647 
648  std::size_t dim_rows = 131;
649  std::size_t dim_cols = 33;
650  //std::size_t dim_rows = 5;
651  //std::size_t dim_cols = 3;
652 
653  //setup ublas objects:
654  MatrixType ublas_A(dim_rows, dim_cols);
655  MatrixType ublas_B(dim_rows, dim_cols);
656  MatrixType ublas_C(dim_rows, dim_cols);
657 
658  for (std::size_t i=0; i<ublas_A.size1(); ++i)
659  for (std::size_t j=0; j<ublas_A.size2(); ++j)
660  {
661  ublas_A(i,j) = ScalarType((i+2) + (j+1)*(i+2));
662  ublas_B(i,j) = ScalarType((j+2) + (j+1)*(j+2));
663  ublas_C(i,j) = ScalarType((i+1) + (i+1)*(i+2));
664  }
665 
666  MatrixType ublas_A_large(4 * dim_rows, 4 * dim_cols);
667  for (std::size_t i=0; i<ublas_A_large.size1(); ++i)
668  for (std::size_t j=0; j<ublas_A_large.size2(); ++j)
669  ublas_A_large(i,j) = ScalarType(i * ublas_A_large.size2() + j);
670 
671  //Setup ViennaCL objects
672  VCLMatrixType vcl_A_full(4 * dim_rows, 4 * dim_cols);
673  VCLMatrixType vcl_B_full(4 * dim_rows, 4 * dim_cols);
674  VCLMatrixType vcl_C_full(4 * dim_rows, 4 * dim_cols);
675 
676  viennacl::copy(ublas_A_large, vcl_A_full);
677  viennacl::copy(ublas_A_large, vcl_B_full);
678  viennacl::copy(ublas_A_large, vcl_C_full);
679 
680  //
681  // Create A
682  //
683  VCLMatrixType vcl_A(dim_rows, dim_cols);
684 
685  viennacl::range vcl_A_r1(2 * dim_rows, 3 * dim_rows);
686  viennacl::range vcl_A_r2(dim_cols, 2 * dim_cols);
687  viennacl::matrix_range<VCLMatrixType> vcl_range_A(vcl_A_full, vcl_A_r1, vcl_A_r2);
688 
689  viennacl::slice vcl_A_s1(2, 3, dim_rows);
690  viennacl::slice vcl_A_s2(2 * dim_cols, 2, dim_cols);
691  viennacl::matrix_slice<VCLMatrixType> vcl_slice_A(vcl_A_full, vcl_A_s1, vcl_A_s2);
692 
693 
694  //
695  // Create B
696  //
697  VCLMatrixType vcl_B(dim_rows, dim_cols);
698 
699  viennacl::range vcl_B_r1(dim_rows, 2 * dim_rows);
700  viennacl::range vcl_B_r2(2 * dim_cols, 3 * dim_cols);
701  viennacl::matrix_range<VCLMatrixType> vcl_range_B(vcl_B_full, vcl_B_r1, vcl_B_r2);
702 
703  viennacl::slice vcl_B_s1(2 * dim_rows, 2, dim_rows);
704  viennacl::slice vcl_B_s2(dim_cols, 3, dim_cols);
705  viennacl::matrix_slice<VCLMatrixType> vcl_slice_B(vcl_B_full, vcl_B_s1, vcl_B_s2);
706 
707 
708  //
709  // Create C
710  //
711  VCLMatrixType vcl_C(dim_rows, dim_cols);
712 
713  viennacl::range vcl_C_r1(2 * dim_rows, 3 * dim_rows);
714  viennacl::range vcl_C_r2(3 * dim_cols, 4 * dim_cols);
715  viennacl::matrix_range<VCLMatrixType> vcl_range_C(vcl_C_full, vcl_C_r1, vcl_C_r2);
716 
717  viennacl::slice vcl_C_s1(dim_rows, 2, dim_rows);
718  viennacl::slice vcl_C_s2(0, 3, dim_cols);
719  viennacl::matrix_slice<VCLMatrixType> vcl_slice_C(vcl_C_full, vcl_C_s1, vcl_C_s2);
720 
721  viennacl::copy(ublas_A, vcl_A);
722  viennacl::copy(ublas_A, vcl_range_A);
723  viennacl::copy(ublas_A, vcl_slice_A);
724 
725  viennacl::copy(ublas_B, vcl_B);
726  viennacl::copy(ublas_B, vcl_range_B);
727  viennacl::copy(ublas_B, vcl_slice_B);
728 
729  viennacl::copy(ublas_C, vcl_C);
730  viennacl::copy(ublas_C, vcl_range_C);
731  viennacl::copy(ublas_C, vcl_slice_C);
732 
733 
734  std::cout << std::endl;
735  std::cout << "//" << std::endl;
736  std::cout << "////////// Test: Copy CTOR //////////" << std::endl;
737  std::cout << "//" << std::endl;
738 
739  {
740  std::cout << "Testing matrix created from range... ";
741  VCLMatrixType vcl_temp = vcl_range_A;
742  if (check_for_equality(ublas_A, vcl_temp))
743  std::cout << "PASSED!" << std::endl;
744  else
745  {
746  std::cout << "ublas_A: " << ublas_A << std::endl;
747  std::cout << "vcl_temp: " << vcl_temp << std::endl;
748  std::cout << "vcl_range_A: " << vcl_range_A << std::endl;
749  std::cout << "vcl_A: " << vcl_A << std::endl;
750  std::cout << std::endl << "TEST failed!" << std::endl;
751  return EXIT_FAILURE;
752  }
753 
754  std::cout << "Testing matrix created from slice... ";
755  VCLMatrixType vcl_temp2 = vcl_range_B;
756  if (check_for_equality(ublas_B, vcl_temp2))
757  std::cout << "PASSED!" << std::endl;
758  else
759  {
760  std::cout << std::endl << "TEST failed!" << std::endl;
761  return EXIT_FAILURE;
762  }
763  }
764 
765  std::cout << "//" << std::endl;
766  std::cout << "////////// Test: Initializer for matrix type //////////" << std::endl;
767  std::cout << "//" << std::endl;
768 
769  {
770  boost::numeric::ublas::matrix<ScalarType> ublas_dummy1 = boost::numeric::ublas::identity_matrix<ScalarType>(ublas_A.size1());
771  boost::numeric::ublas::matrix<ScalarType> ublas_dummy2 = boost::numeric::ublas::scalar_matrix<ScalarType>(ublas_A.size1(), ublas_A.size1(), 3);
772  boost::numeric::ublas::matrix<ScalarType> ublas_dummy3 = boost::numeric::ublas::zero_matrix<ScalarType>(ublas_A.size1(), ublas_A.size1());
773 
775  viennacl::matrix<ScalarType> vcl_dummy2 = viennacl::scalar_matrix<ScalarType>(ublas_A.size1(), ublas_A.size1(), 3);
776  viennacl::matrix<ScalarType> vcl_dummy3 = viennacl::zero_matrix<ScalarType>(ublas_A.size1(), ublas_A.size1());
777 
778  std::cout << "Testing initializer CTOR... ";
779  if ( check_for_equality(ublas_dummy1, vcl_dummy1)
780  && check_for_equality(ublas_dummy2, vcl_dummy2)
781  && check_for_equality(ublas_dummy3, vcl_dummy3)
782  )
783  std::cout << "PASSED!" << std::endl;
784  else
785  {
786  std::cout << std::endl << "TEST failed!" << std::endl;
787  return EXIT_FAILURE;
788  }
789 
790  ublas_dummy1 = boost::numeric::ublas::zero_matrix<ScalarType>(ublas_A.size1(), ublas_A.size1());
791  ublas_dummy2 = boost::numeric::ublas::identity_matrix<ScalarType>(ublas_A.size1());
792  ublas_dummy3 = boost::numeric::ublas::scalar_matrix<ScalarType>(ublas_A.size1(), ublas_A.size1(), 3);
793 
794  vcl_dummy1 = viennacl::zero_matrix<ScalarType>(ublas_A.size1(), ublas_A.size1());
795  vcl_dummy2 = viennacl::identity_matrix<ScalarType>(ublas_A.size1());
796  vcl_dummy3 = viennacl::scalar_matrix<ScalarType>(ublas_A.size1(), ublas_A.size1(), 3);
797 
798  std::cout << "Testing initializer assignment... ";
799  if ( check_for_equality(ublas_dummy1, vcl_dummy1)
800  && check_for_equality(ublas_dummy2, vcl_dummy2)
801  && check_for_equality(ublas_dummy3, vcl_dummy3)
802  )
803  std::cout << "PASSED!" << std::endl;
804  else
805  {
806  std::cout << std::endl << "TEST failed!" << std::endl;
807  return EXIT_FAILURE;
808  }
809  }
810 
811 
812  //
813  // run operation tests:
814  //
815 
817  std::cout << "Testing A=matrix, B=matrix, C=matrix ..." << std::endl;
818  viennacl::copy(ublas_A, vcl_A);
819  viennacl::copy(ublas_B, vcl_B);
820  viennacl::copy(ublas_C, vcl_C);
821  if (run_test(ublas_A, ublas_B, ublas_C,
822  vcl_A, vcl_B, vcl_C) != EXIT_SUCCESS)
823  {
824  return EXIT_FAILURE;
825  }
826 
827  std::cout << "Testing A=matrix, B=matrix, C=range ..." << std::endl;
828  viennacl::copy(ublas_A, vcl_A);
829  viennacl::copy(ublas_B, vcl_B);
830  viennacl::copy(ublas_C, vcl_range_C);
831  if (run_test(ublas_A, ublas_B, ublas_C,
832  vcl_A, vcl_B, vcl_range_C) != EXIT_SUCCESS)
833  {
834  return EXIT_FAILURE;
835  }
836 
837  std::cout << "Testing A=matrix, B=matrix, C=slice ..." << std::endl;
838  viennacl::copy(ublas_A, vcl_A);
839  viennacl::copy(ublas_B, vcl_B);
840  viennacl::copy(ublas_C, vcl_slice_C);
841  if (run_test(ublas_A, ublas_B, ublas_C,
842  vcl_A, vcl_B, vcl_slice_C) != EXIT_SUCCESS)
843  {
844  return EXIT_FAILURE;
845  }
846 
847  std::cout << "Testing A=matrix, B=range, C=matrix ..." << std::endl;
848  viennacl::copy(ublas_A, vcl_A);
849  viennacl::copy(ublas_B, vcl_range_B);
850  viennacl::copy(ublas_C, vcl_C);
851  if (run_test(ublas_A, ublas_B, ublas_C,
852  vcl_A, vcl_range_B, vcl_C) != EXIT_SUCCESS)
853  {
854  return EXIT_FAILURE;
855  }
856 
857  std::cout << "Testing A=matrix, B=range, C=range ..." << std::endl;
858  viennacl::copy(ublas_A, vcl_A);
859  viennacl::copy(ublas_B, vcl_range_B);
860  viennacl::copy(ublas_C, vcl_range_C);
861  if (run_test(ublas_A, ublas_B, ublas_C,
862  vcl_A, vcl_range_B, vcl_range_C) != EXIT_SUCCESS)
863  {
864  return EXIT_FAILURE;
865  }
866 
867  std::cout << "Testing A=matrix, B=range, C=slice ..." << std::endl;
868  viennacl::copy(ublas_A, vcl_A);
869  viennacl::copy(ublas_B, vcl_range_B);
870  viennacl::copy(ublas_C, vcl_slice_C);
871  if (run_test(ublas_A, ublas_B, ublas_C,
872  vcl_A, vcl_range_B, vcl_slice_C) != EXIT_SUCCESS)
873  {
874  return EXIT_FAILURE;
875  }
876 
877 
878  std::cout << "Testing A=matrix, B=slice, C=matrix ..." << std::endl;
879  viennacl::copy(ublas_A, vcl_A);
880  viennacl::copy(ublas_B, vcl_slice_B);
881  viennacl::copy(ublas_C, vcl_C);
882  if (run_test(ublas_A, ublas_B, ublas_C,
883  vcl_A, vcl_slice_B, vcl_C) != EXIT_SUCCESS)
884  {
885  return EXIT_FAILURE;
886  }
887 
888  std::cout << "Testing A=matrix, B=slice, C=range ..." << std::endl;
889  viennacl::copy(ublas_A, vcl_A);
890  viennacl::copy(ublas_B, vcl_slice_B);
891  viennacl::copy(ublas_C, vcl_range_C);
892  if (run_test(ublas_A, ublas_B, ublas_C,
893  vcl_A, vcl_slice_B, vcl_range_C) != EXIT_SUCCESS)
894  {
895  return EXIT_FAILURE;
896  }
897 
898  std::cout << "Testing A=matrix, B=slice, C=slice ..." << std::endl;
899  viennacl::copy(ublas_A, vcl_A);
900  viennacl::copy(ublas_B, vcl_slice_B);
901  viennacl::copy(ublas_C, vcl_slice_C);
902  if (run_test(ublas_A, ublas_B, ublas_C,
903  vcl_A, vcl_slice_B, vcl_slice_C) != EXIT_SUCCESS)
904  {
905  return EXIT_FAILURE;
906  }
907 
908 
909 
911  std::cout << "Testing A=range, B=matrix, C=matrix ..." << std::endl;
912  viennacl::copy(ublas_A, vcl_range_A);
913  viennacl::copy(ublas_B, vcl_B);
914  viennacl::copy(ublas_C, vcl_C);
915  if (run_test(ublas_A, ublas_B, ublas_C,
916  vcl_range_A, vcl_B, vcl_C) != EXIT_SUCCESS)
917  {
918  return EXIT_FAILURE;
919  }
920 
921  std::cout << "Testing A=range, B=matrix, C=range ..." << std::endl;
922  viennacl::copy(ublas_A, vcl_range_A);
923  viennacl::copy(ublas_B, vcl_B);
924  viennacl::copy(ublas_C, vcl_range_C);
925  if (run_test(ublas_A, ublas_B, ublas_C,
926  vcl_range_A, vcl_B, vcl_range_C) != EXIT_SUCCESS)
927  {
928  return EXIT_FAILURE;
929  }
930 
931  std::cout << "Testing A=range, B=matrix, C=slice ..." << std::endl;
932  viennacl::copy(ublas_A, vcl_range_A);
933  viennacl::copy(ublas_B, vcl_B);
934  viennacl::copy(ublas_C, vcl_slice_C);
935  if (run_test(ublas_A, ublas_B, ublas_C,
936  vcl_range_A, vcl_B, vcl_slice_C) != EXIT_SUCCESS)
937  {
938  return EXIT_FAILURE;
939  }
940 
941 
942 
943  std::cout << "Testing A=range, B=range, C=matrix ..." << std::endl;
944  viennacl::copy(ublas_A, vcl_range_A);
945  viennacl::copy(ublas_B, vcl_range_B);
946  viennacl::copy(ublas_C, vcl_C);
947  if (run_test(ublas_A, ublas_B, ublas_C,
948  vcl_range_A, vcl_range_B, vcl_C) != EXIT_SUCCESS)
949  {
950  return EXIT_FAILURE;
951  }
952 
953  std::cout << "Testing A=range, B=range, C=range ..." << std::endl;
954  viennacl::copy(ublas_A, vcl_range_A);
955  viennacl::copy(ublas_B, vcl_range_B);
956  viennacl::copy(ublas_C, vcl_range_C);
957  if (run_test(ublas_A, ublas_B, ublas_C,
958  vcl_range_A, vcl_range_B, vcl_range_C) != EXIT_SUCCESS)
959  {
960  return EXIT_FAILURE;
961  }
962 
963  std::cout << "Testing A=range, B=range, C=slice ..." << std::endl;
964  viennacl::copy(ublas_A, vcl_range_A);
965  viennacl::copy(ublas_B, vcl_range_B);
966  viennacl::copy(ublas_C, vcl_slice_C);
967  if (run_test(ublas_A, ublas_B, ublas_C,
968  vcl_range_A, vcl_range_B, vcl_slice_C) != EXIT_SUCCESS)
969  {
970  return EXIT_FAILURE;
971  }
972 
973 
974 
975  std::cout << "Testing A=range, B=slice, C=matrix ..." << std::endl;
976  viennacl::copy(ublas_A, vcl_range_A);
977  viennacl::copy(ublas_B, vcl_slice_B);
978  viennacl::copy(ublas_C, vcl_C);
979  if (run_test(ublas_A, ublas_B, ublas_C,
980  vcl_range_A, vcl_slice_B, vcl_C) != EXIT_SUCCESS)
981  {
982  return EXIT_FAILURE;
983  }
984 
985  std::cout << "Testing A=range, B=slice, C=range ..." << std::endl;
986  viennacl::copy(ublas_A, vcl_range_A);
987  viennacl::copy(ublas_B, vcl_slice_B);
988  viennacl::copy(ublas_C, vcl_range_C);
989  if (run_test(ublas_A, ublas_B, ublas_C,
990  vcl_range_A, vcl_slice_B, vcl_range_C) != EXIT_SUCCESS)
991  {
992  return EXIT_FAILURE;
993  }
994 
995  std::cout << "Testing A=range, B=slice, C=slice ..." << std::endl;
996  viennacl::copy(ublas_A, vcl_range_A);
997  viennacl::copy(ublas_B, vcl_slice_B);
998  viennacl::copy(ublas_C, vcl_slice_C);
999  if (run_test(ublas_A, ublas_B, ublas_C,
1000  vcl_range_A, vcl_slice_B, vcl_slice_C) != EXIT_SUCCESS)
1001  {
1002  return EXIT_FAILURE;
1003  }
1004 
1005 
1007  std::cout << "Testing A=slice, B=matrix, C=matrix ..." << std::endl;
1008  viennacl::copy(ublas_A, vcl_slice_A);
1009  viennacl::copy(ublas_B, vcl_B);
1010  viennacl::copy(ublas_C, vcl_C);
1011  if (run_test(ublas_A, ublas_B, ublas_C,
1012  vcl_slice_A, vcl_B, vcl_C) != EXIT_SUCCESS)
1013  {
1014  return EXIT_FAILURE;
1015  }
1016 
1017  std::cout << "Testing A=slice, B=matrix, C=range ..." << std::endl;
1018  viennacl::copy(ublas_A, vcl_slice_A);
1019  viennacl::copy(ublas_B, vcl_B);
1020  viennacl::copy(ublas_C, vcl_range_C);
1021  if (run_test(ublas_A, ublas_B, ublas_C,
1022  vcl_slice_A, vcl_B, vcl_range_C) != EXIT_SUCCESS)
1023  {
1024  return EXIT_FAILURE;
1025  }
1026 
1027  std::cout << "Testing A=slice, B=matrix, C=slice ..." << std::endl;
1028  viennacl::copy(ublas_A, vcl_slice_A);
1029  viennacl::copy(ublas_B, vcl_B);
1030  viennacl::copy(ublas_C, vcl_slice_C);
1031  if (run_test(ublas_A, ublas_B, ublas_C,
1032  vcl_slice_A, vcl_B, vcl_slice_C) != EXIT_SUCCESS)
1033  {
1034  return EXIT_FAILURE;
1035  }
1036 
1037 
1038 
1039  std::cout << "Testing A=slice, B=range, C=matrix ..." << std::endl;
1040  viennacl::copy(ublas_A, vcl_slice_A);
1041  viennacl::copy(ublas_B, vcl_range_B);
1042  viennacl::copy(ublas_C, vcl_C);
1043  if (run_test(ublas_A, ublas_B, ublas_C,
1044  vcl_slice_A, vcl_range_B, vcl_C) != EXIT_SUCCESS)
1045  {
1046  return EXIT_FAILURE;
1047  }
1048 
1049  std::cout << "Testing A=slice, B=range, C=range ..." << std::endl;
1050  viennacl::copy(ublas_A, vcl_slice_A);
1051  viennacl::copy(ublas_B, vcl_range_B);
1052  viennacl::copy(ublas_C, vcl_range_C);
1053  if (run_test(ublas_A, ublas_B, ublas_C,
1054  vcl_slice_A, vcl_range_B, vcl_range_C) != EXIT_SUCCESS)
1055  {
1056  return EXIT_FAILURE;
1057  }
1058 
1059  std::cout << "Testing A=slice, B=range, C=slice ..." << std::endl;
1060  viennacl::copy(ublas_A, vcl_slice_A);
1061  viennacl::copy(ublas_B, vcl_range_B);
1062  viennacl::copy(ublas_C, vcl_slice_C);
1063  if (run_test(ublas_A, ublas_B, ublas_C,
1064  vcl_slice_A, vcl_range_B, vcl_slice_C) != EXIT_SUCCESS)
1065  {
1066  return EXIT_FAILURE;
1067  }
1068 
1069 
1070 
1071  std::cout << "Testing A=slice, B=slice, C=matrix ..." << std::endl;
1072  viennacl::copy(ublas_A, vcl_slice_A);
1073  viennacl::copy(ublas_B, vcl_slice_B);
1074  viennacl::copy(ublas_C, vcl_C);
1075  if (run_test(ublas_A, ublas_B, ublas_C,
1076  vcl_slice_A, vcl_slice_B, vcl_C) != EXIT_SUCCESS)
1077  {
1078  return EXIT_FAILURE;
1079  }
1080 
1081  std::cout << "Testing A=slice, B=slice, C=range ..." << std::endl;
1082  viennacl::copy(ublas_A, vcl_slice_A);
1083  viennacl::copy(ublas_B, vcl_slice_B);
1084  viennacl::copy(ublas_C, vcl_range_C);
1085  if (run_test(ublas_A, ublas_B, ublas_C,
1086  vcl_slice_A, vcl_slice_B, vcl_range_C) != EXIT_SUCCESS)
1087  {
1088  return EXIT_FAILURE;
1089  }
1090 
1091  std::cout << "Testing A=slice, B=slice, C=slice ..." << std::endl;
1092  viennacl::copy(ublas_A, vcl_slice_A);
1093  viennacl::copy(ublas_B, vcl_slice_B);
1094  viennacl::copy(ublas_C, vcl_slice_C);
1095  if (run_test(ublas_A, ublas_B, ublas_C,
1096  vcl_slice_A, vcl_slice_B, vcl_slice_C) != EXIT_SUCCESS)
1097  {
1098  return EXIT_FAILURE;
1099  }
1100 
1101 
1102  return EXIT_SUCCESS;
1103 }
1104 
1105 
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)
This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type...
Definition: forwards.h:226
Class for representing strided submatrices of a bigger matrix A.
Definition: forwards.h:442
Generic interface for matrix-vector and matrix-matrix products. See viennacl/linalg/vector_operations...
Implementation of the dense matrix class.
void finish()
Synchronizes the execution. finish() will only return after all compute kernels (CUDA, OpenCL) have completed.
Definition: memory.hpp:54
A dense matrix class.
Definition: forwards.h:374
Represents a vector consisting of 1 at a given index and zeros otherwise. To be used as an initialize...
Definition: matrix_def.hpp:69
Represents a vector consisting of scalars 's' only, i.e. v[i] = s for all i. To be used as an initial...
Definition: matrix_def.hpp:93
bool check_for_equality(MatrixType const &ublas_A, VCLMatrixType const &vcl_A)
Definition: matrix_int.hpp:49
#define GENERATE_UNARY_OP_TEST(FUNCNAME)
Represents a vector consisting of zeros only. To be used as an initializer for viennacl::vector, vector_range, or vector_slize only.
Definition: matrix_def.hpp:81
T::ERROR_CANNOT_DEDUCE_CPU_SCALAR_TYPE_FOR_T type
Definition: result_of.hpp:238
Proxy classes for vectors.
Proxy classes for matrices.
int run_test(UBLASMatrixType &ublas_A, UBLASMatrixType &ublas_B, UBLASMatrixType &ublas_C, ViennaCLMatrixType1 &vcl_A, ViennaCLMatrixType2 &vcl_B, ViennaCLMatrixType3 vcl_C)
Definition: matrix_int.hpp:79
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) ...
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)
Class for representing non-strided submatrices of a bigger matrix A.
Definition: forwards.h:439
A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
Definition: forwards.h:428
Implementation of the ViennaCL scalar class.