ViennaCL - The Vienna Computing Library  1.6.1
Free open-source GPU-accelerated linear algebra and solver library.
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 
23 //
24 // *** System
25 //
26 #include <iostream>
27 
28 //
29 // *** Boost
30 //
31 #include <boost/numeric/ublas/io.hpp>
32 #include <boost/numeric/ublas/triangular.hpp>
33 #include <boost/numeric/ublas/matrix_sparse.hpp>
34 #include <boost/numeric/ublas/matrix.hpp>
35 #include <boost/numeric/ublas/matrix_proxy.hpp>
36 #include <boost/numeric/ublas/lu.hpp>
37 #include <boost/numeric/ublas/io.hpp>
38 #include <boost/numeric/ublas/vector_proxy.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 
54 //
55 // -------------------------------------------------------------
56 //
57 using namespace boost::numeric;
58 //
59 // -------------------------------------------------------------
60 //
61 template<typename ScalarType>
63 {
65  if (s1 != s2)
66  return (s1 - s2) / std::max(std::fabs(s1), std::fabs(s2));
67  return 0;
68 }
69 
70 template<typename ScalarType, typename VCLVectorType>
71 ScalarType diff(ublas::vector<ScalarType> const & v1, VCLVectorType const & v2)
72 {
73  ublas::vector<ScalarType> v2_cpu(v2.size());
74  viennacl::backend::finish(); //workaround for a bug in APP SDK 2.7 on Trinity APUs (with Catalyst 12.8)
75  viennacl::copy(v2.begin(), v2.end(), v2_cpu.begin());
76 
77  for (unsigned int i=0;i<v1.size(); ++i)
78  {
79  if ( std::max( std::fabs(v2_cpu[i]), std::fabs(v1[i]) ) > 0 )
80  v2_cpu[i] = std::fabs(v2_cpu[i] - v1[i]) / std::max( std::fabs(v2_cpu[i]), std::fabs(v1[i]) );
81  else
82  v2_cpu[i] = 0.0;
83  }
84 
85  return norm_inf(v2_cpu);
86 }
87 
88 template<typename ScalarType, typename VCLMatrixType>
89 ScalarType diff(ublas::matrix<ScalarType> const & mat1, VCLMatrixType const & mat2)
90 {
91  ublas::matrix<ScalarType> mat2_cpu(mat2.size1(), mat2.size2());
92  viennacl::backend::finish(); //workaround for a bug in APP SDK 2.7 on Trinity APUs (with Catalyst 12.8)
93  viennacl::copy(mat2, mat2_cpu);
94  ScalarType ret = 0;
95  ScalarType act = 0;
96 
97  for (unsigned int i = 0; i < mat2_cpu.size1(); ++i)
98  {
99  for (unsigned int j = 0; j < mat2_cpu.size2(); ++j)
100  {
101  act = std::fabs(mat2_cpu(i,j) - mat1(i,j)) / std::max( std::fabs(mat2_cpu(i, j)), std::fabs(mat1(i,j)) );
102  if (act > ret)
103  ret = act;
104  }
105  }
106  //std::cout << ret << std::endl;
107  return ret;
108 }
109 //
110 // -------------------------------------------------------------
111 //
112 
113 template<typename NumericT, typename Epsilon,
114  typename UblasMatrixType, typename UblasVectorType,
115  typename VCLMatrixType, typename VCLVectorType1, typename VCLVectorType2>
116 int test_prod_rank1(Epsilon const & epsilon,
117  UblasMatrixType & ublas_m1, UblasVectorType & ublas_v1, UblasVectorType & ublas_v2, UblasMatrixType & ublas_m2,
118  VCLMatrixType & vcl_m1, VCLVectorType1 & vcl_v1, VCLVectorType2 & vcl_v2, VCLMatrixType & vcl_m2)
119 {
120  int retval = EXIT_SUCCESS;
121 
122  // sync data:
123  ublas_v1 = ublas::scalar_vector<NumericT>(ublas_v1.size(), NumericT(0.1234));
124  ublas_v2 = ublas::scalar_vector<NumericT>(ublas_v2.size(), NumericT(0.4321));
125  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
126  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
127  viennacl::copy(ublas_m1, vcl_m1);
128 
129  // --------------------------------------------------------------------------
130  std::cout << "Rank 1 update" << std::endl;
131 
132  ublas_m1 += ublas::outer_prod(ublas_v1, ublas_v2);
133  vcl_m1 += viennacl::linalg::outer_prod(vcl_v1, vcl_v2);
134  if ( std::fabs(diff(ublas_m1, vcl_m1)) > epsilon )
135  {
136  std::cout << "# Error at operation: rank 1 update" << std::endl;
137  std::cout << " diff: " << std::fabs(diff(ublas_m1, vcl_m1)) << std::endl;
138  return EXIT_FAILURE;
139  }
140 
141 
142 
143  // --------------------------------------------------------------------------
144  std::cout << "Scaled rank 1 update - CPU Scalar" << std::endl;
145  ublas_m1 += NumericT(4.2) * ublas::outer_prod(ublas_v1, ublas_v2);
146  vcl_m1 += NumericT(2.1) * viennacl::linalg::outer_prod(vcl_v1, vcl_v2);
147  vcl_m1 += viennacl::linalg::outer_prod(vcl_v1, vcl_v2) * NumericT(2.1); //check proper compilation
148  if ( std::fabs(diff(ublas_m1, vcl_m1)) > epsilon )
149  {
150  std::cout << "# Error at operation: scaled rank 1 update - CPU Scalar" << std::endl;
151  std::cout << " diff: " << std::fabs(diff(ublas_m1, vcl_m1)) << std::endl;
152  return EXIT_FAILURE;
153  }
154 
155  // --------------------------------------------------------------------------
156  std::cout << "Scaled rank 1 update - GPU Scalar" << std::endl;
157  ublas_m1 += NumericT(4.2) * ublas::outer_prod(ublas_v1, ublas_v2);
158  vcl_m1 += viennacl::scalar<NumericT>(NumericT(2.1)) * viennacl::linalg::outer_prod(vcl_v1, vcl_v2);
159  vcl_m1 += viennacl::linalg::outer_prod(vcl_v1, vcl_v2) * viennacl::scalar<NumericT>(NumericT(2.1)); //check proper compilation
160  if ( std::fabs(diff(ublas_m1, vcl_m1)) > epsilon )
161  {
162  std::cout << "# Error at operation: scaled rank 1 update - GPU Scalar" << std::endl;
163  std::cout << " diff: " << std::fabs(diff(ublas_m1, vcl_m1)) << std::endl;
164  return EXIT_FAILURE;
165  }
166 
167  //reset vcl_matrix:
168  viennacl::copy(ublas_m1, vcl_m1);
169 
170  // --------------------------------------------------------------------------
171  std::cout << "Matrix-Vector product" << std::endl;
172  ublas_v1 = viennacl::linalg::prod(ublas_m1, ublas_v2);
173  vcl_v1 = viennacl::linalg::prod(vcl_m1, vcl_v2);
174 
175  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
176  {
177  std::cout << "# Error at operation: matrix-vector product" << std::endl;
178  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
179  retval = EXIT_FAILURE;
180  }
181  // --------------------------------------------------------------------------
182  std::cout << "Matrix-Vector product with scaled add" << std::endl;
183  NumericT alpha = static_cast<NumericT>(2.786);
184  NumericT beta = static_cast<NumericT>(1.432);
185  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
186  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
187 
188  ublas_v1 = alpha * viennacl::linalg::prod(ublas_m1, ublas_v2) + beta * ublas_v1;
189  vcl_v1 = alpha * viennacl::linalg::prod(vcl_m1, vcl_v2) + beta * vcl_v1;
190 
191  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
192  {
193  std::cout << "# Error at operation: matrix-vector product with scaled additions" << std::endl;
194  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
195  retval = EXIT_FAILURE;
196  }
197  // --------------------------------------------------------------------------
198 
199  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
200  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
201 
202  std::cout << "Transposed Matrix-Vector product" << std::endl;
203  ublas_v2 = alpha * viennacl::linalg::prod(trans(ublas_m1), ublas_v1);
204  vcl_v2 = alpha * viennacl::linalg::prod(trans(vcl_m1), vcl_v1);
205 
206  if ( std::fabs(diff(ublas_v2, vcl_v2)) > epsilon )
207  {
208  std::cout << "# Error at operation: transposed matrix-vector product" << std::endl;
209  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
210  retval = EXIT_FAILURE;
211  }
212 
213  std::cout << "Transposed Matrix-Vector product with scaled add" << std::endl;
214  ublas_v2 = alpha * viennacl::linalg::prod(trans(ublas_m1), ublas_v1) + beta * ublas_v2;
215  vcl_v2 = alpha * viennacl::linalg::prod(trans(vcl_m1), vcl_v1) + beta * vcl_v2;
216 
217  if ( std::fabs(diff(ublas_v2, vcl_v2)) > epsilon )
218  {
219  std::cout << "# Error at operation: transposed matrix-vector product with scaled additions" << std::endl;
220  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
221  retval = EXIT_FAILURE;
222  }
223  // --------------------------------------------------------------------------
224 
225  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
226  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
227 
228  std::cout << "Row extraction from matrix" << std::endl;
229  ublas_v2 = row(ublas_m1, std::size_t(7));
230  vcl_v2 = row(vcl_m1, std::size_t(7));
231 
232  if ( std::fabs(diff(ublas_v2, vcl_v2)) > epsilon )
233  {
234  std::cout << "# Error at operation: diagonal extraction from matrix" << std::endl;
235  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
236  retval = EXIT_FAILURE;
237  }
238 
239  std::cout << "Column extraction from matrix" << std::endl;
240  ublas_v1 = column(ublas_m1, std::size_t(7));
241  vcl_v1 = column(vcl_m1, std::size_t(7));
242 
243  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
244  {
245  std::cout << "# Error at operation: diagonal extraction from matrix" << std::endl;
246  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
247  retval = EXIT_FAILURE;
248  }
249 
250  // --------------------------------------------------------------------------
251 
252  viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
253  viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
254  viennacl::copy(ublas_m2, vcl_m2);
255  UblasMatrixType A = ublas_m2;
256 
257  std::cout << "Diagonal extraction from matrix" << std::endl;
258  for (std::size_t i=0; i<ublas_m1.size2(); ++i)
259  ublas_v2[i] = ublas_m1(i + 3, i);
260  vcl_v2 = diag(vcl_m1, static_cast<int>(-3));
261 
262  if ( std::fabs(diff(ublas_v2, vcl_v2)) > epsilon )
263  {
264  std::cout << "# Error at operation: diagonal extraction from matrix" << std::endl;
265  std::cout << " diff: " << std::fabs(diff(ublas_v2, vcl_v2)) << std::endl;
266  retval = EXIT_FAILURE;
267  }
268 
269  std::cout << "Matrix diagonal assignment from vector" << std::endl;
270  A = ublas::scalar_matrix<NumericT>(A.size1(), A.size2(), NumericT(0));
271  for (std::size_t i=0; i<ublas_m1.size2(); ++i)
272  A(i + (A.size1() - ublas_m1.size2()), i) = ublas_v2[i];
273  vcl_m2 = diag(vcl_v2, static_cast<int>(ublas_m1.size2()) - static_cast<int>(A.size1()));
274 
275  if ( std::fabs(diff(A, vcl_m2)) > epsilon )
276  {
277  std::cout << "# Error at operation: Matrix assignment from diagonal" << std::endl;
278  std::cout << " diff: " << std::fabs(diff(A, vcl_m2)) << std::endl;
279  retval = EXIT_FAILURE;
280  }
281  // --------------------------------------------------------------------------
282 
283  return retval;
284 }
285 
286 
287 
288 template<typename NumericT, typename Epsilon,
289  typename UblasMatrixType, typename UblasVectorType,
290  typename VCLMatrixType, typename VCLVectorType1>
291 int test_solve(Epsilon const & epsilon,
292  UblasMatrixType & ublas_m1, UblasVectorType & ublas_v1,
293  VCLMatrixType & vcl_m1, VCLVectorType1 & vcl_v1)
294 {
295  int retval = EXIT_SUCCESS;
296 
297  // sync data:
298  //viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
299  viennacl::copy(ublas_v1, vcl_v1);
300  viennacl::copy(ublas_m1, vcl_m1);
301 
303 
304  //upper triangular:
305  std::cout << "Upper triangular solver" << std::endl;
306  ublas_v1 = ublas::solve(ublas_m1, ublas_v1, ublas::upper_tag());
307  vcl_v1 = viennacl::linalg::solve(vcl_m1, vcl_v1, viennacl::linalg::upper_tag());
308  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
309  {
310  std::cout << "# Error at operation: upper triangular solver" << std::endl;
311  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
312  retval = EXIT_FAILURE;
313  }
314 
315  //upper unit triangular:
316  std::cout << "Upper unit triangular solver" << std::endl;
317  viennacl::copy(ublas_v1, vcl_v1);
318  ublas_v1 = ublas::solve(ublas_m1, ublas_v1, ublas::unit_upper_tag());
319  vcl_v1 = viennacl::linalg::solve(vcl_m1, vcl_v1, viennacl::linalg::unit_upper_tag());
320  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
321  {
322  std::cout << "# Error at operation: unit upper triangular solver" << std::endl;
323  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
324  retval = EXIT_FAILURE;
325  }
326 
327  //lower triangular:
328  std::cout << "Lower triangular solver" << std::endl;
329  viennacl::copy(ublas_v1, vcl_v1);
330  ublas_v1 = ublas::solve(ublas_m1, ublas_v1, ublas::lower_tag());
331  vcl_v1 = viennacl::linalg::solve(vcl_m1, vcl_v1, viennacl::linalg::lower_tag());
332  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
333  {
334  std::cout << "# Error at operation: lower triangular solver" << std::endl;
335  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
336  retval = EXIT_FAILURE;
337  }
338 
339  //lower unit triangular:
340  std::cout << "Lower unit triangular solver" << std::endl;
341  viennacl::copy(ublas_v1, vcl_v1);
342  ublas_v1 = ublas::solve(ublas_m1, ublas_v1, ublas::unit_lower_tag());
343  vcl_v1 = viennacl::linalg::solve(vcl_m1, vcl_v1, viennacl::linalg::unit_lower_tag());
344  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
345  {
346  std::cout << "# Error at operation: unit lower triangular solver" << std::endl;
347  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
348  retval = EXIT_FAILURE;
349  }
350 
351 
352 
353 
354 
355  //transposed upper triangular:
356  std::cout << "Transposed upper triangular solver" << std::endl;
357  viennacl::copy(ublas_v1, vcl_v1);
358  ublas_v1 = ublas::solve(trans(ublas_m1), ublas_v1, ublas::upper_tag());
359  vcl_v1 = viennacl::linalg::solve(trans(vcl_m1), vcl_v1, viennacl::linalg::upper_tag());
360  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
361  {
362  std::cout << "# Error at operation: upper triangular solver" << std::endl;
363  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
364  retval = EXIT_FAILURE;
365  }
366 
367  //transposed upper unit triangular:
368  std::cout << "Transposed unit upper triangular solver" << std::endl;
369  viennacl::copy(ublas_v1, vcl_v1);
370  ublas_v1 = ublas::solve(trans(ublas_m1), ublas_v1, ublas::unit_upper_tag());
372  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
373  {
374  std::cout << "# Error at operation: unit upper triangular solver" << std::endl;
375  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
376  retval = EXIT_FAILURE;
377  }
378 
379  //transposed lower triangular:
380  std::cout << "Transposed lower triangular solver" << std::endl;
381  viennacl::copy(ublas_v1, vcl_v1);
382  ublas_v1 = ublas::solve(trans(ublas_m1), ublas_v1, ublas::lower_tag());
383  vcl_v1 = viennacl::linalg::solve(trans(vcl_m1), vcl_v1, viennacl::linalg::lower_tag());
384  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
385  {
386  std::cout << "# Error at operation: lower triangular solver" << std::endl;
387  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
388  retval = EXIT_FAILURE;
389  }
390 
391  //transposed lower unit triangular:
392  std::cout << "Transposed unit lower triangular solver" << std::endl;
393  viennacl::copy(ublas_v1, vcl_v1);
394  ublas_v1 = ublas::solve(trans(ublas_m1), ublas_v1, ublas::unit_lower_tag());
396  if ( std::fabs(diff(ublas_v1, vcl_v1)) > epsilon )
397  {
398  std::cout << "# Error at operation: unit lower triangular solver" << std::endl;
399  std::cout << " diff: " << std::fabs(diff(ublas_v1, vcl_v1)) << std::endl;
400  retval = EXIT_FAILURE;
401  }
402 
403  return retval;
404 }
405 
406 
407 //
408 // -------------------------------------------------------------
409 //
410 template< typename NumericT, typename F, typename Epsilon >
411 int test(Epsilon const& epsilon)
412 {
413  int retval = EXIT_SUCCESS;
414 
415  std::size_t num_rows = 141; //note: use num_rows > num_cols + 3 for diag() tests to work
416  std::size_t num_cols = 103;
417 
418  // --------------------------------------------------------------------------
419  ublas::vector<NumericT> ublas_v1(num_rows);
420  for (std::size_t i = 0; i < ublas_v1.size(); ++i)
421  ublas_v1(i) = random<NumericT>();
422  ublas::vector<NumericT> ublas_v2 = ublas::scalar_vector<NumericT>(num_cols, NumericT(3.1415));
423 
424 
425  ublas::matrix<NumericT> ublas_m1(ublas_v1.size(), ublas_v2.size());
426 
427  for (std::size_t i = 0; i < ublas_m1.size1(); ++i)
428  for (std::size_t j = 0; j < ublas_m1.size2(); ++j)
429  ublas_m1(i,j) = static_cast<NumericT>(0.1) * random<NumericT>();
430 
431 
432  ublas::matrix<NumericT> ublas_m2(ublas_v1.size(), ublas_v1.size());
433 
434  for (std::size_t i = 0; i < ublas_m2.size1(); ++i)
435  {
436  for (std::size_t j = 0; j < ublas_m2.size2(); ++j)
437  ublas_m2(i,j) = static_cast<NumericT>(-0.1) * random<NumericT>();
438  ublas_m2(i, i) = static_cast<NumericT>(2) + random<NumericT>();
439  }
440 
441 
442  viennacl::vector<NumericT> vcl_v1_native(ublas_v1.size());
443  viennacl::vector<NumericT> vcl_v1_large(4 * ublas_v1.size());
444  viennacl::vector_range< viennacl::vector<NumericT> > vcl_v1_range(vcl_v1_large, viennacl::range(3, ublas_v1.size() + 3));
445  viennacl::vector_slice< viennacl::vector<NumericT> > vcl_v1_slice(vcl_v1_large, viennacl::slice(2, 3, ublas_v1.size()));
446 
447  viennacl::vector<NumericT> vcl_v2_native(ublas_v2.size());
448  viennacl::vector<NumericT> vcl_v2_large(4 * ublas_v2.size());
449  viennacl::vector_range< viennacl::vector<NumericT> > vcl_v2_range(vcl_v2_large, viennacl::range(8, ublas_v2.size() + 8));
450  viennacl::vector_slice< viennacl::vector<NumericT> > vcl_v2_slice(vcl_v2_large, viennacl::slice(6, 2, ublas_v2.size()));
451 
452  viennacl::matrix<NumericT, F> vcl_m1_native(ublas_m1.size1(), ublas_m1.size2());
453  viennacl::matrix<NumericT, F> vcl_m1_large(4 * ublas_m1.size1(), 4 * ublas_m1.size2());
454  viennacl::matrix_range< viennacl::matrix<NumericT, F> > vcl_m1_range(vcl_m1_large,
455  viennacl::range(8, ublas_m1.size1() + 8),
456  viennacl::range(ublas_m1.size2(), 2 * ublas_m1.size2()) );
457  viennacl::matrix_slice< viennacl::matrix<NumericT, F> > vcl_m1_slice(vcl_m1_large,
458  viennacl::slice(6, 2, ublas_m1.size1()),
459  viennacl::slice(ublas_m1.size2(), 2, ublas_m1.size2()) );
460 
461  viennacl::matrix<NumericT, F> vcl_m2_native(ublas_m2.size1(), ublas_m2.size2());
462  viennacl::matrix<NumericT, F> vcl_m2_large(4 * ublas_m2.size1(), 4 * ublas_m2.size2());
463  viennacl::matrix_range< viennacl::matrix<NumericT, F> > vcl_m2_range(vcl_m2_large,
464  viennacl::range(8, ublas_m2.size1() + 8),
465  viennacl::range(ublas_m2.size2(), 2 * ublas_m2.size2()) );
466  viennacl::matrix_slice< viennacl::matrix<NumericT, F> > vcl_m2_slice(vcl_m2_large,
467  viennacl::slice(6, 2, ublas_m2.size1()),
468  viennacl::slice(ublas_m2.size2(), 2, ublas_m2.size2()) );
469 
470 
471 /* std::cout << "Matrix resizing (to larger)" << std::endl;
472  matrix.resize(2*num_rows, 2*num_cols, true);
473  for (unsigned int i = 0; i < matrix.size1(); ++i)
474  {
475  for (unsigned int j = (i<result.size() ? rhs.size() : 0); j < matrix.size2(); ++j)
476  matrix(i,j) = 0;
477  }
478  vcl_matrix.resize(2*num_rows, 2*num_cols, true);
479  viennacl::copy(vcl_matrix, matrix);
480  if ( std::fabs(diff(matrix, vcl_matrix)) > epsilon )
481  {
482  std::cout << "# Error at operation: matrix resize (to larger)" << std::endl;
483  std::cout << " diff: " << std::fabs(diff(matrix, vcl_matrix)) << std::endl;
484  return EXIT_FAILURE;
485  }
486 
487  matrix(12, 14) = NumericT(1.9);
488  matrix(19, 16) = NumericT(1.0);
489  matrix (13, 15) = NumericT(-9);
490  vcl_matrix(12, 14) = NumericT(1.9);
491  vcl_matrix(19, 16) = NumericT(1.0);
492  vcl_matrix (13, 15) = NumericT(-9);
493 
494  std::cout << "Matrix resizing (to smaller)" << std::endl;
495  matrix.resize(result.size(), rhs.size(), true);
496  vcl_matrix.resize(result.size(), rhs.size(), true);
497  if ( std::fabs(diff(matrix, vcl_matrix)) > epsilon )
498  {
499  std::cout << "# Error at operation: matrix resize (to smaller)" << std::endl;
500  std::cout << " diff: " << std::fabs(diff(matrix, vcl_matrix)) << std::endl;
501  return EXIT_FAILURE;
502  }
503  */
504 
505  //
506  // Run a bunch of tests for rank-1-updates, matrix-vector products
507  //
508  std::cout << "------------ Testing rank-1-updates and matrix-vector products ------------------" << std::endl;
509 
510  std::cout << "* m = full, v1 = full, v2 = full" << std::endl;
511  retval = test_prod_rank1<NumericT>(epsilon,
512  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
513  vcl_m1_native, vcl_v1_native, vcl_v2_native, vcl_m2_native);
514  if (retval == EXIT_FAILURE)
515  {
516  std::cout << " --- FAILED! ---" << std::endl;
517  return retval;
518  }
519  else
520  std::cout << " --- PASSED ---" << std::endl;
521 
522 
523  std::cout << "* m = full, v1 = full, v2 = range" << std::endl;
524  retval = test_prod_rank1<NumericT>(epsilon,
525  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
526  vcl_m1_native, vcl_v1_native, vcl_v2_range, vcl_m2_native);
527  if (retval == EXIT_FAILURE)
528  {
529  std::cout << " --- FAILED! ---" << std::endl;
530  return retval;
531  }
532  else
533  std::cout << " --- PASSED ---" << std::endl;
534 
535 
536  std::cout << "* m = full, v1 = full, v2 = slice" << std::endl;
537  retval = test_prod_rank1<NumericT>(epsilon,
538  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
539  vcl_m1_native, vcl_v1_native, vcl_v2_slice, vcl_m2_native);
540  if (retval == EXIT_FAILURE)
541  {
542  std::cout << " --- FAILED! ---" << std::endl;
543  return retval;
544  }
545  else
546  std::cout << " --- PASSED ---" << std::endl;
547 
548 
549  // v1 = range
550 
551 
552  std::cout << "* m = full, v1 = range, v2 = full" << std::endl;
553  retval = test_prod_rank1<NumericT>(epsilon,
554  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
555  vcl_m1_native, vcl_v1_range, vcl_v2_native, vcl_m2_native);
556  if (retval == EXIT_FAILURE)
557  {
558  std::cout << " --- FAILED! ---" << std::endl;
559  return retval;
560  }
561  else
562  std::cout << " --- PASSED ---" << std::endl;
563 
564 
565  std::cout << "* m = full, v1 = range, v2 = range" << std::endl;
566  retval = test_prod_rank1<NumericT>(epsilon,
567  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
568  vcl_m1_native, vcl_v1_range, vcl_v2_range, vcl_m2_native);
569  if (retval == EXIT_FAILURE)
570  {
571  std::cout << " --- FAILED! ---" << std::endl;
572  return retval;
573  }
574  else
575  std::cout << " --- PASSED ---" << std::endl;
576 
577 
578  std::cout << "* m = full, v1 = range, v2 = slice" << std::endl;
579  retval = test_prod_rank1<NumericT>(epsilon,
580  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
581  vcl_m1_native, vcl_v1_range, vcl_v2_slice, vcl_m2_native);
582  if (retval == EXIT_FAILURE)
583  {
584  std::cout << " --- FAILED! ---" << std::endl;
585  return retval;
586  }
587  else
588  std::cout << " --- PASSED ---" << std::endl;
589 
590 
591 
592  // v1 = slice
593 
594  std::cout << "* m = full, v1 = slice, v2 = full" << std::endl;
595  retval = test_prod_rank1<NumericT>(epsilon,
596  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
597  vcl_m1_native, vcl_v1_slice, vcl_v2_native, vcl_m2_native);
598  if (retval == EXIT_FAILURE)
599  {
600  std::cout << " --- FAILED! ---" << std::endl;
601  return retval;
602  }
603  else
604  std::cout << " --- PASSED ---" << std::endl;
605 
606 
607  std::cout << "* m = full, v1 = slice, v2 = range" << std::endl;
608  retval = test_prod_rank1<NumericT>(epsilon,
609  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
610  vcl_m1_native, vcl_v1_slice, vcl_v2_range, vcl_m2_native);
611  if (retval == EXIT_FAILURE)
612  {
613  std::cout << " --- FAILED! ---" << std::endl;
614  return retval;
615  }
616  else
617  std::cout << " --- PASSED ---" << std::endl;
618 
619 
620  std::cout << "* m = full, v1 = slice, v2 = slice" << std::endl;
621  retval = test_prod_rank1<NumericT>(epsilon,
622  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
623  vcl_m1_native, vcl_v1_slice, vcl_v2_slice, vcl_m2_native);
624  if (retval == EXIT_FAILURE)
625  {
626  std::cout << " --- FAILED! ---" << std::endl;
627  return retval;
628  }
629  else
630  std::cout << " --- PASSED ---" << std::endl;
631 
632 
634 
635  std::cout << "* m = range, v1 = full, v2 = full" << std::endl;
636  retval = test_prod_rank1<NumericT>(epsilon,
637  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
638  vcl_m1_range, vcl_v1_native, vcl_v2_native, vcl_m2_range);
639  if (retval == EXIT_FAILURE)
640  {
641  std::cout << " --- FAILED! ---" << std::endl;
642  return retval;
643  }
644  else
645  std::cout << " --- PASSED ---" << std::endl;
646 
647 
648  std::cout << "* m = range, v1 = full, v2 = range" << std::endl;
649  retval = test_prod_rank1<NumericT>(epsilon,
650  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
651  vcl_m1_range, vcl_v1_native, vcl_v2_range, vcl_m2_range);
652  if (retval == EXIT_FAILURE)
653  {
654  std::cout << " --- FAILED! ---" << std::endl;
655  return retval;
656  }
657  else
658  std::cout << " --- PASSED ---" << std::endl;
659 
660 
661  std::cout << "* m = range, v1 = full, v2 = slice" << std::endl;
662  retval = test_prod_rank1<NumericT>(epsilon,
663  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
664  vcl_m1_range, vcl_v1_native, vcl_v2_slice, vcl_m2_range);
665  if (retval == EXIT_FAILURE)
666  {
667  std::cout << " --- FAILED! ---" << std::endl;
668  return retval;
669  }
670  else
671  std::cout << " --- PASSED ---" << std::endl;
672 
673 
674  // v1 = range
675 
676 
677  std::cout << "* m = range, v1 = range, v2 = full" << std::endl;
678  retval = test_prod_rank1<NumericT>(epsilon,
679  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
680  vcl_m1_range, vcl_v1_range, vcl_v2_native, vcl_m2_range);
681  if (retval == EXIT_FAILURE)
682  {
683  std::cout << " --- FAILED! ---" << std::endl;
684  return retval;
685  }
686  else
687  std::cout << " --- PASSED ---" << std::endl;
688 
689 
690  std::cout << "* m = range, v1 = range, v2 = range" << std::endl;
691  retval = test_prod_rank1<NumericT>(epsilon,
692  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
693  vcl_m1_range, vcl_v1_range, vcl_v2_range, vcl_m2_range);
694  if (retval == EXIT_FAILURE)
695  {
696  std::cout << " --- FAILED! ---" << std::endl;
697  return retval;
698  }
699  else
700  std::cout << " --- PASSED ---" << std::endl;
701 
702 
703  std::cout << "* m = range, v1 = range, v2 = slice" << std::endl;
704  retval = test_prod_rank1<NumericT>(epsilon,
705  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
706  vcl_m1_range, vcl_v1_range, vcl_v2_slice, vcl_m2_range);
707  if (retval == EXIT_FAILURE)
708  {
709  std::cout << " --- FAILED! ---" << std::endl;
710  return retval;
711  }
712  else
713  std::cout << " --- PASSED ---" << std::endl;
714 
715 
716 
717  // v1 = slice
718 
719  std::cout << "* m = range, v1 = slice, v2 = full" << std::endl;
720  retval = test_prod_rank1<NumericT>(epsilon,
721  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
722  vcl_m1_range, vcl_v1_slice, vcl_v2_native, vcl_m2_range);
723  if (retval == EXIT_FAILURE)
724  {
725  std::cout << " --- FAILED! ---" << std::endl;
726  return retval;
727  }
728  else
729  std::cout << " --- PASSED ---" << std::endl;
730 
731 
732  std::cout << "* m = range, v1 = slice, v2 = range" << std::endl;
733  retval = test_prod_rank1<NumericT>(epsilon,
734  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
735  vcl_m1_range, vcl_v1_slice, vcl_v2_range, vcl_m2_range);
736  if (retval == EXIT_FAILURE)
737  {
738  std::cout << " --- FAILED! ---" << std::endl;
739  return retval;
740  }
741  else
742  std::cout << " --- PASSED ---" << std::endl;
743 
744 
745  std::cout << "* m = range, v1 = slice, v2 = slice" << std::endl;
746  retval = test_prod_rank1<NumericT>(epsilon,
747  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
748  vcl_m1_range, vcl_v1_slice, vcl_v2_slice, vcl_m2_range);
749  if (retval == EXIT_FAILURE)
750  {
751  std::cout << " --- FAILED! ---" << std::endl;
752  return retval;
753  }
754  else
755  std::cout << " --- PASSED ---" << std::endl;
756 
757 
759 
760  std::cout << "* m = slice, v1 = full, v2 = full" << std::endl;
761  retval = test_prod_rank1<NumericT>(epsilon,
762  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
763  vcl_m1_slice, vcl_v1_native, vcl_v2_native, vcl_m2_slice);
764  if (retval == EXIT_FAILURE)
765  {
766  std::cout << " --- FAILED! ---" << std::endl;
767  return retval;
768  }
769  else
770  std::cout << " --- PASSED ---" << std::endl;
771 
772 
773  std::cout << "* m = slice, v1 = full, v2 = range" << std::endl;
774  retval = test_prod_rank1<NumericT>(epsilon,
775  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
776  vcl_m1_slice, vcl_v1_native, vcl_v2_range, vcl_m2_slice);
777  if (retval == EXIT_FAILURE)
778  {
779  std::cout << " --- FAILED! ---" << std::endl;
780  return retval;
781  }
782  else
783  std::cout << " --- PASSED ---" << std::endl;
784 
785 
786  std::cout << "* m = slice, v1 = full, v2 = slice" << std::endl;
787  retval = test_prod_rank1<NumericT>(epsilon,
788  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
789  vcl_m1_slice, vcl_v1_native, vcl_v2_slice, vcl_m2_slice);
790  if (retval == EXIT_FAILURE)
791  {
792  std::cout << " --- FAILED! ---" << std::endl;
793  return retval;
794  }
795  else
796  std::cout << " --- PASSED ---" << std::endl;
797 
798 
799  // v1 = range
800 
801 
802  std::cout << "* m = slice, v1 = range, v2 = full" << std::endl;
803  retval = test_prod_rank1<NumericT>(epsilon,
804  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
805  vcl_m1_slice, vcl_v1_range, vcl_v2_native, vcl_m2_slice);
806  if (retval == EXIT_FAILURE)
807  {
808  std::cout << " --- FAILED! ---" << std::endl;
809  return retval;
810  }
811  else
812  std::cout << " --- PASSED ---" << std::endl;
813 
814 
815  std::cout << "* m = slice, v1 = range, v2 = range" << std::endl;
816  retval = test_prod_rank1<NumericT>(epsilon,
817  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
818  vcl_m1_slice, vcl_v1_range, vcl_v2_range, vcl_m2_slice);
819  if (retval == EXIT_FAILURE)
820  {
821  std::cout << " --- FAILED! ---" << std::endl;
822  return retval;
823  }
824  else
825  std::cout << " --- PASSED ---" << std::endl;
826 
827 
828  std::cout << "* m = slice, v1 = range, v2 = slice" << std::endl;
829  retval = test_prod_rank1<NumericT>(epsilon,
830  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
831  vcl_m1_slice, vcl_v1_range, vcl_v2_slice, vcl_m2_slice);
832  if (retval == EXIT_FAILURE)
833  {
834  std::cout << " --- FAILED! ---" << std::endl;
835  return retval;
836  }
837  else
838  std::cout << " --- PASSED ---" << std::endl;
839 
840 
841 
842  // v1 = slice
843 
844  std::cout << "* m = slice, v1 = slice, v2 = full" << std::endl;
845  retval = test_prod_rank1<NumericT>(epsilon,
846  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
847  vcl_m1_slice, vcl_v1_slice, vcl_v2_native, vcl_m2_slice);
848  if (retval == EXIT_FAILURE)
849  {
850  std::cout << " --- FAILED! ---" << std::endl;
851  return retval;
852  }
853  else
854  std::cout << " --- PASSED ---" << std::endl;
855 
856 
857  std::cout << "* m = slice, v1 = slice, v2 = range" << std::endl;
858  retval = test_prod_rank1<NumericT>(epsilon,
859  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
860  vcl_m1_slice, vcl_v1_slice, vcl_v2_range, vcl_m2_slice);
861  if (retval == EXIT_FAILURE)
862  {
863  std::cout << " --- FAILED! ---" << std::endl;
864  return retval;
865  }
866  else
867  std::cout << " --- PASSED ---" << std::endl;
868 
869 
870  std::cout << "* m = slice, v1 = slice, v2 = slice" << std::endl;
871  retval = test_prod_rank1<NumericT>(epsilon,
872  ublas_m1, ublas_v1, ublas_v2, ublas_m2,
873  vcl_m1_slice, vcl_v1_slice, vcl_v2_slice, vcl_m2_slice);
874  if (retval == EXIT_FAILURE)
875  {
876  std::cout << " --- FAILED! ---" << std::endl;
877  return retval;
878  }
879  else
880  std::cout << " --- PASSED ---" << std::endl;
881 
882 
883 
884  //
885  // Testing triangular solve() routines
886  //
887 
888  std::cout << "------------ Testing triangular solves ------------------" << std::endl;
889 
890  std::cout << "* m = full, v1 = full" << std::endl;
891  retval = test_solve<NumericT>(epsilon,
892  ublas_m2, ublas_v1,
893  vcl_m2_native, vcl_v1_native);
894  if (retval == EXIT_FAILURE)
895  {
896  std::cout << " --- FAILED! ---" << std::endl;
897  return retval;
898  }
899  else
900  std::cout << " --- PASSED ---" << std::endl;
901 
902  std::cout << "* m = full, v1 = range" << std::endl;
903  retval = test_solve<NumericT>(epsilon,
904  ublas_m2, ublas_v1,
905  vcl_m2_native, vcl_v1_range);
906  if (retval == EXIT_FAILURE)
907  {
908  std::cout << " --- FAILED! ---" << std::endl;
909  return retval;
910  }
911  else
912  std::cout << " --- PASSED ---" << std::endl;
913 
914  std::cout << "* m = full, v1 = slice" << std::endl;
915  retval = test_solve<NumericT>(epsilon,
916  ublas_m2, ublas_v1,
917  vcl_m2_native, vcl_v1_slice);
918  if (retval == EXIT_FAILURE)
919  {
920  std::cout << " --- FAILED! ---" << std::endl;
921  return retval;
922  }
923  else
924  std::cout << " --- PASSED ---" << std::endl;
925 
927 
928 
929  std::cout << "* m = range, v1 = full" << std::endl;
930  retval = test_solve<NumericT>(epsilon,
931  ublas_m2, ublas_v1,
932  vcl_m2_range, vcl_v1_native);
933  if (retval == EXIT_FAILURE)
934  {
935  std::cout << " --- FAILED! ---" << std::endl;
936  return retval;
937  }
938  else
939  std::cout << " --- PASSED ---" << std::endl;
940 
941  std::cout << "* m = range, v1 = range" << std::endl;
942  retval = test_solve<NumericT>(epsilon,
943  ublas_m2, ublas_v1,
944  vcl_m2_range, vcl_v1_range);
945  if (retval == EXIT_FAILURE)
946  {
947  std::cout << " --- FAILED! ---" << std::endl;
948  return retval;
949  }
950  else
951  std::cout << " --- PASSED ---" << std::endl;
952 
953  std::cout << "* m = range, v1 = slice" << std::endl;
954  retval = test_solve<NumericT>(epsilon,
955  ublas_m2, ublas_v1,
956  vcl_m2_range, vcl_v1_slice);
957  if (retval == EXIT_FAILURE)
958  {
959  std::cout << " --- FAILED! ---" << std::endl;
960  return retval;
961  }
962  else
963  std::cout << " --- PASSED ---" << std::endl;
964 
966 
967  std::cout << "* m = slice, v1 = full" << std::endl;
968  retval = test_solve<NumericT>(epsilon,
969  ublas_m2, ublas_v1,
970  vcl_m2_slice, vcl_v1_native);
971  if (retval == EXIT_FAILURE)
972  {
973  std::cout << " --- FAILED! ---" << std::endl;
974  return retval;
975  }
976  else
977  std::cout << " --- PASSED ---" << std::endl;
978 
979  std::cout << "* m = slice, v1 = range" << std::endl;
980  retval = test_solve<NumericT>(epsilon,
981  ublas_m2, ublas_v1,
982  vcl_m2_slice, vcl_v1_range);
983  if (retval == EXIT_FAILURE)
984  {
985  std::cout << " --- FAILED! ---" << std::endl;
986  return retval;
987  }
988  else
989  std::cout << " --- PASSED ---" << std::endl;
990 
991  std::cout << "* m = slice, v1 = slice" << std::endl;
992  retval = test_solve<NumericT>(epsilon,
993  ublas_m2, ublas_v1,
994  vcl_m2_slice, vcl_v1_slice);
995  if (retval == EXIT_FAILURE)
996  {
997  std::cout << " --- FAILED! ---" << std::endl;
998  return retval;
999  }
1000  else
1001  std::cout << " --- PASSED ---" << std::endl;
1002 
1003 
1004 
1005 
1006 
1007 
1008 
1010 
1011  //full solver:
1012  std::cout << "Full solver" << std::endl;
1013  unsigned int lu_dim = 100;
1014  ublas::matrix<NumericT> square_matrix(lu_dim, lu_dim);
1015  ublas::vector<NumericT> lu_rhs(lu_dim);
1016  viennacl::matrix<NumericT, F> vcl_square_matrix(lu_dim, lu_dim);
1017  viennacl::vector<NumericT> vcl_lu_rhs(lu_dim);
1018 
1019  for (std::size_t i=0; i<lu_dim; ++i)
1020  for (std::size_t j=0; j<lu_dim; ++j)
1021  square_matrix(i,j) = -static_cast<NumericT>(0.5) * random<NumericT>();
1022 
1023  //put some more weight on diagonal elements:
1024  for (std::size_t j=0; j<lu_dim; ++j)
1025  {
1026  square_matrix(j,j) = static_cast<NumericT>(20.0) + random<NumericT>();
1027  lu_rhs(j) = random<NumericT>();
1028  }
1029 
1030  viennacl::copy(square_matrix, vcl_square_matrix);
1031  viennacl::copy(lu_rhs, vcl_lu_rhs);
1032 
1033  //ublas::
1034  ublas::lu_factorize(square_matrix);
1035  ublas::inplace_solve (square_matrix, lu_rhs, ublas::unit_lower_tag ());
1036  ublas::inplace_solve (square_matrix, lu_rhs, ublas::upper_tag ());
1037 
1038  // ViennaCL:
1039  viennacl::linalg::lu_factorize(vcl_square_matrix);
1040  //viennacl::copy(square_matrix, vcl_square_matrix);
1041  viennacl::linalg::lu_substitute(vcl_square_matrix, vcl_lu_rhs);
1042 
1043  if ( std::fabs(diff(lu_rhs, vcl_lu_rhs)) > epsilon )
1044  {
1045  std::cout << "# Error at operation: dense solver" << std::endl;
1046  std::cout << " diff: " << std::fabs(diff(lu_rhs, vcl_lu_rhs)) << std::endl;
1047  retval = EXIT_FAILURE;
1048  }
1049 
1050 
1051 
1052  return retval;
1053 }
1054 //
1055 // -------------------------------------------------------------
1056 //
1057 int main()
1058 {
1059  std::cout << std::endl;
1060  std::cout << "----------------------------------------------" << std::endl;
1061  std::cout << "----------------------------------------------" << std::endl;
1062  std::cout << "## Test :: Matrix" << std::endl;
1063  std::cout << "----------------------------------------------" << std::endl;
1064  std::cout << "----------------------------------------------" << std::endl;
1065  std::cout << std::endl;
1066 
1067  int retval = EXIT_SUCCESS;
1068 
1069 // std::cout << std::endl;
1070 // std::cout << "----------------------------------------------" << std::endl;
1071 // std::cout << std::endl;
1072 // {
1073 // typedef float NumericT;
1074 // NumericT epsilon = NumericT(1.0E-3);
1075 // std::cout << "# Testing setup:" << std::endl;
1076 // std::cout << " eps: " << epsilon << std::endl;
1077 // std::cout << " numeric: float" << std::endl;
1078 // std::cout << " layout: row-major" << std::endl;
1079 // retval = test<NumericT, viennacl::row_major>(epsilon);
1080 // if ( retval == EXIT_SUCCESS )
1081 // std::cout << "# Test passed" << std::endl;
1082 // else
1083 // return retval;
1084 // }
1085  std::cout << std::endl;
1086  std::cout << "----------------------------------------------" << std::endl;
1087  std::cout << std::endl;
1088  {
1089  typedef float NumericT;
1090  NumericT epsilon = NumericT(1.0E-3);
1091  std::cout << "# Testing setup:" << std::endl;
1092  std::cout << " eps: " << epsilon << std::endl;
1093  std::cout << " numeric: float" << std::endl;
1094  std::cout << " layout: column-major" << std::endl;
1095  retval = test<NumericT, viennacl::column_major>(epsilon);
1096  if ( retval == EXIT_SUCCESS )
1097  std::cout << "# Test passed" << std::endl;
1098  else
1099  return retval;
1100  }
1101  std::cout << std::endl;
1102  std::cout << "----------------------------------------------" << std::endl;
1103  std::cout << std::endl;
1104 
1105 
1106 #ifdef VIENNACL_WITH_OPENCL
1108 #endif
1109  {
1110  {
1111  typedef double NumericT;
1112  NumericT epsilon = 1.0E-11;
1113  std::cout << "# Testing setup:" << std::endl;
1114  std::cout << " eps: " << epsilon << std::endl;
1115  std::cout << " numeric: double" << std::endl;
1116  std::cout << " layout: row-major" << std::endl;
1117  retval = test<NumericT, viennacl::row_major>(epsilon);
1118  if ( retval == EXIT_SUCCESS )
1119  std::cout << "# Test passed" << std::endl;
1120  else
1121  return retval;
1122  }
1123  std::cout << std::endl;
1124  std::cout << "----------------------------------------------" << std::endl;
1125  std::cout << std::endl;
1126  {
1127  typedef double NumericT;
1128  NumericT epsilon = 1.0E-11;
1129  std::cout << "# Testing setup:" << std::endl;
1130  std::cout << " eps: " << epsilon << std::endl;
1131  std::cout << " numeric: double" << std::endl;
1132  std::cout << " layout: column-major" << std::endl;
1133  retval = test<NumericT, viennacl::column_major>(epsilon);
1134  if ( retval == EXIT_SUCCESS )
1135  std::cout << "# Test passed" << std::endl;
1136  else
1137  return retval;
1138  }
1139  std::cout << std::endl;
1140  std::cout << "----------------------------------------------" << std::endl;
1141  std::cout << std::endl;
1142  }
1143 
1144  std::cout << std::endl;
1145  std::cout << "------- Test completed --------" << std::endl;
1146  std::cout << std::endl;
1147 
1148 
1149  return retval;
1150 }
void inplace_solve(matrix_base< NumericT > const &A, matrix_base< NumericT > &B, SolverTagT tag)
Direct inplace solver for triangular systems with multiple right hand sides, i.e. A \ B (MATLAB notat...
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...
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.
void lu_substitute(matrix< NumericT, F1, AlignmentV1 > const &A, matrix< NumericT, F2, AlignmentV2 > &B)
LU substitution for the system LU = rhs.
Definition: lu.hpp:201
A tag class representing a lower triangular matrix.
Definition: forwards.h:809
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
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
int main()
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
A tag class representing an upper triangular matrix.
Definition: forwards.h:814
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
vector_expression< const matrix_base< NumericT >, const int, op_matrix_diag > diag(const matrix_base< NumericT > &A, int k=0)
Definition: matrix.hpp:838
Implementations of LU factorization for row-major and column-major dense matrices.
Implementations of dense direct solvers are found here.
vector_expression< const matrix_base< NumericT, F >, const unsigned int, op_row > row(const matrix_base< NumericT, F > &A, unsigned int i)
Definition: matrix.hpp:853
viennacl::matrix_expression< const vector_base< NumericT >, const vector_base< NumericT >, op_prod > outer_prod(const vector_base< NumericT > &vec1, const vector_base< NumericT > &vec2)
Returns a proxy class for the operation mat += vec1 * vec2^T, i.e. a rank 1 update.
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
int test_solve(Epsilon const &epsilon, UblasMatrixType &ublas_m1, UblasVectorType &ublas_v1, VCLMatrixType &vcl_m1, VCLVectorType1 &vcl_v1)
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, UblasMatrixType &ublas_m2, VCLMatrixType &vcl_m1, VCLVectorType1 &vcl_v1, VCLVectorType2 &vcl_v2, VCLMatrixType &vcl_m2)
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
A tag class representing a lower triangular matrix with unit diagonal.
Definition: forwards.h:819
ScalarType diff(ScalarType &s1, viennacl::scalar< ScalarType > &s2)
Class for representing non-strided submatrices of a bigger matrix A.
Definition: forwards.h:439
vector_expression< const matrix_base< NumericT, F >, const unsigned int, op_column > column(const matrix_base< NumericT, F > &A, unsigned int j)
Definition: matrix.hpp:861
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.
int test(Epsilon const &epsilon)
void lu_factorize(matrix< NumericT, viennacl::row_major > &A)
LU factorization of a row-major dense matrix.
Definition: lu.hpp:42
A tag class representing an upper triangular matrix with unit diagonal.
Definition: forwards.h:824
viennacl::vector< NumericT > solve(MatrixT const &A, viennacl::vector_base< NumericT > const &rhs, bicgstab_tag const &tag, viennacl::linalg::no_precond)
Implementation of a pipelined stabilized Bi-conjugate gradient solver.
Definition: bicgstab.hpp:88