ViennaCL - The Vienna Computing Library  1.5.1
viennacl/linalg/scalar_operations.hpp
Go to the documentation of this file.
00001 #ifndef VIENNACL_LINALG_SCALAR_OPERATIONS_HPP
00002 #define VIENNACL_LINALG_SCALAR_OPERATIONS_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/forwards.h"
00026 #include "viennacl/tools/tools.hpp"
00027 #include "viennacl/meta/predicate.hpp"
00028 #include "viennacl/meta/enable_if.hpp"
00029 #include "viennacl/traits/size.hpp"
00030 #include "viennacl/traits/start.hpp"
00031 #include "viennacl/traits/handle.hpp"
00032 #include "viennacl/traits/stride.hpp"
00033 #include "viennacl/linalg/host_based/scalar_operations.hpp"
00034 
00035 #ifdef VIENNACL_WITH_OPENCL
00036   #include "viennacl/linalg/opencl/scalar_operations.hpp"
00037 #endif
00038 
00039 #ifdef VIENNACL_WITH_CUDA
00040   #include "viennacl/linalg/cuda/scalar_operations.hpp"
00041 #endif
00042 
00043 
00044 
00045 namespace viennacl
00046 {
00047   namespace linalg
00048   {
00049 
00059     template <typename S1,
00060               typename S2, typename ScalarType1>
00061     typename viennacl::enable_if< viennacl::is_scalar<S1>::value
00062                                   && viennacl::is_scalar<S2>::value
00063                                   && viennacl::is_any_scalar<ScalarType1>::value
00064                                 >::type
00065     as(S1 & s1,
00066        S2 const & s2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
00067     {
00068       switch (viennacl::traits::handle(s1).get_active_handle_id())
00069       {
00070         case viennacl::MAIN_MEMORY:
00071           viennacl::linalg::host_based::as(s1, s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha);
00072           break;
00073 #ifdef VIENNACL_WITH_OPENCL
00074         case viennacl::OPENCL_MEMORY:
00075           viennacl::linalg::opencl::as(s1, s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha);
00076           break;
00077 #endif
00078 #ifdef VIENNACL_WITH_CUDA
00079         case viennacl::CUDA_MEMORY:
00080           viennacl::linalg::cuda::as(s1, s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha);
00081           break;
00082 #endif
00083         case viennacl::MEMORY_NOT_INITIALIZED:
00084           throw memory_exception("not initialised!");
00085         default:
00086           throw memory_exception("not implemented");
00087       }
00088     }
00089 
00090 
00105     template <typename S1,
00106               typename S2, typename ScalarType1,
00107               typename S3, typename ScalarType2>
00108     typename viennacl::enable_if< viennacl::is_scalar<S1>::value
00109                                   && viennacl::is_scalar<S2>::value
00110                                   && viennacl::is_scalar<S3>::value
00111                                   && viennacl::is_any_scalar<ScalarType1>::value
00112                                   && viennacl::is_any_scalar<ScalarType2>::value
00113                                 >::type
00114     asbs(S1 & s1,
00115          S2 const & s2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha,
00116          S3 const & s3, ScalarType2 const & beta,  vcl_size_t len_beta,  bool reciprocal_beta,  bool flip_sign_beta)
00117     {
00118       switch (viennacl::traits::handle(s1).get_active_handle_id())
00119       {
00120         case viennacl::MAIN_MEMORY:
00121           viennacl::linalg::host_based::asbs(s1,
00122                                              s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
00123                                              s3,  beta, len_beta,  reciprocal_beta,  flip_sign_beta);
00124           break;
00125 #ifdef VIENNACL_WITH_OPENCL
00126         case viennacl::OPENCL_MEMORY:
00127           viennacl::linalg::opencl::asbs(s1,
00128                                          s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
00129                                          s3,  beta, len_beta,  reciprocal_beta,  flip_sign_beta);
00130           break;
00131 #endif
00132 #ifdef VIENNACL_WITH_CUDA
00133         case viennacl::CUDA_MEMORY:
00134           viennacl::linalg::cuda::asbs(s1,
00135                                        s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
00136                                        s3,  beta, len_beta,  reciprocal_beta,  flip_sign_beta);
00137           break;
00138 #endif
00139         case viennacl::MEMORY_NOT_INITIALIZED:
00140           throw memory_exception("not initialised!");
00141         default:
00142           throw memory_exception("not implemented");
00143       }
00144     }
00145 
00146 
00161     template <typename S1,
00162               typename S2, typename ScalarType1,
00163               typename S3, typename ScalarType2>
00164     typename viennacl::enable_if< viennacl::is_scalar<S1>::value
00165                                   && viennacl::is_scalar<S2>::value
00166                                   && viennacl::is_scalar<S3>::value
00167                                   && viennacl::is_any_scalar<ScalarType1>::value
00168                                   && viennacl::is_any_scalar<ScalarType2>::value
00169                                 >::type
00170     asbs_s(S1 & s1,
00171            S2 const & s2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha,
00172            S3 const & s3, ScalarType2 const & beta,  vcl_size_t len_beta,  bool reciprocal_beta,  bool flip_sign_beta)
00173     {
00174       switch (viennacl::traits::handle(s1).get_active_handle_id())
00175       {
00176         case viennacl::MAIN_MEMORY:
00177           viennacl::linalg::host_based::asbs_s(s1,
00178                                                s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
00179                                                s3,  beta, len_beta,  reciprocal_beta,  flip_sign_beta);
00180           break;
00181 #ifdef VIENNACL_WITH_OPENCL
00182         case viennacl::OPENCL_MEMORY:
00183           viennacl::linalg::opencl::asbs_s(s1,
00184                                            s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
00185                                            s3,  beta, len_beta,  reciprocal_beta,  flip_sign_beta);
00186           break;
00187 #endif
00188 #ifdef VIENNACL_WITH_CUDA
00189         case viennacl::CUDA_MEMORY:
00190           viennacl::linalg::cuda::asbs_s(s1,
00191                                          s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
00192                                          s3,  beta, len_beta,  reciprocal_beta,  flip_sign_beta);
00193           break;
00194 #endif
00195         case viennacl::MEMORY_NOT_INITIALIZED:
00196           throw memory_exception("not initialised!");
00197         default:
00198           throw memory_exception("not implemented");
00199       }
00200     }
00201 
00202 
00203 
00209     template <typename S1, typename S2>
00210     typename viennacl::enable_if<    viennacl::is_scalar<S1>::value
00211                                   && viennacl::is_scalar<S2>::value
00212                                 >::type
00213     swap(S1 & s1, S2 & s2)
00214     {
00215       switch (viennacl::traits::handle(s1).get_active_handle_id())
00216       {
00217         case viennacl::MAIN_MEMORY:
00218           viennacl::linalg::host_based::swap(s1, s2);
00219           break;
00220 #ifdef VIENNACL_WITH_OPENCL
00221         case viennacl::OPENCL_MEMORY:
00222           viennacl::linalg::opencl::swap(s1, s2);
00223           break;
00224 #endif
00225 #ifdef VIENNACL_WITH_CUDA
00226         case viennacl::CUDA_MEMORY:
00227           viennacl::linalg::cuda::swap(s1, s2);
00228           break;
00229 #endif
00230         case viennacl::MEMORY_NOT_INITIALIZED:
00231           throw memory_exception("not initialised!");
00232         default:
00233           throw memory_exception("not implemented");
00234       }
00235     }
00236 
00237 
00238   } //namespace linalg
00239 } //namespace viennacl
00240 
00241 
00242 #endif