ViennaCL - The Vienna Computing Library  1.5.1
viennacl/linalg/host_based/scalar_operations.hpp
Go to the documentation of this file.
00001 #ifndef VIENNACL_LINALG_HOST_BASED_SCALAR_OPERATIONS_HPP_
00002 #define VIENNACL_LINALG_HOST_BASED_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/stride.hpp"
00032 #include "viennacl/linalg/host_based/common.hpp"
00033 
00034 namespace viennacl
00035 {
00036   namespace linalg
00037   {
00038     namespace host_based
00039     {
00040       template <typename S1,
00041                 typename S2, typename ScalarType1>
00042       typename viennacl::enable_if< viennacl::is_scalar<S1>::value
00043                                     && viennacl::is_scalar<S2>::value
00044                                     && viennacl::is_any_scalar<ScalarType1>::value
00045                                   >::type
00046       as(S1 & s1,
00047          S2 const & s2, ScalarType1 const & alpha, vcl_size_t /*len_alpha*/, bool reciprocal_alpha, bool flip_sign_alpha)
00048       {
00049         typedef typename viennacl::result_of::cpu_value_type<S1>::type        value_type;
00050 
00051         value_type       * data_s1 = detail::extract_raw_pointer<value_type>(s1);
00052         value_type const * data_s2 = detail::extract_raw_pointer<value_type>(s2);
00053 
00054         value_type data_alpha = alpha;
00055         if (flip_sign_alpha)
00056           data_alpha = -data_alpha;
00057         if (reciprocal_alpha)
00058           data_alpha = static_cast<value_type>(1) / data_alpha;
00059 
00060         *data_s1 = *data_s2 * data_alpha;
00061       }
00062 
00063 
00064       template <typename S1,
00065                 typename S2, typename ScalarType1,
00066                 typename S3, typename ScalarType2>
00067       typename viennacl::enable_if< viennacl::is_scalar<S1>::value
00068                                     && viennacl::is_scalar<S2>::value
00069                                     && viennacl::is_scalar<S3>::value
00070                                     && viennacl::is_any_scalar<ScalarType1>::value
00071                                     && viennacl::is_any_scalar<ScalarType2>::value
00072                                   >::type
00073       asbs(S1 & s1,
00074            S2 const & s2, ScalarType1 const & alpha, vcl_size_t /*len_alpha*/, bool reciprocal_alpha, bool flip_sign_alpha,
00075            S3 const & s3, ScalarType2 const & beta,  vcl_size_t /*len_beta*/,  bool reciprocal_beta,  bool flip_sign_beta)
00076       {
00077         typedef typename viennacl::result_of::cpu_value_type<S1>::type        value_type;
00078 
00079         value_type       * data_s1 = detail::extract_raw_pointer<value_type>(s1);
00080         value_type const * data_s2 = detail::extract_raw_pointer<value_type>(s2);
00081         value_type const * data_s3 = detail::extract_raw_pointer<value_type>(s3);
00082 
00083         value_type data_alpha = alpha;
00084         if (flip_sign_alpha)
00085           data_alpha = -data_alpha;
00086         if (reciprocal_alpha)
00087           data_alpha = static_cast<value_type>(1) / data_alpha;
00088 
00089         value_type data_beta = beta;
00090         if (flip_sign_beta)
00091           data_beta = -data_beta;
00092         if (reciprocal_beta)
00093           data_beta = static_cast<value_type>(1) / data_beta;
00094 
00095         *data_s1 = *data_s2 * data_alpha + *data_s3 * data_beta;
00096       }
00097 
00098 
00099       template <typename S1,
00100                 typename S2, typename ScalarType1,
00101                 typename S3, typename ScalarType2>
00102       typename viennacl::enable_if< viennacl::is_scalar<S1>::value
00103                                     && viennacl::is_scalar<S2>::value
00104                                     && viennacl::is_scalar<S3>::value
00105                                     && viennacl::is_any_scalar<ScalarType1>::value
00106                                     && viennacl::is_any_scalar<ScalarType2>::value
00107                                   >::type
00108       asbs_s(S1 & s1,
00109              S2 const & s2, ScalarType1 const & alpha, vcl_size_t /*len_alpha*/, bool reciprocal_alpha, bool flip_sign_alpha,
00110              S3 const & s3, ScalarType2 const & beta,  vcl_size_t /*len_beta*/,  bool reciprocal_beta,  bool flip_sign_beta)
00111       {
00112         typedef typename viennacl::result_of::cpu_value_type<S1>::type        value_type;
00113 
00114         value_type       * data_s1 = detail::extract_raw_pointer<value_type>(s1);
00115         value_type const * data_s2 = detail::extract_raw_pointer<value_type>(s2);
00116         value_type const * data_s3 = detail::extract_raw_pointer<value_type>(s3);
00117 
00118         value_type data_alpha = alpha;
00119         if (flip_sign_alpha)
00120           data_alpha = -data_alpha;
00121         if (reciprocal_alpha)
00122           data_alpha = static_cast<value_type>(1) / data_alpha;
00123 
00124         value_type data_beta = beta;
00125         if (flip_sign_beta)
00126           data_beta = -data_beta;
00127         if (reciprocal_beta)
00128           data_beta = static_cast<value_type>(1) / data_beta;
00129 
00130         *data_s1 += *data_s2 * data_alpha + *data_s3 * data_beta;
00131       }
00132 
00133 
00139       template <typename S1, typename S2>
00140       typename viennacl::enable_if<    viennacl::is_scalar<S1>::value
00141                                     && viennacl::is_scalar<S2>::value
00142                                   >::type
00143       swap(S1 & s1, S2 & s2)
00144       {
00145         typedef typename viennacl::result_of::cpu_value_type<S1>::type        value_type;
00146 
00147         value_type * data_s1 = detail::extract_raw_pointer<value_type>(s1);
00148         value_type * data_s2 = detail::extract_raw_pointer<value_type>(s2);
00149 
00150         value_type temp = *data_s2;
00151         *data_s2 = *data_s1;
00152         *data_s1 = temp;
00153       }
00154 
00155 
00156 
00157     } //namespace host_based
00158   } //namespace linalg
00159 } //namespace viennacl
00160 
00161 
00162 #endif