ViennaCL - The Vienna Computing Library  1.5.2
scalar_operations.hpp
Go to the documentation of this file.
1 #ifndef VIENNACL_LINALG_HOST_BASED_SCALAR_OPERATIONS_HPP_
2 #define VIENNACL_LINALG_HOST_BASED_SCALAR_OPERATIONS_HPP_
3 
4 /* =========================================================================
5  Copyright (c) 2010-2014, Institute for Microelectronics,
6  Institute for Analysis and Scientific Computing,
7  TU Wien.
8  Portions of this software are copyright by UChicago Argonne, LLC.
9 
10  -----------------
11  ViennaCL - The Vienna Computing Library
12  -----------------
13 
14  Project Head: Karl Rupp rupp@iue.tuwien.ac.at
15 
16  (A list of authors and contributors can be found in the PDF manual)
17 
18  License: MIT (X11), see file LICENSE in the base directory
19 ============================================================================= */
20 
25 #include "viennacl/forwards.h"
26 #include "viennacl/tools/tools.hpp"
29 #include "viennacl/traits/size.hpp"
33 
34 namespace viennacl
35 {
36  namespace linalg
37  {
38  namespace host_based
39  {
40  template <typename S1,
41  typename S2, typename ScalarType1>
45  >::type
46  as(S1 & s1,
47  S2 const & s2, ScalarType1 const & alpha, vcl_size_t /*len_alpha*/, bool reciprocal_alpha, bool flip_sign_alpha)
48  {
49  typedef typename viennacl::result_of::cpu_value_type<S1>::type value_type;
50 
51  value_type * data_s1 = detail::extract_raw_pointer<value_type>(s1);
52  value_type const * data_s2 = detail::extract_raw_pointer<value_type>(s2);
53 
54  value_type data_alpha = alpha;
55  if (flip_sign_alpha)
56  data_alpha = -data_alpha;
57  if (reciprocal_alpha)
58  data_alpha = static_cast<value_type>(1) / data_alpha;
59 
60  *data_s1 = *data_s2 * data_alpha;
61  }
62 
63 
64  template <typename S1,
65  typename S2, typename ScalarType1,
66  typename S3, typename ScalarType2>
72  >::type
73  asbs(S1 & s1,
74  S2 const & s2, ScalarType1 const & alpha, vcl_size_t /*len_alpha*/, bool reciprocal_alpha, bool flip_sign_alpha,
75  S3 const & s3, ScalarType2 const & beta, vcl_size_t /*len_beta*/, bool reciprocal_beta, bool flip_sign_beta)
76  {
77  typedef typename viennacl::result_of::cpu_value_type<S1>::type value_type;
78 
79  value_type * data_s1 = detail::extract_raw_pointer<value_type>(s1);
80  value_type const * data_s2 = detail::extract_raw_pointer<value_type>(s2);
81  value_type const * data_s3 = detail::extract_raw_pointer<value_type>(s3);
82 
83  value_type data_alpha = alpha;
84  if (flip_sign_alpha)
85  data_alpha = -data_alpha;
86  if (reciprocal_alpha)
87  data_alpha = static_cast<value_type>(1) / data_alpha;
88 
89  value_type data_beta = beta;
90  if (flip_sign_beta)
91  data_beta = -data_beta;
92  if (reciprocal_beta)
93  data_beta = static_cast<value_type>(1) / data_beta;
94 
95  *data_s1 = *data_s2 * data_alpha + *data_s3 * data_beta;
96  }
97 
98 
99  template <typename S1,
100  typename S2, typename ScalarType1,
101  typename S3, typename ScalarType2>
107  >::type
108  asbs_s(S1 & s1,
109  S2 const & s2, ScalarType1 const & alpha, vcl_size_t /*len_alpha*/, bool reciprocal_alpha, bool flip_sign_alpha,
110  S3 const & s3, ScalarType2 const & beta, vcl_size_t /*len_beta*/, bool reciprocal_beta, bool flip_sign_beta)
111  {
112  typedef typename viennacl::result_of::cpu_value_type<S1>::type value_type;
113 
114  value_type * data_s1 = detail::extract_raw_pointer<value_type>(s1);
115  value_type const * data_s2 = detail::extract_raw_pointer<value_type>(s2);
116  value_type const * data_s3 = detail::extract_raw_pointer<value_type>(s3);
117 
118  value_type data_alpha = alpha;
119  if (flip_sign_alpha)
120  data_alpha = -data_alpha;
121  if (reciprocal_alpha)
122  data_alpha = static_cast<value_type>(1) / data_alpha;
123 
124  value_type data_beta = beta;
125  if (flip_sign_beta)
126  data_beta = -data_beta;
127  if (reciprocal_beta)
128  data_beta = static_cast<value_type>(1) / data_beta;
129 
130  *data_s1 += *data_s2 * data_alpha + *data_s3 * data_beta;
131  }
132 
133 
139  template <typename S1, typename S2>
142  >::type
143  swap(S1 & s1, S2 & s2)
144  {
145  typedef typename viennacl::result_of::cpu_value_type<S1>::type value_type;
146 
147  value_type * data_s1 = detail::extract_raw_pointer<value_type>(s1);
148  value_type * data_s2 = detail::extract_raw_pointer<value_type>(s2);
149 
150  value_type temp = *data_s2;
151  *data_s2 = *data_s1;
152  *data_s1 = temp;
153  }
154 
155 
156 
157  } //namespace host_based
158  } //namespace linalg
159 } //namespace viennacl
160 
161 
162 #endif
Simple enable-if variant that uses the SFINAE pattern.
Definition: enable_if.hpp:29
std::size_t vcl_size_t
Definition: forwards.h:58
Generic size and resize functionality for different vector and matrix types.
Extracts the underlying OpenCL start index handle from a vector, a matrix, an expression etc...
Various little tools used here and there in ViennaCL.
This file provides the forward declarations for the main types used within ViennaCL.
Determines row and column increments for matrices and matrix proxies.
viennacl::enable_if< viennacl::is_scalar< S1 >::value &&viennacl::is_scalar< S2 >::value &&viennacl::is_scalar< S3 >::value &&viennacl::is_any_scalar< ScalarType1 >::value &&viennacl::is_any_scalar< ScalarType2 >::value >::type asbs(S1 &s1, S2 const &s2, ScalarType1 const &alpha, vcl_size_t, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t, bool reciprocal_beta, bool flip_sign_beta)
Definition: scalar_operations.hpp:73
viennacl::enable_if< viennacl::is_scalar< S1 >::value &&viennacl::is_scalar< S2 >::value >::type swap(S1 &s1, S2 &s2)
Swaps the contents of two scalars, data is copied.
Definition: scalar_operations.hpp:143
Helper struct for checking whether the provided type represents a scalar (either host, from ViennaCL, or a flip-sign proxy)
Definition: forwards.h:384
viennacl::enable_if< viennacl::is_scalar< S1 >::value &&viennacl::is_scalar< S2 >::value &&viennacl::is_scalar< S3 >::value &&viennacl::is_any_scalar< ScalarType1 >::value &&viennacl::is_any_scalar< ScalarType2 >::value >::type asbs_s(S1 &s1, S2 const &s2, ScalarType1 const &alpha, vcl_size_t, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t, bool reciprocal_beta, bool flip_sign_beta)
Definition: scalar_operations.hpp:108
All the predicates used within ViennaCL. Checks for expressions to be vectors, etc.
Helper struct for checking whether a type is a viennacl::scalar<>
Definition: forwards.h:370
Common routines for single-threaded or OpenMP-enabled execution on CPU.
T::ERROR_CANNOT_DEDUCE_CPU_SCALAR_TYPE_FOR_T type
Definition: result_of.hpp:276
viennacl::enable_if< viennacl::is_scalar< S1 >::value &&viennacl::is_scalar< S2 >::value &&viennacl::is_any_scalar< ScalarType1 >::value >::type as(S1 &s1, S2 const &s2, ScalarType1 const &alpha, vcl_size_t, bool reciprocal_alpha, bool flip_sign_alpha)
Definition: scalar_operations.hpp:46
Simple enable-if variant that uses the SFINAE pattern.