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
scheduler_matrix_vector.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 
19 
24 //
25 // *** System
26 //
27 #include <iostream>
28 
29 //
30 // *** Boost
31 //
32 #include <boost/numeric/ublas/io.hpp>
33 #include <boost/numeric/ublas/triangular.hpp>
34 #include <boost/numeric/ublas/matrix_sparse.hpp>
35 #include <boost/numeric/ublas/matrix.hpp>
36 #include <boost/numeric/ublas/matrix_proxy.hpp>
37 #include <boost/numeric/ublas/lu.hpp>
38 #include <boost/numeric/ublas/io.hpp>
39 
40 //
41 // *** ViennaCL
42 //
43 //#define VIENNACL_DEBUG_ALL
44 #define VIENNACL_WITH_UBLAS 1
45 #include "viennacl/scalar.hpp"
46 #include "viennacl/matrix.hpp"
47 #include "viennacl/vector.hpp"
48 #include "viennacl/linalg/prod.hpp"
51 #include "viennacl/linalg/lu.hpp"
53 
56 
57 //
58 // -------------------------------------------------------------
59 //
60 using namespace boost::numeric;
61 //
62 // -------------------------------------------------------------
63 //
64 template<typename ScalarType>
66 {
68  if (s1 != s2)
69  return (s1 - s2) / std::max(std::fabs(s1), std::fabs(s2));
70  return 0;
71 }
72 
73 template<typename ScalarType, typename VCLVectorType>
74 ScalarType diff(ublas::vector<ScalarType> const & v1, VCLVectorType const & v2)
75 {
76  ublas::vector<ScalarType> v2_cpu(v2.size());
77  viennacl::backend::finish(); //workaround for a bug in APP SDK 2.7 on Trinity APUs (with Catalyst 12.8)
78  viennacl::copy(v2.begin(), v2.end(), v2_cpu.begin());
79 
80  for (unsigned int i=0;i<v1.size(); ++i)
81  {
82  if ( std::max( std::fabs(v2_cpu[i]), std::fabs(v1[i]) ) > 0 )
83  v2_cpu[i] = std::fabs(v2_cpu[i] - v1[i]) / std::max( std::fabs(v2_cpu[i]), std::fabs(v1[i]) );
84  else
85  v2_cpu[i] = 0.0;
86  }
87 
88  return norm_inf(v2_cpu);
89 }
90 
91 template<typename ScalarType, typename VCLMatrixType>
92 ScalarType diff(ublas::matrix<ScalarType> const & mat1, VCLMatrixType const & mat2)
93 {
94  ublas::matrix<ScalarType> mat2_cpu(mat2.size1(), mat2.size2());
95  viennacl::backend::finish(); //workaround for a bug in APP SDK 2.7 on Trinity APUs (with Catalyst 12.8)
96  viennacl::copy(mat2, mat2_cpu);
97  ScalarType ret = 0;
98  ScalarType act = 0;
99 
100  for (unsigned int i = 0; i < mat2_cpu.size1(); ++i)
101  {
102  for (unsigned int j = 0; j < mat2_cpu.size2(); ++j)
103  {
104  act = std::fabs(mat2_cpu(i,j) - mat1(i,j)) / std::max( std::fabs(mat2_cpu(i, j)), std::fabs(mat1(i,j)) );
105  if (act > ret)
106  ret = act;
107  }
108  }
109  //std::cout << ret << std::endl;
110  return ret;
111 }
112 //
113 // -------------------------------------------------------------
114 //
115 
116 template<typename NumericT, typename Epsilon,
117  typename UblasMatrixType, typename UblasVectorType,
118  typename VCLMatrixType, typename VCLVectorType1, typename VCLVectorType2>
119 int test_prod_rank1(Epsilon const & epsilon,
120  UblasMatrixType & ublas_m1, UblasVectorType & ublas_v1, UblasVectorType & ublas_v2,
121  VCLMatrixType & vcl_m1, VCLVectorType1 & vcl_v1, VCLVectorType2 & vcl_v2)
122 {
123  int retval = EXIT_SUCCESS;
124 
125  // sync data:
126  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
127  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
128  viennacl::copy(ublas_m1, vcl_m1);
129 
130  /* TODO: Add rank-1 operations here */
131 
132  //reset vcl_matrix:
133  viennacl::copy(ublas_m1, vcl_m1);
134 
135  // --------------------------------------------------------------------------
136  std::cout << "Matrix-Vector product" << std::endl;
137  ublas_v1 = viennacl::linalg::prod(ublas_m1, ublas_v2);
138  {
139  viennacl::scheduler::statement my_statement(vcl_v1, viennacl::op_assign(), viennacl::linalg::prod(vcl_m1, vcl_v2));
140  viennacl::scheduler::execute(my_statement);
141  }
142 
143  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
144  {
145  std::cout << "# Error at operation: matrix-vector product" << std::endl;
146  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
147  retval = EXIT_FAILURE;
148  }
149 
150  std::cout << "Matrix-Vector product with inplace-add" << std::endl;
151  ublas_v1 += viennacl::linalg::prod(ublas_m1, ublas_v2);
152  {
153  viennacl::scheduler::statement my_statement(vcl_v1, viennacl::op_inplace_add(), viennacl::linalg::prod(vcl_m1, vcl_v2));
154  viennacl::scheduler::execute(my_statement);
155  }
156 
157  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
158  {
159  std::cout << "# Error at operation: matrix-vector product" << std::endl;
160  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
161  retval = EXIT_FAILURE;
162  }
163 
164  std::cout << "Matrix-Vector product with inplace-sub" << std::endl;
165  ublas_v1 -= viennacl::linalg::prod(ublas_m1, ublas_v2);
166  {
167  viennacl::scheduler::statement my_statement(vcl_v1, viennacl::op_inplace_sub(), viennacl::linalg::prod(vcl_m1, vcl_v2));
168  viennacl::scheduler::execute(my_statement);
169  }
170 
171  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
172  {
173  std::cout << "# Error at operation: matrix-vector product" << std::endl;
174  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
175  retval = EXIT_FAILURE;
176  }
177 
178  // --------------------------------------------------------------------------
179  /*
180  std::cout << "Matrix-Vector product with scaled matrix" << std::endl;
181  ublas_v1 = viennacl::linalg::prod(NumericT(2.0) * ublas_m1, ublas_v2);
182  {
183  viennacl::scheduler::statement my_statement(vcl_v1, viennacl::op_assign(), viennacl::linalg::prod(NumericT(2.0) * vcl_m1, vcl_v2));
184  viennacl::scheduler::execute(my_statement);
185  }
186 
187  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
188  {
189  std::cout << "# Error at operation: matrix-vector product" << std::endl;
190  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
191  retval = EXIT_FAILURE;
192  }*/
193 
194  // --------------------------------------------------------------------------
195  std::cout << "Matrix-Vector product with scaled vector" << std::endl;
196  /*
197  ublas_v1 = viennacl::linalg::prod(ublas_m1, NumericT(2.0) * ublas_v2);
198  {
199  viennacl::scheduler::statement my_statement(vcl_v1, viennacl::op_assign(), viennacl::linalg::prod(vcl_m1, NumericT(2.0) * vcl_v2));
200  viennacl::scheduler::execute(my_statement);
201  }
202 
203  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
204  {
205  std::cout << "# Error at operation: matrix-vector product" << std::endl;
206  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
207  retval = EXIT_FAILURE;
208  }*/
209 
210  // --------------------------------------------------------------------------
211  std::cout << "Matrix-Vector product with scaled matrix and scaled vector" << std::endl;
212  /*
213  ublas_v1 = viennacl::linalg::prod(NumericT(2.0) * ublas_m1, NumericT(2.0) * ublas_v2);
214  {
215  viennacl::scheduler::statement my_statement(vcl_v1, viennacl::op_assign(), viennacl::linalg::prod(NumericT(2.0) * vcl_m1, NumericT(2.0) * vcl_v2));
216  viennacl::scheduler::execute(my_statement);
217  }
218 
219  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
220  {
221  std::cout << "# Error at operation: matrix-vector product" << std::endl;
222  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
223  retval = EXIT_FAILURE;
224  }*/
225 
226 
227  // --------------------------------------------------------------------------
228  std::cout << "Matrix-Vector product with scaled add" << std::endl;
229  NumericT alpha = static_cast<NumericT>(2.786);
230  NumericT beta = static_cast<NumericT>(3.1415);
231  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
232  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
233 
234  ublas_v1 = alpha * viennacl::linalg::prod(ublas_m1, ublas_v2) - beta * ublas_v1;
235  {
236  viennacl::scheduler::statement my_statement(vcl_v1, viennacl::op_assign(), alpha * viennacl::linalg::prod(vcl_m1, vcl_v2) - beta * vcl_v1);
237  viennacl::scheduler::execute(my_statement);
238  }
239 
240  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
241  {
242  std::cout << "# Error at operation: matrix-vector product with scaled additions" << std::endl;
243  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
244  retval = EXIT_FAILURE;
245  }
246 
247  std::cout << "Matrix-Vector product with scaled add, inplace-add" << std::endl;
248  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
249  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
250 
251  ublas_v1 += alpha * viennacl::linalg::prod(ublas_m1, ublas_v2) - beta * ublas_v1;
252  {
253  viennacl::scheduler::statement my_statement(vcl_v1, viennacl::op_inplace_add(), alpha * viennacl::linalg::prod(vcl_m1, vcl_v2) - beta * vcl_v1);
254  viennacl::scheduler::execute(my_statement);
255  }
256 
257  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
258  {
259  std::cout << "# Error at operation: matrix-vector product with scaled additions" << std::endl;
260  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
261  retval = EXIT_FAILURE;
262  }
263 
264  std::cout << "Matrix-Vector product with scaled add, inplace-sub" << std::endl;
265  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
266  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
267 
268  ublas_v1 -= alpha * viennacl::linalg::prod(ublas_m1, ublas_v2) - beta * ublas_v1;
269  {
270  viennacl::scheduler::statement my_statement(vcl_v1, viennacl::op_inplace_sub(), alpha * viennacl::linalg::prod(vcl_m1, vcl_v2) - beta * vcl_v1);
271  viennacl::scheduler::execute(my_statement);
272  }
273 
274  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
275  {
276  std::cout << "# Error at operation: matrix-vector product with scaled additions" << std::endl;
277  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
278  retval = EXIT_FAILURE;
279  }
280 
281  // --------------------------------------------------------------------------
282 
283  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
284  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
285 
286  std::cout << "Transposed Matrix-Vector product" << std::endl;
287  ublas_v2 = viennacl::linalg::prod(trans(ublas_m1), ublas_v1);
288  {
289  viennacl::scheduler::statement my_statement(vcl_v2, viennacl::op_assign(), viennacl::linalg::prod(trans(vcl_m1), vcl_v1));
290  viennacl::scheduler::execute(my_statement);
291  }
292 
293  if ( std::fabs(diff(ublas_v2, vcl_v2)) > epsilon )
294  {
295  std::cout << "# Error at operation: transposed matrix-vector product" << std::endl;
296  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
297  retval = EXIT_FAILURE;
298  }
299 
300  std::cout << "Transposed Matrix-Vector product, inplace-add" << std::endl;
301  ublas_v2 += viennacl::linalg::prod(trans(ublas_m1), ublas_v1);
302  {
304  viennacl::scheduler::execute(my_statement);
305  }
306 
307  if ( std::fabs(diff(ublas_v2, vcl_v2)) > epsilon )
308  {
309  std::cout << "# Error at operation: transposed matrix-vector product" << std::endl;
310  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
311  retval = EXIT_FAILURE;
312  }
313 
314  std::cout << "Transposed Matrix-Vector product, inplace-sub" << std::endl;
315  ublas_v2 -= viennacl::linalg::prod(trans(ublas_m1), ublas_v1);
316  {
318  viennacl::scheduler::execute(my_statement);
319  }
320 
321  if ( std::fabs(diff(ublas_v2, vcl_v2)) > epsilon )
322  {
323  std::cout << "# Error at operation: transposed matrix-vector product" << std::endl;
324  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
325  retval = EXIT_FAILURE;
326  }
327 
328  // --------------------------------------------------------------------------
329  std::cout << "Transposed Matrix-Vector product with scaled add" << std::endl;
330  ublas_v2 = alpha * viennacl::linalg::prod(trans(ublas_m1), ublas_v1) + beta * ublas_v2;
331  {
332  viennacl::scheduler::statement my_statement(vcl_v2, viennacl::op_assign(), alpha * viennacl::linalg::prod(trans(vcl_m1), vcl_v1) + beta * vcl_v2);
333  viennacl::scheduler::execute(my_statement);
334  }
335 
336  if ( std::fabs(diff(ublas_v2, vcl_v2)) > epsilon )
337  {
338  std::cout << "# Error at operation: transposed matrix-vector product with scaled additions" << std::endl;
339  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
340  retval = EXIT_FAILURE;
341  }
342 
343  std::cout << "Transposed Matrix-Vector product with scaled add, inplace-add" << std::endl;
344  ublas_v2 += alpha * viennacl::linalg::prod(trans(ublas_m1), ublas_v1) + beta * ublas_v2;
345  {
346  viennacl::scheduler::statement my_statement(vcl_v2, viennacl::op_inplace_add(), alpha * viennacl::linalg::prod(trans(vcl_m1), vcl_v1) + beta * vcl_v2);
347  viennacl::scheduler::execute(my_statement);
348  }
349 
350  if ( std::fabs(diff(ublas_v2, vcl_v2)) > epsilon )
351  {
352  std::cout << "# Error at operation: transposed matrix-vector product with scaled additions" << std::endl;
353  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
354  retval = EXIT_FAILURE;
355  }
356 
357  std::cout << "Transposed Matrix-Vector product with scaled add, inplace-sub" << std::endl;
358  ublas_v2 -= alpha * viennacl::linalg::prod(trans(ublas_m1), ublas_v1) + beta * ublas_v2;
359  {
360  viennacl::scheduler::statement my_statement(vcl_v2, viennacl::op_inplace_sub(), alpha * viennacl::linalg::prod(trans(vcl_m1), vcl_v1) + beta * vcl_v2);
361  viennacl::scheduler::execute(my_statement);
362  }
363 
364  if ( std::fabs(diff(ublas_v2, vcl_v2)) > epsilon )
365  {
366  std::cout << "# Error at operation: transposed matrix-vector product with scaled additions" << std::endl;
367  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
368  retval = EXIT_FAILURE;
369  }
370 
371  // --------------------------------------------------------------------------
372 
373  return retval;
374 }
375 
376 
377 //
378 // -------------------------------------------------------------
379 //
380 template< typename NumericT, typename F, typename Epsilon >
381 int test(Epsilon const& epsilon)
382 {
383  int retval = EXIT_SUCCESS;
384 
385  std::size_t num_rows = 141;
386  std::size_t num_cols = 79;
387 
388  // --------------------------------------------------------------------------
389  ublas::vector<NumericT> ublas_v1(num_rows);
390  for (std::size_t i = 0; i < ublas_v1.size(); ++i)
391  ublas_v1(i) = random<NumericT>();
392  ublas::vector<NumericT> ublas_v2 = ublas::scalar_vector<NumericT>(num_cols, NumericT(3.1415));
393 
394 
395  ublas::matrix<NumericT> ublas_m1(ublas_v1.size(), ublas_v2.size());
396 
397  for (std::size_t i = 0; i < ublas_m1.size1(); ++i)
398  for (std::size_t j = 0; j < ublas_m1.size2(); ++j)
399  ublas_m1(i,j) = static_cast<NumericT>(0.1) * random<NumericT>();
400 
401 
402  ublas::matrix<NumericT> ublas_m2(ublas_v1.size(), ublas_v1.size());
403 
404  for (std::size_t i = 0; i < ublas_m2.size1(); ++i)
405  {
406  for (std::size_t j = 0; j < ublas_m2.size2(); ++j)
407  ublas_m2(i,j) = static_cast<NumericT>(-0.1) * random<NumericT>();
408  ublas_m2(i, i) = static_cast<NumericT>(2) + random<NumericT>();
409  }
410 
411 
412  viennacl::vector<NumericT> vcl_v1_native(ublas_v1.size());
413  viennacl::vector<NumericT> vcl_v1_large(4 * ublas_v1.size());
414  viennacl::vector_range< viennacl::vector<NumericT> > vcl_v1_range(vcl_v1_large, viennacl::range(3, ublas_v1.size() + 3));
415  viennacl::vector_slice< viennacl::vector<NumericT> > vcl_v1_slice(vcl_v1_large, viennacl::slice(2, 3, ublas_v1.size()));
416 
417  viennacl::vector<NumericT> vcl_v2_native(ublas_v2.size());
418  viennacl::vector<NumericT> vcl_v2_large(4 * ublas_v2.size());
419  viennacl::vector_range< viennacl::vector<NumericT> > vcl_v2_range(vcl_v2_large, viennacl::range(8, ublas_v2.size() + 8));
420  viennacl::vector_slice< viennacl::vector<NumericT> > vcl_v2_slice(vcl_v2_large, viennacl::slice(6, 2, ublas_v2.size()));
421 
422  viennacl::matrix<NumericT, F> vcl_m1_native(ublas_m1.size1(), ublas_m1.size2());
423  viennacl::matrix<NumericT, F> vcl_m1_large(4 * ublas_m1.size1(), 4 * ublas_m1.size2());
424  viennacl::matrix_range< viennacl::matrix<NumericT, F> > vcl_m1_range(vcl_m1_large,
425  viennacl::range(8, ublas_m1.size1() + 8),
426  viennacl::range(ublas_m1.size2(), 2 * ublas_m1.size2()) );
427  viennacl::matrix_slice< viennacl::matrix<NumericT, F> > vcl_m1_slice(vcl_m1_large,
428  viennacl::slice(6, 2, ublas_m1.size1()),
429  viennacl::slice(ublas_m1.size2(), 2, ublas_m1.size2()) );
430 
431  viennacl::matrix<NumericT, F> vcl_m2_native(ublas_m2.size1(), ublas_m2.size2());
432  viennacl::matrix<NumericT, F> vcl_m2_large(4 * ublas_m2.size1(), 4 * ublas_m2.size2());
433  viennacl::matrix_range< viennacl::matrix<NumericT, F> > vcl_m2_range(vcl_m2_large,
434  viennacl::range(8, ublas_m2.size1() + 8),
435  viennacl::range(ublas_m2.size2(), 2 * ublas_m2.size2()) );
436  viennacl::matrix_slice< viennacl::matrix<NumericT, F> > vcl_m2_slice(vcl_m2_large,
437  viennacl::slice(6, 2, ublas_m2.size1()),
438  viennacl::slice(ublas_m2.size2(), 2, ublas_m2.size2()) );
439 
440 
441 /* std::cout << "Matrix resizing (to larger)" << std::endl;
442  matrix.resize(2*num_rows, 2*num_cols, true);
443  for (unsigned int i = 0; i < matrix.size1(); ++i)
444  {
445  for (unsigned int j = (i<result.size() ? rhs.size() : 0); j < matrix.size2(); ++j)
446  matrix(i,j) = 0;
447  }
448  vcl_matrix.resize(2*num_rows, 2*num_cols, true);
449  viennacl::copy(vcl_matrix, matrix);
450  if ( std::fabs(diff(matrix, vcl_matrix)) > epsilon )
451  {
452  std::cout << "# Error at operation: matrix resize (to larger)" << std::endl;
453  std::cout << " diff: " << std::fabs(diff(matrix, vcl_matrix)) << std::endl;
454  return EXIT_FAILURE;
455  }
456 
457  matrix(12, 14) = NumericT(1.9);
458  matrix(19, 16) = NumericT(1.0);
459  matrix (13, 15) = NumericT(-9);
460  vcl_matrix(12, 14) = NumericT(1.9);
461  vcl_matrix(19, 16) = NumericT(1.0);
462  vcl_matrix (13, 15) = NumericT(-9);
463 
464  std::cout << "Matrix resizing (to smaller)" << std::endl;
465  matrix.resize(result.size(), rhs.size(), true);
466  vcl_matrix.resize(result.size(), rhs.size(), true);
467  if ( std::fabs(diff(matrix, vcl_matrix)) > epsilon )
468  {
469  std::cout << "# Error at operation: matrix resize (to smaller)" << std::endl;
470  std::cout << " diff: " << std::fabs(diff(matrix, vcl_matrix)) << std::endl;
471  return EXIT_FAILURE;
472  }
473  */
474 
475  //
476  // Run a bunch of tests for rank-1-updates, matrix-vector products
477  //
478  std::cout << "------------ Testing rank-1-updates and matrix-vector products ------------------" << std::endl;
479 
480  std::cout << "* m = full, v1 = full, v2 = full" << std::endl;
481  retval = test_prod_rank1<NumericT>(epsilon,
482  ublas_m1, ublas_v1, ublas_v2,
483  vcl_m1_native, vcl_v1_native, vcl_v2_native);
484  if (retval == EXIT_FAILURE)
485  {
486  std::cout << " --- FAILED! ---" << std::endl;
487  return retval;
488  }
489  else
490  std::cout << " --- PASSED ---" << std::endl;
491 
492 
493  std::cout << "* m = full, v1 = full, v2 = range" << std::endl;
494  retval = test_prod_rank1<NumericT>(epsilon,
495  ublas_m1, ublas_v1, ublas_v2,
496  vcl_m1_native, vcl_v1_native, vcl_v2_range);
497  if (retval == EXIT_FAILURE)
498  {
499  std::cout << " --- FAILED! ---" << std::endl;
500  return retval;
501  }
502  else
503  std::cout << " --- PASSED ---" << std::endl;
504 
505 
506  std::cout << "* m = full, v1 = full, v2 = slice" << std::endl;
507  retval = test_prod_rank1<NumericT>(epsilon,
508  ublas_m1, ublas_v1, ublas_v2,
509  vcl_m1_native, vcl_v1_native, vcl_v2_slice);
510  if (retval == EXIT_FAILURE)
511  {
512  std::cout << " --- FAILED! ---" << std::endl;
513  return retval;
514  }
515  else
516  std::cout << " --- PASSED ---" << std::endl;
517 
518 
519  // v1 = range
520 
521 
522  std::cout << "* m = full, v1 = range, v2 = full" << std::endl;
523  retval = test_prod_rank1<NumericT>(epsilon,
524  ublas_m1, ublas_v1, ublas_v2,
525  vcl_m1_native, vcl_v1_range, vcl_v2_native);
526  if (retval == EXIT_FAILURE)
527  {
528  std::cout << " --- FAILED! ---" << std::endl;
529  return retval;
530  }
531  else
532  std::cout << " --- PASSED ---" << std::endl;
533 
534 
535  std::cout << "* m = full, v1 = range, v2 = range" << std::endl;
536  retval = test_prod_rank1<NumericT>(epsilon,
537  ublas_m1, ublas_v1, ublas_v2,
538  vcl_m1_native, vcl_v1_range, vcl_v2_range);
539  if (retval == EXIT_FAILURE)
540  {
541  std::cout << " --- FAILED! ---" << std::endl;
542  return retval;
543  }
544  else
545  std::cout << " --- PASSED ---" << std::endl;
546 
547 
548  std::cout << "* m = full, v1 = range, v2 = slice" << std::endl;
549  retval = test_prod_rank1<NumericT>(epsilon,
550  ublas_m1, ublas_v1, ublas_v2,
551  vcl_m1_native, vcl_v1_range, vcl_v2_slice);
552  if (retval == EXIT_FAILURE)
553  {
554  std::cout << " --- FAILED! ---" << std::endl;
555  return retval;
556  }
557  else
558  std::cout << " --- PASSED ---" << std::endl;
559 
560 
561 
562  // v1 = slice
563 
564  std::cout << "* m = full, v1 = slice, v2 = full" << std::endl;
565  retval = test_prod_rank1<NumericT>(epsilon,
566  ublas_m1, ublas_v1, ublas_v2,
567  vcl_m1_native, vcl_v1_slice, vcl_v2_native);
568  if (retval == EXIT_FAILURE)
569  {
570  std::cout << " --- FAILED! ---" << std::endl;
571  return retval;
572  }
573  else
574  std::cout << " --- PASSED ---" << std::endl;
575 
576 
577  std::cout << "* m = full, v1 = slice, v2 = range" << std::endl;
578  retval = test_prod_rank1<NumericT>(epsilon,
579  ublas_m1, ublas_v1, ublas_v2,
580  vcl_m1_native, vcl_v1_slice, vcl_v2_range);
581  if (retval == EXIT_FAILURE)
582  {
583  std::cout << " --- FAILED! ---" << std::endl;
584  return retval;
585  }
586  else
587  std::cout << " --- PASSED ---" << std::endl;
588 
589 
590  std::cout << "* m = full, v1 = slice, v2 = slice" << std::endl;
591  retval = test_prod_rank1<NumericT>(epsilon,
592  ublas_m1, ublas_v1, ublas_v2,
593  vcl_m1_native, vcl_v1_slice, vcl_v2_slice);
594  if (retval == EXIT_FAILURE)
595  {
596  std::cout << " --- FAILED! ---" << std::endl;
597  return retval;
598  }
599  else
600  std::cout << " --- PASSED ---" << std::endl;
601 
602 
604 
605  std::cout << "* m = range, v1 = full, v2 = full" << std::endl;
606  retval = test_prod_rank1<NumericT>(epsilon,
607  ublas_m1, ublas_v1, ublas_v2,
608  vcl_m1_range, vcl_v1_native, vcl_v2_native);
609  if (retval == EXIT_FAILURE)
610  {
611  std::cout << " --- FAILED! ---" << std::endl;
612  return retval;
613  }
614  else
615  std::cout << " --- PASSED ---" << std::endl;
616 
617 
618  std::cout << "* m = range, v1 = full, v2 = range" << std::endl;
619  retval = test_prod_rank1<NumericT>(epsilon,
620  ublas_m1, ublas_v1, ublas_v2,
621  vcl_m1_range, vcl_v1_native, vcl_v2_range);
622  if (retval == EXIT_FAILURE)
623  {
624  std::cout << " --- FAILED! ---" << std::endl;
625  return retval;
626  }
627  else
628  std::cout << " --- PASSED ---" << std::endl;
629 
630 
631  std::cout << "* m = range, v1 = full, v2 = slice" << std::endl;
632  retval = test_prod_rank1<NumericT>(epsilon,
633  ublas_m1, ublas_v1, ublas_v2,
634  vcl_m1_range, vcl_v1_native, vcl_v2_slice);
635  if (retval == EXIT_FAILURE)
636  {
637  std::cout << " --- FAILED! ---" << std::endl;
638  return retval;
639  }
640  else
641  std::cout << " --- PASSED ---" << std::endl;
642 
643 
644  // v1 = range
645 
646 
647  std::cout << "* m = range, v1 = range, v2 = full" << std::endl;
648  retval = test_prod_rank1<NumericT>(epsilon,
649  ublas_m1, ublas_v1, ublas_v2,
650  vcl_m1_range, vcl_v1_range, vcl_v2_native);
651  if (retval == EXIT_FAILURE)
652  {
653  std::cout << " --- FAILED! ---" << std::endl;
654  return retval;
655  }
656  else
657  std::cout << " --- PASSED ---" << std::endl;
658 
659 
660  std::cout << "* m = range, v1 = range, v2 = range" << std::endl;
661  retval = test_prod_rank1<NumericT>(epsilon,
662  ublas_m1, ublas_v1, ublas_v2,
663  vcl_m1_range, vcl_v1_range, vcl_v2_range);
664  if (retval == EXIT_FAILURE)
665  {
666  std::cout << " --- FAILED! ---" << std::endl;
667  return retval;
668  }
669  else
670  std::cout << " --- PASSED ---" << std::endl;
671 
672 
673  std::cout << "* m = range, v1 = range, v2 = slice" << std::endl;
674  retval = test_prod_rank1<NumericT>(epsilon,
675  ublas_m1, ublas_v1, ublas_v2,
676  vcl_m1_range, vcl_v1_range, vcl_v2_slice);
677  if (retval == EXIT_FAILURE)
678  {
679  std::cout << " --- FAILED! ---" << std::endl;
680  return retval;
681  }
682  else
683  std::cout << " --- PASSED ---" << std::endl;
684 
685 
686 
687  // v1 = slice
688 
689  std::cout << "* m = range, v1 = slice, v2 = full" << std::endl;
690  retval = test_prod_rank1<NumericT>(epsilon,
691  ublas_m1, ublas_v1, ublas_v2,
692  vcl_m1_range, vcl_v1_slice, vcl_v2_native);
693  if (retval == EXIT_FAILURE)
694  {
695  std::cout << " --- FAILED! ---" << std::endl;
696  return retval;
697  }
698  else
699  std::cout << " --- PASSED ---" << std::endl;
700 
701 
702  std::cout << "* m = range, v1 = slice, v2 = range" << std::endl;
703  retval = test_prod_rank1<NumericT>(epsilon,
704  ublas_m1, ublas_v1, ublas_v2,
705  vcl_m1_range, vcl_v1_slice, vcl_v2_range);
706  if (retval == EXIT_FAILURE)
707  {
708  std::cout << " --- FAILED! ---" << std::endl;
709  return retval;
710  }
711  else
712  std::cout << " --- PASSED ---" << std::endl;
713 
714 
715  std::cout << "* m = range, v1 = slice, v2 = slice" << std::endl;
716  retval = test_prod_rank1<NumericT>(epsilon,
717  ublas_m1, ublas_v1, ublas_v2,
718  vcl_m1_range, vcl_v1_slice, vcl_v2_slice);
719  if (retval == EXIT_FAILURE)
720  {
721  std::cout << " --- FAILED! ---" << std::endl;
722  return retval;
723  }
724  else
725  std::cout << " --- PASSED ---" << std::endl;
726 
727 
729 
730  std::cout << "* m = slice, v1 = full, v2 = full" << std::endl;
731  retval = test_prod_rank1<NumericT>(epsilon,
732  ublas_m1, ublas_v1, ublas_v2,
733  vcl_m1_slice, vcl_v1_native, vcl_v2_native);
734  if (retval == EXIT_FAILURE)
735  {
736  std::cout << " --- FAILED! ---" << std::endl;
737  return retval;
738  }
739  else
740  std::cout << " --- PASSED ---" << std::endl;
741 
742 
743  std::cout << "* m = slice, v1 = full, v2 = range" << std::endl;
744  retval = test_prod_rank1<NumericT>(epsilon,
745  ublas_m1, ublas_v1, ublas_v2,
746  vcl_m1_slice, vcl_v1_native, vcl_v2_range);
747  if (retval == EXIT_FAILURE)
748  {
749  std::cout << " --- FAILED! ---" << std::endl;
750  return retval;
751  }
752  else
753  std::cout << " --- PASSED ---" << std::endl;
754 
755 
756  std::cout << "* m = slice, v1 = full, v2 = slice" << std::endl;
757  retval = test_prod_rank1<NumericT>(epsilon,
758  ublas_m1, ublas_v1, ublas_v2,
759  vcl_m1_slice, vcl_v1_native, vcl_v2_slice);
760  if (retval == EXIT_FAILURE)
761  {
762  std::cout << " --- FAILED! ---" << std::endl;
763  return retval;
764  }
765  else
766  std::cout << " --- PASSED ---" << std::endl;
767 
768 
769  // v1 = range
770 
771 
772  std::cout << "* m = slice, v1 = range, v2 = full" << std::endl;
773  retval = test_prod_rank1<NumericT>(epsilon,
774  ublas_m1, ublas_v1, ublas_v2,
775  vcl_m1_slice, vcl_v1_range, vcl_v2_native);
776  if (retval == EXIT_FAILURE)
777  {
778  std::cout << " --- FAILED! ---" << std::endl;
779  return retval;
780  }
781  else
782  std::cout << " --- PASSED ---" << std::endl;
783 
784 
785  std::cout << "* m = slice, v1 = range, v2 = range" << std::endl;
786  retval = test_prod_rank1<NumericT>(epsilon,
787  ublas_m1, ublas_v1, ublas_v2,
788  vcl_m1_slice, vcl_v1_range, vcl_v2_range);
789  if (retval == EXIT_FAILURE)
790  {
791  std::cout << " --- FAILED! ---" << std::endl;
792  return retval;
793  }
794  else
795  std::cout << " --- PASSED ---" << std::endl;
796 
797 
798  std::cout << "* m = slice, v1 = range, v2 = slice" << std::endl;
799  retval = test_prod_rank1<NumericT>(epsilon,
800  ublas_m1, ublas_v1, ublas_v2,
801  vcl_m1_slice, vcl_v1_range, vcl_v2_slice);
802  if (retval == EXIT_FAILURE)
803  {
804  std::cout << " --- FAILED! ---" << std::endl;
805  return retval;
806  }
807  else
808  std::cout << " --- PASSED ---" << std::endl;
809 
810 
811 
812  // v1 = slice
813 
814  std::cout << "* m = slice, v1 = slice, v2 = full" << std::endl;
815  retval = test_prod_rank1<NumericT>(epsilon,
816  ublas_m1, ublas_v1, ublas_v2,
817  vcl_m1_slice, vcl_v1_slice, vcl_v2_native);
818  if (retval == EXIT_FAILURE)
819  {
820  std::cout << " --- FAILED! ---" << std::endl;
821  return retval;
822  }
823  else
824  std::cout << " --- PASSED ---" << std::endl;
825 
826 
827  std::cout << "* m = slice, v1 = slice, v2 = range" << std::endl;
828  retval = test_prod_rank1<NumericT>(epsilon,
829  ublas_m1, ublas_v1, ublas_v2,
830  vcl_m1_slice, vcl_v1_slice, vcl_v2_range);
831  if (retval == EXIT_FAILURE)
832  {
833  std::cout << " --- FAILED! ---" << std::endl;
834  return retval;
835  }
836  else
837  std::cout << " --- PASSED ---" << std::endl;
838 
839 
840  std::cout << "* m = slice, v1 = slice, v2 = slice" << std::endl;
841  retval = test_prod_rank1<NumericT>(epsilon,
842  ublas_m1, ublas_v1, ublas_v2,
843  vcl_m1_slice, vcl_v1_slice, vcl_v2_slice);
844  if (retval == EXIT_FAILURE)
845  {
846  std::cout << " --- FAILED! ---" << std::endl;
847  return retval;
848  }
849  else
850  std::cout << " --- PASSED ---" << std::endl;
851 
852  return retval;
853 }
854 //
855 // -------------------------------------------------------------
856 //
857 int main()
858 {
859  std::cout << std::endl;
860  std::cout << "----------------------------------------------" << std::endl;
861  std::cout << "----------------------------------------------" << std::endl;
862  std::cout << "## Test :: Matrix" << std::endl;
863  std::cout << "----------------------------------------------" << std::endl;
864  std::cout << "----------------------------------------------" << std::endl;
865  std::cout << std::endl;
866 
867  int retval = EXIT_SUCCESS;
868 
869  std::cout << std::endl;
870  std::cout << "----------------------------------------------" << std::endl;
871  std::cout << std::endl;
872  {
873  typedef float NumericT;
874  NumericT epsilon = NumericT(1.0E-3);
875  std::cout << "# Testing setup:" << std::endl;
876  std::cout << " eps: " << epsilon << std::endl;
877  std::cout << " numeric: float" << std::endl;
878  std::cout << " layout: row-major" << std::endl;
879  retval = test<NumericT, viennacl::row_major>(epsilon);
880  if ( retval == EXIT_SUCCESS )
881  std::cout << "# Test passed" << std::endl;
882  else
883  return retval;
884  }
885  std::cout << std::endl;
886  std::cout << "----------------------------------------------" << std::endl;
887  std::cout << std::endl;
888  {
889  typedef float NumericT;
890  NumericT epsilon = NumericT(1.0E-3);
891  std::cout << "# Testing setup:" << std::endl;
892  std::cout << " eps: " << epsilon << std::endl;
893  std::cout << " numeric: float" << std::endl;
894  std::cout << " layout: column-major" << std::endl;
895  retval = test<NumericT, viennacl::column_major>(epsilon);
896  if ( retval == EXIT_SUCCESS )
897  std::cout << "# Test passed" << std::endl;
898  else
899  return retval;
900  }
901  std::cout << std::endl;
902  std::cout << "----------------------------------------------" << std::endl;
903  std::cout << std::endl;
904 
905 
906 #ifdef VIENNACL_WITH_OPENCL
908 #endif
909  {
910  {
911  typedef double NumericT;
912  NumericT epsilon = 1.0E-11;
913  std::cout << "# Testing setup:" << std::endl;
914  std::cout << " eps: " << epsilon << std::endl;
915  std::cout << " numeric: double" << std::endl;
916  std::cout << " layout: row-major" << std::endl;
917  retval = test<NumericT, viennacl::row_major>(epsilon);
918  if ( retval == EXIT_SUCCESS )
919  std::cout << "# Test passed" << std::endl;
920  else
921  return retval;
922  }
923  std::cout << std::endl;
924  std::cout << "----------------------------------------------" << std::endl;
925  std::cout << std::endl;
926  {
927  typedef double NumericT;
928  NumericT epsilon = 1.0E-11;
929  std::cout << "# Testing setup:" << std::endl;
930  std::cout << " eps: " << epsilon << std::endl;
931  std::cout << " numeric: double" << std::endl;
932  std::cout << " layout: column-major" << std::endl;
933  retval = test<NumericT, viennacl::column_major>(epsilon);
934  if ( retval == EXIT_SUCCESS )
935  std::cout << "# Test passed" << std::endl;
936  else
937  return retval;
938  }
939  std::cout << std::endl;
940  std::cout << "----------------------------------------------" << std::endl;
941  std::cout << std::endl;
942  }
943 
944  std::cout << std::endl;
945  std::cout << "------- Test completed --------" << std::endl;
946  std::cout << std::endl;
947 
948 
949  return retval;
950 }
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...
ScalarType diff(ScalarType &s1, viennacl::scalar< ScalarType > &s2)
Class for representing strided submatrices of a bigger matrix A.
Definition: forwards.h:442
void trans(matrix_expression< const matrix_base< NumericT, SizeT, DistanceT >, const matrix_base< NumericT, SizeT, DistanceT >, op_trans > const &proxy, matrix_base< NumericT > &temp_trans)
Generic interface for matrix-vector and matrix-matrix products. See viennacl/linalg/vector_operations...
Implementation of the dense matrix class.
Some helper routines for reading/writing/printing scheduler expressions.
A tag class representing assignment.
Definition: forwards.h:80
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
void execute(statement const &s)
Definition: execute.hpp:279
int test(Epsilon const &epsilon)
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
A tag class representing inplace addition.
Definition: forwards.h:82
viennacl::vector< float > v1
VectorT prod(std::vector< std::vector< T, A1 >, A2 > const &matrix, VectorT const &vector)
Definition: prod.hpp:91
Class for representing non-strided subvectors of a bigger vector x.
Definition: forwards.h:433
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
Implementations of LU factorization for row-major and column-major dense matrices.
Implementations of dense direct solvers are found here.
A tag class representing inplace subtraction.
Definition: forwards.h:84
viennacl::vector< int > v2
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
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) ...
int test_prod_rank1(Epsilon const &epsilon, UblasMatrixType &ublas_m1, UblasVectorType &ublas_v1, UblasVectorType &ublas_v2, VCLMatrixType &vcl_m1, VCLVectorType1 &vcl_v1, VCLVectorType2 &vcl_v2)
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
Provides the datastructures for dealing with a single statement such as 'x = y + z;'.
Class for representing non-strided submatrices of a bigger matrix A.
Definition: forwards.h:439
The main class for representing a statement such as x = inner_prod(y,z); at runtime.
Definition: forwards.h:504
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.