ViennaCL - The Vienna Computing Library: examples/tutorial/least-squares.cpp Source File

ViennaCL - The Vienna Computing Library 1.7.1 Free open-source GPU-accelerated linear algebra and solver library. |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
least-squares.cpp
Go to the documentation of this file.
1 /* =========================================================================
2 Copyright (c) 2010-2016, 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
25 // activate ublas support in ViennaCL
26 #define VIENNACL_WITH_UBLAS
27
28 //
29 // include necessary system headers
30 //
31 #include <iostream>
32
33 // Boost headers
34 #include <boost/numeric/ublas/triangular.hpp>
35 #include <boost/numeric/ublas/vector.hpp>
36 #include <boost/numeric/ublas/vector_proxy.hpp>
37 #include <boost/numeric/ublas/matrix.hpp>
38 #include <boost/numeric/ublas/matrix_proxy.hpp>
39 #include <boost/numeric/ublas/lu.hpp>
40 #include <boost/numeric/ublas/io.hpp>
41
42
43 // ViennaCL headers
44 #include "viennacl/vector.hpp"
45 #include "viennacl/matrix.hpp"
46 #include "viennacl/matrix_proxy.hpp"
47 #include "viennacl/linalg/qr.hpp"
48 #include "viennacl/linalg/lu.hpp"
49 #include "viennacl/linalg/direct_solve.hpp"
50
51
59 int main (int, const char **)
60 {
61 typedef float ScalarType; //feel free to change this to 'double' if supported by your hardware
62
63 typedef boost::numeric::ublas::matrix<ScalarType> MatrixType;
64 typedef boost::numeric::ublas::vector<ScalarType> VectorType;
65 typedef viennacl::matrix<ScalarType, viennacl::column_major> VCLMatrixType;
66 typedef viennacl::vector<ScalarType> VCLVectorType;
67
71 VectorType ublas_b(4);
72 ublas_b(0) = -4;
73 ublas_b(1) = 2;
74 ublas_b(2) = 5;
75 ublas_b(3) = -1;
76
77 MatrixType ublas_A(4, 3);
78
79 ublas_A(0, 0) = 2; ublas_A(0, 1) = -1; ublas_A(0, 2) = 1;
80 ublas_A(1, 0) = 1; ublas_A(1, 1) = -5; ublas_A(1, 2) = 2;
81 ublas_A(2, 0) = -3; ublas_A(2, 1) = 1; ublas_A(2, 2) = -4;
82 ublas_A(3, 0) = 1; ublas_A(3, 1) = -1; ublas_A(3, 2) = 1;
83
87 VCLVectorType vcl_b(ublas_b.size());
88 VCLMatrixType vcl_A(ublas_A.size1(), ublas_A.size2());
89
90 viennacl::copy(ublas_b, vcl_b);
91 viennacl::copy(ublas_A, vcl_A);
92
93
101 std::cout << "--- Boost.uBLAS ---" << std::endl;
107 std::vector<ScalarType> ublas_betas = viennacl::linalg::inplace_qr(ublas_A);
108
113 viennacl::linalg::inplace_qr_apply_trans_Q(ublas_A, ublas_betas, ublas_b);
114
119 boost::numeric::ublas::range ublas_range(0, 3);
120 boost::numeric::ublas::matrix_range<MatrixType> ublas_R(ublas_A, ublas_range, ublas_range);
121 boost::numeric::ublas::vector_range<VectorType> ublas_b2(ublas_b, ublas_range);
122 boost::numeric::ublas::inplace_solve(ublas_R, ublas_b2, boost::numeric::ublas::upper_tag());
123
124 std::cout << "Result: " << ublas_b2 << std::endl;
125
133 std::cout << "--- ViennaCL (hybrid implementation) ---" << std::endl;
134 std::vector<ScalarType> hybrid_betas = viennacl::linalg::inplace_qr(vcl_A);
135
139 viennacl::linalg::inplace_qr_apply_trans_Q(vcl_A, hybrid_betas, vcl_b);
140
145 viennacl::range vcl_range(0, 3);
146 viennacl::matrix_range<VCLMatrixType> vcl_R(vcl_A, vcl_range, vcl_range);
147 viennacl::vector_range<VCLVectorType> vcl_b2(vcl_b, vcl_range);
148 viennacl::linalg::inplace_solve(vcl_R, vcl_b2, viennacl::linalg::upper_tag());
149
150 std::cout << "Result: " << vcl_b2 << std::endl;
151
155 std::cout << "!!!! TUTORIAL COMPLETED SUCCESSFULLY !!!!" << std::endl;
156
157 return EXIT_SUCCESS;
158 }
159
vcl_b
endcode *compute modified RHS of the minimization vcl_b
Definition: least-squares.cpp:139
viennacl::linalg::cuda::inplace_solve
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...
Definition: direct_solve.hpp:253
viennacl::linalg::inplace_solve
void inplace_solve(const matrix_base< NumericT > &A, matrix_base< NumericT > &B, SolverTagT)
Direct inplace solver for triangular systems with multiple right hand sides, i.e. A \ B (MATLAB notat...
Definition: direct_solve.hpp:217
viennacl::linalg::inplace_qr
std::vector< T > inplace_qr(viennacl::matrix< T, F, ALIGNMENT > &A, vcl_size_t block_size=16)
Overload of inplace-QR factorization of a ViennaCL matrix A.
Definition: qr.hpp:647
matrix.hpp
Implementation of the dense matrix class.
vcl_R
endcode *Final viennacl::matrix_range< VCLMatrixType > vcl_R(vcl_A, vcl_range, vcl_range)
main
int main()
Definition: bisect.cpp:91
viennacl::matrix
A dense matrix class.
Definition: forwards.h:375
viennacl::range
basic_range range
Definition: forwards.h:424
hybrid_betas
std::cout<< "--- ViennaCL (hybrid implementation) ---"<< std::endl;std::vector< ScalarType > hybrid_betas
Definition: least-squares.cpp:134
viennacl::vector_range
Class for representing non-strided subvectors of a bigger vector x.
Definition: forwards.h:434
viennacl::linalg::upper_tag
A tag class representing an upper triangular matrix.
Definition: forwards.h:854
qr.hpp
Provides a QR factorization using a block-based approach.
viennacl::vector< ScalarType >
vcl_b2
viennacl::vector_range< VCLVectorType > vcl_b2(vcl_b, vcl_range)
lu.hpp
Implementations of LU factorization for row-major and column-major dense matrices.
direct_solve.hpp
Implementations of dense direct solvers are found here.
matrix_proxy.hpp
Proxy classes for matrices.
vector.hpp
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
viennacl::copy
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) ...
Definition: circulant_matrix.hpp:150
viennacl::basic_range
A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
Definition: forwards.h:424
ScalarType
float ScalarType
Definition: fft_1d.cpp:42
viennacl::matrix_range
Class for representing non-strided submatrices of a bigger matrix A.
Definition: forwards.h:440
viennacl::linalg::inplace_qr_apply_trans_Q
void inplace_qr_apply_trans_Q(MatrixType const &A, VectorType1 const &betas, VectorType2 &b)
Computes Q^T b, where Q is an implicit orthogonal matrix defined via its Householder reflectors store...
Definition: qr.hpp:608