All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
external_1.cpp
Go to the documentation of this file.
/* =========================================================================
Copyright (c) 2010-2016, Institute for Microelectronics,
Institute for Analysis and Scientific Computing,
TU Wien.
Portions of this software are copyright by UChicago Argonne, LLC.
-----------------
ViennaCL - The Vienna Computing Library
-----------------
Project Head: Karl Rupp rupp@iue.tuwien.ac.at
(A list of authors and contributors can be found in the PDF manual)
License: MIT (X11), see file LICENSE in the base directory
============================================================================= */
//#define VIENNACL_WITH_EIGEN
#define VIENNACL_WITH_UBLAS
//
// *** System
//
#include <iostream>
//
// *** ViennaCL
//
#include "viennacl/scalar.hpp"
#include "viennacl/vector.hpp"
#include "viennacl/matrix.hpp"
#include "viennacl/compressed_matrix.hpp"
#include "viennacl/coordinate_matrix.hpp"
#include "viennacl/ell_matrix.hpp"
#include "viennacl/fft.hpp"
#include "viennacl/hyb_matrix.hpp"
#include "viennacl/sliced_ell_matrix.hpp"
#ifdef VIENNACL_WITH_OPENCL
#include "viennacl/circulant_matrix.hpp"
#include "viennacl/hankel_matrix.hpp"
#include "viennacl/toeplitz_matrix.hpp"
#include "viennacl/vandermonde_matrix.hpp"
#endif
#include "viennacl/linalg/bicgstab.hpp"
#include "viennacl/linalg/bisect.hpp"
#include "viennacl/linalg/bisect_gpu.hpp"
#include "viennacl/linalg/cg.hpp"
#include "viennacl/linalg/direct_solve.hpp"
#include "viennacl/linalg/gmres.hpp"
#include "viennacl/linalg/ichol.hpp"
#include "viennacl/linalg/ilu.hpp"
#include "viennacl/linalg/inner_prod.hpp"
#include "viennacl/linalg/jacobi_precond.hpp"
#include "viennacl/linalg/norm_1.hpp"
#include "viennacl/linalg/norm_2.hpp"
#include "viennacl/linalg/norm_inf.hpp"
#include "viennacl/linalg/norm_frobenius.hpp"
#include "viennacl/linalg/lanczos.hpp"
#include "viennacl/linalg/qr.hpp"
#include "viennacl/linalg/qr-method.hpp"
#include "viennacl/linalg/row_scaling.hpp"
#include "viennacl/linalg/sum.hpp"
#include "viennacl/linalg/tql2.hpp"
#include "viennacl/misc/bandwidth_reduction.hpp"
#ifdef VIENNACL_WITH_OPENCL
#include "viennacl/linalg/amg.hpp"
#include "viennacl/linalg/spai.hpp"
#include "viennacl/linalg/svd.hpp"
#include "viennacl/device_specific/execute.hpp"
#endif
#include "viennacl/io/matrix_market.hpp"
#include "viennacl/scheduler/execute.hpp"
//defined in external_2.cpp
void other_func();
//
// -------------------------------------------------------------
//
int main()
{
typedef float NumericType;
//doing nothing but instantiating a few types
viennacl::scalar<NumericType> s;
viennacl::vector<NumericType> v(10);
viennacl::matrix<NumericType> m(10, 10);
viennacl::compressed_matrix<NumericType> compr(10, 10);
viennacl::coordinate_matrix<NumericType> coord(10, 10);
//this is the external linkage check:
other_func();
std::cout << std::endl;
std::cout << "------- Test completed --------" << std::endl;
std::cout << std::endl;
return EXIT_SUCCESS;
}
matrix_market.hpp
A reader and writer for the matrix market format is implemented here.
viennacl::scalar
This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type...
Definition: forwards.h:227
norm_2.hpp
Generic interface for the l^2-norm. See viennacl/linalg/vector_operations.hpp for implementations...
matrix.hpp
Implementation of the dense matrix class.
bicgstab.hpp
The stabilized bi-conjugate gradient method is implemented here.
ichol.hpp
Implementations of incomplete Cholesky factorization preconditioners with static nonzero pattern...
tql2.hpp
Implementation of the tql2-algorithm for eigenvalue computations.
bandwidth_reduction.hpp
Convenience include for bandwidth reduction algorithms such as Cuthill-McKee or Gibbs-Poole-Stockmeye...
viennacl::matrix
A dense matrix class.
Definition: forwards.h:375
other_func
void other_func()
Definition: external_2.cpp:85
jacobi_precond.hpp
Implementation of a simple Jacobi preconditioner.
inner_prod.hpp
Generic interface for the computation of inner products. See viennacl/linalg/vector_operations.hpp for implementations.
bisect_gpu.hpp
Implementation of an bisection algorithm for eigenvalues.
norm_1.hpp
Generic interface for the l^1-norm. See viennacl/linalg/vector_operations.hpp for implementations...
coordinate_matrix.hpp
Implementation of the coordinate_matrix class.
main
int main()
Definition: external_1.cpp:92
hyb_matrix.hpp
Implementation of the hyb_matrix class.
gmres.hpp
Implementations of the generalized minimum residual method are in this file.
ilu.hpp
Implementations of incomplete factorization preconditioners. Convenience header file.
hankel_matrix.hpp
Implementation of the hankel_matrix class for efficient manipulation of Hankel matrices. Experimental.
norm_frobenius.hpp
Generic interface for the Frobenius norm.
execute.hpp
the user interface for the code generator
circulant_matrix.hpp
Implementation of the circulant_matrix class for efficient manipulation of circulant matrices...
compressed_matrix.hpp
Implementation of the compressed_matrix class.
sliced_ell_matrix.hpp
Implementation of the sliced_ell_matrix class.
amg.hpp
Main include file for algebraic multigrid (AMG) preconditioners. Experimental.
qr.hpp
Provides a QR factorization using a block-based approach.
cg.hpp
The conjugate gradient method is implemented here.
ell_matrix.hpp
Implementation of the ell_matrix class.
viennacl::vector< NumericType >
row_scaling.hpp
A row normalization preconditioner is implemented here.
direct_solve.hpp
Implementations of dense direct solvers are found here.
svd.hpp
Provides singular value decomposition using a block-based approach. Experimental. ...
qr-method.hpp
Implementation of the QR method for eigenvalue computations. Experimental.
vandermonde_matrix.hpp
Implementation of the vandermonde_matrix class for efficient manipulation of Vandermonde matrices...
sum.hpp
Stub routines for the summation of elements in a vector, or all elements in either a row or column of...
vector.hpp
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
fft.hpp
All routines related to the Fast Fourier Transform. Experimental.
execute.hpp
Provides the datastructures for dealing with a single statement such as 'x = y + z;'.
spai.hpp
Main include file for the sparse approximate inverse preconditioner family (SPAI and FSPAI)...
viennacl::compressed_matrix< NumericType >
bisect.hpp
Implementation of the algorithm for finding eigenvalues of a tridiagonal matrix.
scalar.hpp
Implementation of the ViennaCL scalar class.
norm_inf.hpp
Generic interface for the l^infty-norm. See viennacl/linalg/vector_operations.hpp for implementations...
toeplitz_matrix.hpp
Implementation of the toeplitz_matrix class for efficient manipulation of Toeplitz matrices...
viennacl::coordinate_matrix
A sparse square matrix, where entries are stored as triplets (i,j, val), where i and j are the row an...
Definition: coordinate_matrix.hpp:186
lanczos.hpp
Generic interface for the Lanczos algorithm.