34 #ifdef VIENNACL_WITH_OPENCL 
   44   template <
typename NumericT>
 
   59     size_type A_size1 = 
static_cast<size_type
>((transA == 
ViennaCLTrans) ? k : m);
 
   60     size_type A_size2 = 
static_cast<size_type
>((transA == 
ViennaCLTrans) ? m : k);
 
   62     size_type B_size1 = 
static_cast<size_type
>((transB == 
ViennaCLTrans) ? n : k);
 
   63     size_type B_size2 = 
static_cast<size_type
>((transB == 
ViennaCLTrans) ? k : n);
 
   70                                          A_size1, size_type(offA_row), difference_type(incA_row), size_type(A_row_major ? m : lda),
 
   71                                          A_size2, size_type(offA_col), difference_type(incA_col), size_type(A_row_major ? lda : k), A_row_major);
 
   74                                          B_size1, size_type(offB_row), difference_type(incB_row), size_type(B_row_major ? k : ldb),
 
   75                                          B_size2, size_type(offB_col), difference_type(incB_col), size_type(B_row_major ? ldb : n), B_row_major);
 
   78                                          size_type(m), size_type(offC_row), difference_type(incC_row), size_type(C_row_major ? m : ldc),
 
   79                                          size_type(n), size_type(offC_col), difference_type(incC_col), size_type(C_row_major ? ldc : n), C_row_major);
 
  100   return detail::ViennaCLOpenCLgemm_impl<float>(backend,
 
  106                                                 A, offA_row, offA_col, incA_row, incA_col, lda,
 
  107                                                 B, offB_row, offB_col, incB_row, incB_col, ldb,
 
  109                                                 C, offC_row, offC_col, incC_row, incC_col, ldc);
 
  123   return detail::ViennaCLOpenCLgemm_impl<double>(backend,
 
  129                                                  A, offA_row, offA_col, incA_row, incA_col, lda,
 
  130                                                  B, offB_row, offB_col, incB_row, incB_col, ldb,
 
  132                                                  C, offC_row, offC_col, incC_row, incC_col, ldc);
 
Generic backend for CUDA, OpenCL, host-based stuff. 
void gemm_dispatch(ScalarType alpha, MatrixTypeA const &A, ViennaCLTranspose transA, MatrixTypeB const &B, ViennaCLTranspose transB, ScalarType beta, MatrixTypeC &C)
Generic interface for matrix-vector and matrix-matrix products. See viennacl/linalg/vector_operations...
Implementation of the dense matrix class. 
#define VIENNACL_EXPORTED_FUNCTION
ViennaCLOpenCLBackend_impl opencl_backend
Implementations of dense direct solvers are found here. 
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
viennacl::ocl::context & get_context(long i)
Convenience function for returning the current context. 
Implementation of the ViennaCL scalar class.