30 #include <Eigen/Sparse>
33 #define VIENNACL_WITH_EIGEN 1
46 #include "../benchmarks/benchmark-utils.hpp"
55 struct Eigen_dense_matrix
57 typedef typename T::ERROR_NO_EIGEN_TYPE_AVAILABLE error_type;
61 struct Eigen_dense_matrix<float>
63 typedef Eigen::MatrixXf type;
67 struct Eigen_dense_matrix<double>
69 typedef Eigen::MatrixXd type;
77 typedef typename T::ERROR_NO_EIGEN_TYPE_AVAILABLE error_type;
81 struct Eigen_vector<float>
83 typedef Eigen::VectorXf type;
87 struct Eigen_vector<double>
89 typedef Eigen::VectorXd type;
104 template<
typename ScalarType>
111 typedef typename Eigen_dense_matrix<ScalarType>::type EigenMatrix;
112 typedef typename Eigen_vector<ScalarType>::type EigenVector;
117 EigenMatrix eigen_densemat(6, 5);
118 EigenMatrix eigen_densemat2(6, 5);
119 eigen_densemat(0,0) = 2.0; eigen_densemat(0,1) = -1.0;
120 eigen_densemat(1,0) = -1.0; eigen_densemat(1,1) = 2.0; eigen_densemat(1,2) = -1.0;
121 eigen_densemat(2,1) = -1.0; eigen_densemat(2,2) = -1.0; eigen_densemat(2,3) = -1.0;
122 eigen_densemat(3,2) = -1.0; eigen_densemat(3,3) = 2.0; eigen_densemat(3,4) = -1.0;
123 eigen_densemat(5,4) = -1.0; eigen_densemat(4,4) = -1.0;
128 Eigen::SparseMatrix<ScalarType, Eigen::RowMajor> eigen_sparsemat(6, 5);
129 Eigen::SparseMatrix<ScalarType, Eigen::RowMajor> eigen_sparsemat2(6, 5);
130 eigen_sparsemat.reserve(5*2);
131 eigen_sparsemat.insert(0,0) = 2.0; eigen_sparsemat.insert(0,1) = -1.0;
132 eigen_sparsemat.insert(1,1) = 2.0; eigen_sparsemat.insert(1,2) = -1.0;
133 eigen_sparsemat.insert(2,2) = -1.0; eigen_sparsemat.insert(2,3) = -1.0;
134 eigen_sparsemat.insert(3,3) = 2.0; eigen_sparsemat.insert(3,4) = -1.0;
135 eigen_sparsemat.insert(5,4) = -1.0;
141 EigenVector eigen_rhs(5);
142 EigenVector eigen_result(6);
143 EigenVector eigen_temp(6);
164 viennacl::copy(&(eigen_rhs[0]), &(eigen_rhs[0]) + 5, vcl_rhs.begin());
169 std::cout <<
"VCL sparsematrix dimensions: " << vcl_sparsemat.size1() <<
", " << vcl_sparsemat.size2() << std::endl;
179 eigen_result = eigen_densemat * eigen_rhs;
182 std::cout <<
"Difference for dense matrix-vector product: " << (eigen_result - eigen_temp).norm() << std::endl;
183 std::cout <<
"Difference for dense matrix-vector product (Eigen->ViennaCL->Eigen): "
184 << (eigen_densemat2 * eigen_rhs - eigen_temp).norm() << std::endl;
189 eigen_result = eigen_sparsemat * eigen_rhs;
192 std::cout <<
"Difference for sparse matrix-vector product: " << (eigen_result - eigen_temp).norm() << std::endl;
193 std::cout <<
"Difference for sparse matrix-vector product (Eigen->ViennaCL->Eigen): "
194 << (eigen_sparsemat2 * eigen_rhs - eigen_temp).norm() << std::endl;
201 int main(
int,
char *[])
203 std::cout <<
"----------------------------------------------" << std::endl;
204 std::cout <<
"## Single precision" << std::endl;
205 std::cout <<
"----------------------------------------------" << std::endl;
206 run_tutorial<float>();
208 #ifdef VIENNACL_HAVE_OPENCL
212 std::cout <<
"----------------------------------------------" << std::endl;
213 std::cout <<
"## Double precision" << std::endl;
214 std::cout <<
"----------------------------------------------" << std::endl;
215 run_tutorial<double>();
221 std::cout << std::endl;
222 std::cout <<
"!!!! TUTORIAL COMPLETED SUCCESSFULLY !!!!" << std::endl;
223 std::cout << std::endl;
Generic interface for matrix-vector and matrix-matrix products. See viennacl/linalg/vector_operations...
Implementation of the dense matrix class.
viennacl::ocl::device const & current_device()
Convenience function for returning the active device in the current context.
VectorT prod(std::vector< std::vector< T, A1 >, A2 > const &matrix, VectorT const &vector)
Implementation of the compressed_matrix class.
bool double_support() const
ViennaCL convenience function: Returns true if the device supports double precision.
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
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 sparse square matrix in compressed sparse rows format.