1 #ifndef VIENNACL_LINALG_HOST_BASED_VECTOR_OPERATIONS_HPP_
2 #define VIENNACL_LINALG_HOST_BASED_VECTOR_OPERATIONS_HPP_
41 #ifndef VIENNACL_OPENMP_VECTOR_MIN_SIZE
42 #define VIENNACL_OPENMP_VECTOR_MIN_SIZE 5000
53 template<
typename NumericT>
55 inline unsigned long flip_sign(
unsigned long val) {
return val; }
56 inline unsigned int flip_sign(
unsigned int val) {
return val; }
57 inline unsigned short flip_sign(
unsigned short val) {
return val; }
58 inline unsigned char flip_sign(
unsigned char val) {
return val; }
65 template<
typename NumericT,
typename ScalarT1>
69 typedef NumericT value_type;
71 value_type * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
72 value_type
const * data_vec2 = detail::extract_raw_pointer<value_type>(vec2);
74 value_type data_alpha = alpha;
87 #ifdef VIENNACL_WITH_OPENMP
88 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
90 for (
long i = 0; i < static_cast<long>(
size1); ++i)
91 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] = data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] / data_alpha;
95 #ifdef VIENNACL_WITH_OPENMP
96 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
98 for (
long i = 0; i < static_cast<long>(
size1); ++i)
99 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] = data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] * data_alpha;
104 template<
typename NumericT,
typename ScalarT1,
typename ScalarT2>
109 typedef NumericT value_type;
111 value_type * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
112 value_type
const * data_vec2 = detail::extract_raw_pointer<value_type>(vec2);
113 value_type
const * data_vec3 = detail::extract_raw_pointer<value_type>(vec3);
115 value_type data_alpha = alpha;
119 value_type data_beta = beta;
133 if (reciprocal_alpha)
137 #ifdef VIENNACL_WITH_OPENMP
138 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
140 for (
long i = 0; i < static_cast<long>(
size1); ++i)
141 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] = data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] / data_alpha + data_vec3[static_cast<vcl_size_t>(i)*inc3+start3] / data_beta;
145 #ifdef VIENNACL_WITH_OPENMP
146 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
148 for (
long i = 0; i < static_cast<long>(
size1); ++i)
149 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] = data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] / data_alpha + data_vec3[static_cast<vcl_size_t>(i)*inc3+start3] * data_beta;
156 #ifdef VIENNACL_WITH_OPENMP
157 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
159 for (
long i = 0; i < static_cast<long>(
size1); ++i)
160 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] = data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] * data_alpha + data_vec3[static_cast<vcl_size_t>(i)*inc3+start3] / data_beta;
164 #ifdef VIENNACL_WITH_OPENMP
165 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
167 for (
long i = 0; i < static_cast<long>(
size1); ++i)
168 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] = data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] * data_alpha + data_vec3[static_cast<vcl_size_t>(i)*inc3+start3] * data_beta;
174 template<
typename NumericT,
typename ScalarT1,
typename ScalarT2>
179 typedef NumericT value_type;
181 value_type * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
182 value_type
const * data_vec2 = detail::extract_raw_pointer<value_type>(vec2);
183 value_type
const * data_vec3 = detail::extract_raw_pointer<value_type>(vec3);
185 value_type data_alpha = alpha;
189 value_type data_beta = beta;
203 if (reciprocal_alpha)
207 #ifdef VIENNACL_WITH_OPENMP
208 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
210 for (
long i = 0; i < static_cast<long>(
size1); ++i)
211 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] += data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] / data_alpha + data_vec3[static_cast<vcl_size_t>(i)*inc3+start3] / data_beta;
215 #ifdef VIENNACL_WITH_OPENMP
216 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
218 for (
long i = 0; i < static_cast<long>(
size1); ++i)
219 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] += data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] / data_alpha + data_vec3[static_cast<vcl_size_t>(i)*inc3+start3] * data_beta;
226 #ifdef VIENNACL_WITH_OPENMP
227 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
229 for (
long i = 0; i < static_cast<long>(
size1); ++i)
230 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] += data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] * data_alpha + data_vec3[static_cast<vcl_size_t>(i)*inc3+start3] / data_beta;
234 #ifdef VIENNACL_WITH_OPENMP
235 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
237 for (
long i = 0; i < static_cast<long>(
size1); ++i)
238 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] += data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] * data_alpha + data_vec3[static_cast<vcl_size_t>(i)*inc3+start3] * data_beta;
252 template<
typename NumericT>
255 typedef NumericT value_type;
257 value_type * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
264 value_type data_alpha =
static_cast<value_type
>(alpha);
266 #ifdef VIENNACL_WITH_OPENMP
267 #pragma omp parallel for if (loop_bound > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
269 for (
long i = 0; i < static_cast<long>(loop_bound); ++i)
270 data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1] = data_alpha;
279 template<
typename NumericT>
282 typedef NumericT value_type;
284 value_type * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
285 value_type * data_vec2 = detail::extract_raw_pointer<value_type>(vec2);
294 #ifdef VIENNACL_WITH_OPENMP
295 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
297 for (
long i = 0; i < static_cast<long>(
size1); ++i)
299 value_type temp = data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2];
300 data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] = data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1];
301 data_vec1[
static_cast<vcl_size_t>(i)*inc1+start1] = temp;
313 template<
typename NumericT,
typename OpT>
317 typedef NumericT value_type;
320 value_type * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
321 value_type
const * data_vec2 = detail::extract_raw_pointer<value_type>(proxy.lhs());
322 value_type
const * data_vec3 = detail::extract_raw_pointer<value_type>(proxy.rhs());
334 #ifdef VIENNACL_WITH_OPENMP
335 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
337 for (
long i = 0; i < static_cast<long>(
size1); ++i)
338 OpFunctor::apply(data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1], data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2], data_vec3[static_cast<vcl_size_t>(i)*inc3+start3]);
346 template<
typename NumericT,
typename OpT>
350 typedef NumericT value_type;
353 value_type * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
354 value_type
const * data_vec2 = detail::extract_raw_pointer<value_type>(proxy.lhs());
363 #ifdef VIENNACL_WITH_OPENMP
364 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
366 for (
long i = 0; i < static_cast<long>(
size1); ++i)
367 OpFunctor::apply(data_vec1[static_cast<vcl_size_t>(i)*inc1+
start1], data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2]);
383 #define VIENNACL_INNER_PROD_IMPL_1(RESULTSCALART, TEMPSCALART) \
384 inline RESULTSCALART inner_prod_impl(RESULTSCALART const * data_vec1, vcl_size_t start1, vcl_size_t inc1, vcl_size_t size1, \
385 RESULTSCALART const * data_vec2, vcl_size_t start2, vcl_size_t inc2) { \
386 TEMPSCALART temp = 0;
388 #define VIENNACL_INNER_PROD_IMPL_2(RESULTSCALART) \
389 for (long i = 0; i < static_cast<long>(size1); ++i) \
390 temp += data_vec1[static_cast<vcl_size_t>(i)*inc1+start1] * data_vec2[static_cast<vcl_size_t>(i)*inc2+start2]; \
391 return static_cast<RESULTSCALART>(temp); \
396 #ifdef VIENNACL_WITH_OPENMP
397 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
402 #ifdef VIENNACL_WITH_OPENMP
403 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
410 #ifdef VIENNACL_WITH_OPENMP
411 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
416 #ifdef VIENNACL_WITH_OPENMP
417 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
424 #ifdef VIENNACL_WITH_OPENMP
425 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
430 #ifdef VIENNACL_WITH_OPENMP
431 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
438 #ifdef VIENNACL_WITH_OPENMP
439 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
444 #ifdef VIENNACL_WITH_OPENMP
445 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
452 #ifdef VIENNACL_WITH_OPENMP
453 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
459 #ifdef VIENNACL_WITH_OPENMP
460 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
464 #undef VIENNACL_INNER_PROD_IMPL_1
465 #undef VIENNACL_INNER_PROD_IMPL_2
474 template<
typename NumericT,
typename ScalarT>
479 typedef NumericT value_type;
481 value_type
const * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
482 value_type
const * data_vec2 = detail::extract_raw_pointer<value_type>(vec2);
492 data_vec2, start2, inc2);
495 template<
typename NumericT>
500 typedef NumericT value_type;
502 value_type
const * data_x = detail::extract_raw_pointer<value_type>(x);
508 std::vector<value_type> temp(vec_tuple.
const_size());
509 std::vector<value_type const *> data_y(vec_tuple.
const_size());
510 std::vector<vcl_size_t> start_y(vec_tuple.
const_size());
511 std::vector<vcl_size_t> stride_y(vec_tuple.
const_size());
515 data_y[j] = detail::extract_raw_pointer<value_type>(vec_tuple.
const_at(j));
523 value_type entry_x = data_x[i*inc_x+start_x];
525 temp[j] += entry_x * data_y[j][i*stride_y[j]+start_y[j]];
536 #define VIENNACL_NORM_1_IMPL_1(RESULTSCALART, TEMPSCALART) \
537 inline RESULTSCALART norm_1_impl(RESULTSCALART const * data_vec1, vcl_size_t start1, vcl_size_t inc1, vcl_size_t size1) { \
538 TEMPSCALART temp = 0;
540 #define VIENNACL_NORM_1_IMPL_2(RESULTSCALART, TEMPSCALART) \
541 for (long i = 0; i < static_cast<long>(size1); ++i) \
542 temp += static_cast<TEMPSCALART>(std::fabs(static_cast<double>(data_vec1[static_cast<vcl_size_t>(i)*inc1+start1]))); \
543 return static_cast<RESULTSCALART>(temp); \
548 #ifdef VIENNACL_WITH_OPENMP
549 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
554 #ifdef VIENNACL_WITH_OPENMP
555 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
561 #ifdef VIENNACL_WITH_OPENMP
562 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
567 #ifdef VIENNACL_WITH_OPENMP
568 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
575 #ifdef VIENNACL_WITH_OPENMP
576 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
581 #ifdef VIENNACL_WITH_OPENMP
582 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
589 #ifdef VIENNACL_WITH_OPENMP
590 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
595 #ifdef VIENNACL_WITH_OPENMP
596 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
603 #ifdef VIENNACL_WITH_OPENMP
604 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
610 #ifdef VIENNACL_WITH_OPENMP
611 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
615 #undef VIENNACL_NORM_1_IMPL_1
616 #undef VIENNACL_NORM_1_IMPL_2
625 template<
typename NumericT,
typename ScalarT>
629 typedef NumericT value_type;
631 value_type
const * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
645 #define VIENNACL_NORM_2_IMPL_1(RESULTSCALART, TEMPSCALART) \
646 inline RESULTSCALART norm_2_impl(RESULTSCALART const * data_vec1, vcl_size_t start1, vcl_size_t inc1, vcl_size_t size1) { \
647 TEMPSCALART temp = 0;
649 #define VIENNACL_NORM_2_IMPL_2(RESULTSCALART, TEMPSCALART) \
650 for (long i = 0; i < static_cast<long>(size1); ++i) { \
651 RESULTSCALART data = data_vec1[static_cast<vcl_size_t>(i)*inc1+start1]; \
652 temp += static_cast<TEMPSCALART>(data * data); \
654 return static_cast<RESULTSCALART>(temp); \
659 #ifdef VIENNACL_WITH_OPENMP
660 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
665 #ifdef VIENNACL_WITH_OPENMP
666 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
673 #ifdef VIENNACL_WITH_OPENMP
674 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
679 #ifdef VIENNACL_WITH_OPENMP
680 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
687 #ifdef VIENNACL_WITH_OPENMP
688 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
693 #ifdef VIENNACL_WITH_OPENMP
694 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
701 #ifdef VIENNACL_WITH_OPENMP
702 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
707 #ifdef VIENNACL_WITH_OPENMP
708 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
715 #ifdef VIENNACL_WITH_OPENMP
716 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
722 #ifdef VIENNACL_WITH_OPENMP
723 #pragma omp parallel for reduction(+: temp) if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
727 #undef VIENNACL_NORM_2_IMPL_1
728 #undef VIENNACL_NORM_2_IMPL_2
738 template<
typename NumericT,
typename ScalarT>
742 typedef NumericT value_type;
744 value_type
const * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
758 template<
typename NumericT,
typename ScalarT>
762 typedef NumericT value_type;
764 value_type
const * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
774 temp = std::max<value_type>(temp, static_cast<value_type>(std::fabs(static_cast<double>(data_vec1[i*inc1+start1]))));
787 template<
typename NumericT>
790 typedef NumericT value_type;
792 value_type
const * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
805 data =
static_cast<value_type
>(std::fabs(static_cast<double>(data_vec1[i*inc1+start1])));
821 template<
typename NumericT,
typename ScalarT>
825 typedef NumericT value_type;
827 value_type
const * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
833 value_type temp = data_vec1[
start1];
837 temp = std::max<value_type>(temp, data_vec1[i*inc1+start1]);
847 template<
typename NumericT,
typename ScalarT>
851 typedef NumericT value_type;
853 value_type
const * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
859 value_type temp = data_vec1[
start1];
863 temp = std::min<value_type>(temp, data_vec1[i*inc1+start1]);
879 template<
typename NumericT>
882 NumericT alpha, NumericT beta)
884 typedef NumericT value_type;
886 value_type * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
887 value_type * data_vec2 = detail::extract_raw_pointer<value_type>(vec2);
896 value_type data_alpha = alpha;
897 value_type data_beta = beta;
899 #ifdef VIENNACL_WITH_OPENMP
900 #pragma omp parallel for if (size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
902 for (
long i = 0; i < static_cast<long>(
size1); ++i)
904 value_type temp1 = data_vec1[
static_cast<vcl_size_t>(i)*inc1+start1];
905 value_type temp2 = data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2];
907 data_vec1[
static_cast<vcl_size_t>(i)*inc1+start1] = data_alpha * temp1 + data_beta * temp2;
908 data_vec2[
static_cast<vcl_size_t>(i)*inc2+start2] = data_alpha * temp2 - data_beta * temp1;
vcl_size_t const_size() const
#define VIENNACL_INNER_PROD_IMPL_2(RESULTSCALART)
#define VIENNACL_NORM_1_IMPL_2(RESULTSCALART, TEMPSCALART)
#define VIENNACL_NORM_2_IMPL_2(RESULTSCALART, TEMPSCALART)
void norm_1_impl(vector_base< NumericT > const &vec1, ScalarT &result)
Computes the l^1-norm of a vector.
Generic size and resize functionality for different vector and matrix types.
void norm_inf_impl(vector_base< NumericT > const &vec1, ScalarT &result)
Computes the supremum-norm of a vector.
void av(vector_base< NumericT > &vec1, vector_base< NumericT > const &vec2, ScalarT1 const &alpha, vcl_size_t, bool reciprocal_alpha, bool flip_sign_alpha)
#define VIENNACL_NORM_1_IMPL_1(RESULTSCALART, TEMPSCALART)
Extracts the underlying OpenCL start index handle from a vector, a matrix, an expression etc...
vcl_size_t size1(MatrixType const &mat)
Generic routine for obtaining the number of rows of a matrix (ViennaCL, uBLAS, etc.)
Worker class for decomposing expression templates.
result_of::size_type< viennacl::vector_base< T > >::type stride(viennacl::vector_base< T > const &s)
This file provides the forward declarations for the main types used within ViennaCL.
result_of::size_type< T >::type start1(T const &obj)
Determines row and column increments for matrices and matrix proxies.
An expression template class that represents a binary operation that yields a vector.
void vector_assign(vector_base< NumericT > &vec1, const NumericT &alpha, bool up_to_internal_size=false)
Assign a constant value to a vector (-range/-slice)
vcl_size_t size(VectorType const &vec)
Generic routine for obtaining the size of a vector (ViennaCL, uBLAS, etc.)
result_of::size_type< T >::type start2(T const &obj)
void norm_2_impl(vector_base< NumericT > const &vec1, ScalarT &result)
Computes the l^2-norm of a vector - implementation.
#define VIENNACL_INNER_PROD_IMPL_1(RESULTSCALART, TEMPSCALART)
vcl_size_t index_norm_inf(vector_base< NumericT > const &vec1)
Computes the index of the first entry that is equal to the supremum-norm in modulus.
Tuple class holding pointers to multiple vectors. Mainly used as a temporary object returned from vie...
void min_impl(vector_base< NumericT > const &vec1, ScalarT &result)
Computes the maximum of a vector.
void norm_2_impl(vector_base< NumericT > const &x, scalar< NumericT > &result)
Computes the l^2-norm of a vector - implementation using OpenCL summation at second step...
void vector_swap(vector_base< NumericT > &vec1, vector_base< NumericT > &vec2)
Swaps the contents of two vectors, data is copied.
void element_op(matrix_base< NumericT > &A, matrix_expression< const matrix_base< NumericT >, const matrix_base< NumericT >, op_element_binary< OpT > > const &proxy)
Implementation of the element-wise operations A = B .* C and A = B ./ C (using MATLAB syntax) ...
result_of::size_type< T >::type start(T const &obj)
NumericT flip_sign(NumericT val)
void avbv(vector_base< NumericT > &vec1, vector_base< NumericT > const &vec2, ScalarT1 const &alpha, vcl_size_t, bool reciprocal_alpha, bool flip_sign_alpha, vector_base< NumericT > const &vec3, ScalarT2 const &beta, vcl_size_t, bool reciprocal_beta, bool flip_sign_beta)
Common routines for single-threaded or OpenMP-enabled execution on CPU.
All the predicates used within ViennaCL. Checks for expressions to be vectors, etc.
void inner_prod_impl(vector_base< NumericT > const &vec1, vector_base< NumericT > const &vec2, ScalarT &result)
Computes the inner product of two vectors - implementation. Library users should call inner_prod(vec1...
void max_impl(vector_base< NumericT > const &vec1, ScalarT &result)
Computes the maximum of a vector.
#define VIENNACL_NORM_2_IMPL_1(RESULTSCALART, TEMPSCALART)
VectorType const & const_at(vcl_size_t i) const
A tag class representing element-wise binary operations (like multiplication) on vectors or matrices...
size_type internal_size() const
Returns the internal length of the vector, which is given by size() plus the extra memory due to padd...
Defines the action of certain unary and binary operators and its arguments (for host execution)...
A tag class representing element-wise unary operations (like sin()) on vectors or matrices...
void plane_rotation(vector_base< NumericT > &vec1, vector_base< NumericT > &vec2, NumericT alpha, NumericT beta)
Computes a plane rotation of two vectors.
void inner_prod_impl(vector_base< T > const &x, vector_tuple< T > const &y_tuple, vector_base< T > &result)
Computes the inner products , , ..., and writes the result to a (sub-)vector...
Implementation of the ViennaCL scalar class.
void avbv_v(vector_base< NumericT > &vec1, vector_base< NumericT > const &vec2, ScalarT1 const &alpha, vcl_size_t, bool reciprocal_alpha, bool flip_sign_alpha, vector_base< NumericT > const &vec3, ScalarT2 const &beta, vcl_size_t, bool reciprocal_beta, bool flip_sign_beta)
void norm_1_impl(viennacl::vector_expression< LHS, RHS, OP > const &vec, S2 &result)
Computes the l^1-norm of a vector - interface for a vector expression. Creates a temporary.
Simple enable-if variant that uses the SFINAE pattern.