ViennaCL - The Vienna Computing Library  1.5.2
viennacl/linalg/host_based/common.hpp
Go to the documentation of this file.
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