ViennaCL - The Vienna Computing Library  1.5.1
scalar_operations.hpp
Go to the documentation of this file.
1 #ifndef VIENNACL_LINALG_SCALAR_OPERATIONS_HPP
2 #define VIENNACL_LINALG_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"
34 
35 #ifdef VIENNACL_WITH_OPENCL
37 #endif
38 
39 #ifdef VIENNACL_WITH_CUDA
41 #endif
42 
43 
44 
45 namespace viennacl
46 {
47  namespace linalg
48  {
49 
59  template <typename S1,
60  typename S2, typename ScalarType1>
64  >::type
65  as(S1 & s1,
66  S2 const & s2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
67  {
68  switch (viennacl::traits::handle(s1).get_active_handle_id())
69  {
71  viennacl::linalg::host_based::as(s1, s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha);
72  break;
73 #ifdef VIENNACL_WITH_OPENCL
75  viennacl::linalg::opencl::as(s1, s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha);
76  break;
77 #endif
78 #ifdef VIENNACL_WITH_CUDA
80  viennacl::linalg::cuda::as(s1, s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha);
81  break;
82 #endif
84  throw memory_exception("not initialised!");
85  default:
86  throw memory_exception("not implemented");
87  }
88  }
89 
90 
105  template <typename S1,
106  typename S2, typename ScalarType1,
107  typename S3, typename ScalarType2>
113  >::type
114  asbs(S1 & s1,
115  S2 const & s2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha,
116  S3 const & s3, ScalarType2 const & beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
117  {
118  switch (viennacl::traits::handle(s1).get_active_handle_id())
119  {
122  s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
123  s3, beta, len_beta, reciprocal_beta, flip_sign_beta);
124  break;
125 #ifdef VIENNACL_WITH_OPENCL
128  s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
129  s3, beta, len_beta, reciprocal_beta, flip_sign_beta);
130  break;
131 #endif
132 #ifdef VIENNACL_WITH_CUDA
135  s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
136  s3, beta, len_beta, reciprocal_beta, flip_sign_beta);
137  break;
138 #endif
140  throw memory_exception("not initialised!");
141  default:
142  throw memory_exception("not implemented");
143  }
144  }
145 
146 
161  template <typename S1,
162  typename S2, typename ScalarType1,
163  typename S3, typename ScalarType2>
169  >::type
170  asbs_s(S1 & s1,
171  S2 const & s2, ScalarType1 const & alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha,
172  S3 const & s3, ScalarType2 const & beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
173  {
174  switch (viennacl::traits::handle(s1).get_active_handle_id())
175  {
178  s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
179  s3, beta, len_beta, reciprocal_beta, flip_sign_beta);
180  break;
181 #ifdef VIENNACL_WITH_OPENCL
184  s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
185  s3, beta, len_beta, reciprocal_beta, flip_sign_beta);
186  break;
187 #endif
188 #ifdef VIENNACL_WITH_CUDA
191  s2, alpha, len_alpha, reciprocal_alpha, flip_sign_alpha,
192  s3, beta, len_beta, reciprocal_beta, flip_sign_beta);
193  break;
194 #endif
196  throw memory_exception("not initialised!");
197  default:
198  throw memory_exception("not implemented");
199  }
200  }
201 
202 
203 
209  template <typename S1, typename S2>
212  >::type
213  swap(S1 & s1, S2 & s2)
214  {
215  switch (viennacl::traits::handle(s1).get_active_handle_id())
216  {
219  break;
220 #ifdef VIENNACL_WITH_OPENCL
223  break;
224 #endif
225 #ifdef VIENNACL_WITH_CUDA
228  break;
229 #endif
231  throw memory_exception("not initialised!");
232  default:
233  throw memory_exception("not implemented");
234  }
235  }
236 
237 
238  } //namespace linalg
239 } //namespace viennacl
240 
241 
242 #endif
Simple enable-if variant that uses the SFINAE pattern.
Definition: enable_if.hpp:29
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 len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
Interface for the generic operation s1 = s2 @ alpha, where s1 and s2 are GPU scalars, @ denotes multiplication or division, and alpha is either a GPU or a CPU scalar.
Definition: scalar_operations.hpp:65
std::size_t vcl_size_t
Definition: forwards.h:58
Definition: forwards.h:478
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 len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
Definition: scalar_operations.hpp:131
Implementations of scalar operations using OpenCL.
Exception class in case of memory errors.
Definition: forwards.h:485
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.
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:178
Implementations of scalar operations using CUDA.
This file provides the forward declarations for the main types used within ViennaCL.
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 len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
Definition: scalar_operations.hpp:52
Determines row and column increments for matrices and matrix proxies.
Implementations of scalar operations using a plain single-threaded or OpenMP-enabled execution on CPU...
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 len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
Definition: scalar_operations.hpp:84
Definition: forwards.h:481
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
Definition: forwards.h:480
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
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 len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
Definition: scalar_operations.hpp:196
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.
Definition: scalar_operations.hpp:213
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_any_scalar< ScalarType1 >::value >::type as(S1 &s1, S2 const &s2, ScalarType1 const &alpha, vcl_size_t len_alpha, bool reciprocal_alpha, bool flip_sign_alpha)
Definition: scalar_operations.hpp:82
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
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 len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
Interface for the generic operation s1 = s2 @ alpha + s3 @ beta, where s1, s2 and s3 are GPU scalars...
Definition: scalar_operations.hpp:114
All the predicates used within ViennaCL. Checks for expressions to be vectors, etc.
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 len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
Interface for the generic operation s1 += s2 @ alpha + s3 @ beta, where s1, s2 and s3 are GPU scalars...
Definition: scalar_operations.hpp:170
Helper struct for checking whether a type is a viennacl::scalar<>
Definition: forwards.h:370
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
Definition: forwards.h:479
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:366
Extracts the underlying OpenCL handle from a vector, a matrix, an expression etc. ...
viennacl::backend::mem_handle & handle(T &obj)
Returns the generic memory handle of an object. Non-const version.
Definition: handle.hpp:41
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 len_alpha, bool reciprocal_alpha, bool flip_sign_alpha, S3 const &s3, ScalarType2 const &beta, vcl_size_t len_beta, bool reciprocal_beta, bool flip_sign_beta)
Definition: scalar_operations.hpp:319
Simple enable-if variant that uses the SFINAE pattern.