ViennaCL - The Vienna Computing Library
1.5.2
|
00001 #ifndef VIENNACL_LINALG_HOST_BASED_COMMON_HPP_ 00002 #define VIENNACL_LINALG_HOST_BASED_COMMON_HPP_ 00003 00004 /* ========================================================================= 00005 Copyright (c) 2010-2014, Institute for Microelectronics, 00006 Institute for Analysis and Scientific Computing, 00007 TU Wien. 00008 Portions of this software are copyright by UChicago Argonne, LLC. 00009 00010 ----------------- 00011 ViennaCL - The Vienna Computing Library 00012 ----------------- 00013 00014 Project Head: Karl Rupp rupp@iue.tuwien.ac.at 00015 00016 (A list of authors and contributors can be found in the PDF manual) 00017 00018 License: MIT (X11), see file LICENSE in the base directory 00019 ============================================================================= */ 00020 00025 #include "viennacl/traits/handle.hpp" 00026 00027 namespace viennacl 00028 { 00029 namespace linalg 00030 { 00031 namespace host_based 00032 { 00033 namespace detail 00034 { 00035 template <typename T, typename VectorType> 00036 T * extract_raw_pointer(VectorType & vec) 00037 { 00038 return reinterpret_cast<T *>(viennacl::traits::ram_handle(vec).get()); 00039 } 00040 00041 template <typename T, typename VectorType> 00042 T const * extract_raw_pointer(VectorType const & vec) 00043 { 00044 return reinterpret_cast<T const *>(viennacl::traits::ram_handle(vec).get()); 00045 } 00046 00048 template <typename NumericT> 00049 class vector_array_wrapper 00050 { 00051 public: 00052 typedef NumericT value_type; 00053 00054 vector_array_wrapper(value_type * A, 00055 vcl_size_t start, 00056 vcl_size_t inc) 00057 : A_(A), 00058 start_(start), 00059 inc_(inc) {} 00060 00061 value_type & operator()(vcl_size_t i) 00062 { 00063 return A_[i * inc_ + start_]; 00064 } 00065 00066 private: 00067 value_type * A_; 00068 vcl_size_t start_; 00069 vcl_size_t inc_; 00070 }; 00071 00072 00074 template <typename NumericT, typename F, bool is_transposed> 00075 class matrix_array_wrapper 00076 { 00077 public: 00078 typedef NumericT value_type; 00079 00080 matrix_array_wrapper(value_type * A, 00081 vcl_size_t start1, vcl_size_t start2, 00082 vcl_size_t inc1, vcl_size_t inc2, 00083 vcl_size_t internal_size1, vcl_size_t internal_size2) 00084 : A_(A), 00085 start1_(start1), start2_(start2), 00086 inc1_(inc1), inc2_(inc2), 00087 internal_size1_(internal_size1), internal_size2_(internal_size2) {} 00088 00089 value_type & operator()(vcl_size_t i, vcl_size_t j) 00090 { 00091 return A_[F::mem_index(i * inc1_ + start1_, j * inc2_ + start2_, internal_size1_, internal_size2_)]; 00092 } 00093 00094 // convenience overloads to address signed index types for OpenMP: 00095 value_type & operator()(vcl_size_t i, long j) { return operator()(i, static_cast<vcl_size_t>(j)); } 00096 value_type & operator()(long i, vcl_size_t j) { return operator()(static_cast<vcl_size_t>(i), j); } 00097 value_type & operator()(long i, long j) { return operator()(static_cast<vcl_size_t>(i), static_cast<vcl_size_t>(j)); } 00098 00099 private: 00100 value_type * A_; 00101 vcl_size_t start1_, start2_; 00102 vcl_size_t inc1_, inc2_; 00103 vcl_size_t internal_size1_, internal_size2_; 00104 }; 00105 00107 template <typename NumericT, typename F> 00108 class matrix_array_wrapper<NumericT, F, true> 00109 { 00110 public: 00111 typedef NumericT value_type; 00112 00113 matrix_array_wrapper(value_type * A, 00114 vcl_size_t start1, vcl_size_t start2, 00115 vcl_size_t inc1, vcl_size_t inc2, 00116 vcl_size_t internal_size1, vcl_size_t internal_size2) 00117 : A_(A), 00118 start1_(start1), start2_(start2), 00119 inc1_(inc1), inc2_(inc2), 00120 internal_size1_(internal_size1), internal_size2_(internal_size2) {} 00121 00122 value_type & operator()(vcl_size_t i, vcl_size_t j) 00123 { 00124 return A_[F::mem_index(j * inc1_ + start1_, i * inc2_ + start2_, internal_size1_, internal_size2_)]; //swapping row and column indices here 00125 } 00126 00127 // convenience overloads to address signed index types for OpenMP: 00128 value_type & operator()(vcl_size_t i, long j) { return operator()(i, static_cast<vcl_size_t>(j)); } 00129 value_type & operator()(long i, vcl_size_t j) { return operator()(static_cast<vcl_size_t>(i), j); } 00130 value_type & operator()(long i, long j) { return operator()(static_cast<vcl_size_t>(i), static_cast<vcl_size_t>(j)); } 00131 00132 private: 00133 value_type * A_; 00134 vcl_size_t start1_, start2_; 00135 vcl_size_t inc1_, inc2_; 00136 vcl_size_t internal_size1_, internal_size2_; 00137 }; 00140 } 00141 00142 } //namespace host_based 00143 } //namespace linalg 00144 } //namespace viennacl 00145 00146 00147 #endif