32 #define BOOST_UBLAS_NDEBUG
38 #include <boost/numeric/ublas/io.hpp>
39 #include <boost/numeric/ublas/vector.hpp>
40 #include <boost/numeric/ublas/vector_proxy.hpp>
46 #define VIENNACL_WITH_UBLAS 1
57 using namespace boost::numeric;
63 template<
typename ScalarType>
67 if (std::fabs(s1 - s2) > 0 )
68 return (s1 - s2) /
std::max(std::fabs(s1), std::fabs(s2));
74 template<
typename ScalarType>
78 if (std::fabs(s1 - s2) > 0 )
79 return (s1 - s2) /
std::max(std::fabs(s1), std::fabs(s2));
85 template<
typename ScalarType>
89 if (std::fabs(s1 - s2) > 0 )
90 return (s1 - s2) /
std::max(std::fabs(s1), std::fabs(s2));
96 template<
typename ScalarType,
typename ViennaCLVectorType>
97 ScalarType diff(ublas::vector<ScalarType>
const &
v1, ViennaCLVectorType
const & vcl_vec)
99 ublas::vector<ScalarType> v2_cpu(vcl_vec.size());
103 for (
unsigned int i=0;i<v1.size(); ++i)
105 if (
std::max( std::fabs(v2_cpu[i]), std::fabs(v1[i]) ) > 0 )
106 v2_cpu[i] = std::fabs(v2_cpu[i] - v1[i]) /
std::max( std::fabs(v2_cpu[i]), std::fabs(v1[i]) );
115 template<
typename T1,
typename T2>
116 int check(T1
const & t1, T2
const & t2,
double epsilon)
118 int retval = EXIT_SUCCESS;
120 double temp = std::fabs(
diff(t1, t2));
123 std::cout <<
"# Error! Relative difference: " << temp << std::endl;
124 retval = EXIT_FAILURE;
133 template<
typename NumericT,
typename Epsilon,
typename UblasVectorType,
typename ViennaCLVectorType1,
typename ViennaCLVectorType2 >
134 int test(Epsilon
const& epsilon,
135 UblasVectorType & ublas_v1, UblasVectorType & ublas_v2,
136 ViennaCLVectorType1 & vcl_v1, ViennaCLVectorType2 & vcl_v2)
138 int retval = EXIT_SUCCESS;
140 NumericT cpu_result = 42.0;
146 std::cout <<
"Checking for zero_vector initializer..." << std::endl;
147 ublas_v1 = ublas::zero_vector<NumericT>(ublas_v1.size());
149 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
152 std::cout <<
"Checking for scalar_vector initializer..." << std::endl;
153 ublas_v1 = ublas::scalar_vector<NumericT>(ublas_v1.size(), cpu_result);
155 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
158 ublas_v1 = ublas::scalar_vector<NumericT>(ublas_v1.size(), gpu_result);
160 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
163 std::cout <<
"Checking for unit_vector initializer..." << std::endl;
164 ublas_v1 = ublas::unit_vector<NumericT>(ublas_v1.size(), 5);
166 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
170 for (std::size_t i=0; i<ublas_v1.size(); ++i)
172 ublas_v1[i] = NumericT(1.0) + random<NumericT>();
173 ublas_v2[i] = NumericT(1.0) + random<NumericT>();
179 std::cout <<
"Checking for successful copy..." << std::endl;
180 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
182 if (
check(ublas_v2, vcl_v2, epsilon) != EXIT_SUCCESS)
190 std::cout <<
"Testing inner_prod..." << std::endl;
195 if (
check(cpu_result, cpu_result2, epsilon) != EXIT_SUCCESS)
197 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
200 cpu_result =
inner_prod(ublas_v1 + ublas_v2, ublas_v2 - ublas_v1);
204 if (
check(cpu_result, cpu_result3, epsilon) != EXIT_SUCCESS)
206 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
210 std::cout <<
"Testing norm_1..." << std::endl;
214 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
217 gpu_result = 2 * cpu_result;
221 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
227 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
231 std::cout <<
"Testing norm_2..." << std::endl;
235 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
238 gpu_result = 2 * cpu_result;
242 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
248 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
252 std::cout <<
"Testing norm_inf..." << std::endl;
256 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
259 gpu_result = 2 * cpu_result;
263 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
269 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
273 std::cout <<
"Testing index_norm_inf..." << std::endl;
277 if (
check(static_cast<NumericT>(cpu_index), static_cast<NumericT>(gpu_index), epsilon) != EXIT_SUCCESS)
283 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
289 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
294 std::cout <<
"Testing max..." << std::endl;
295 cpu_result = ublas_v1[0];
296 for (std::size_t i=0; i<ublas_v1.size(); ++i)
297 cpu_result = std::max<NumericT>(cpu_result, ublas_v1[i]);
300 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
303 cpu_result = ublas_v1[0];
304 for (std::size_t i=0; i<ublas_v1.size(); ++i)
305 cpu_result = std::max<NumericT>(cpu_result, ublas_v1[i]);
306 gpu_result = cpu_result;
310 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
313 cpu_result = ublas_v1[0] + ublas_v2[0];
314 for (std::size_t i=0; i<ublas_v1.size(); ++i)
315 cpu_result = std::max<NumericT>(cpu_result, ublas_v1[i] + ublas_v2[i]);
316 gpu_result = cpu_result;
320 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
325 std::cout <<
"Testing min..." << std::endl;
326 cpu_result = ublas_v1[0];
327 for (std::size_t i=0; i<ublas_v1.size(); ++i)
328 cpu_result = std::min<NumericT>(cpu_result, ublas_v1[i]);
331 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
334 cpu_result = ublas_v1[0];
335 for (std::size_t i=0; i<ublas_v1.size(); ++i)
336 cpu_result = std::min<NumericT>(cpu_result, ublas_v1[i]);
337 gpu_result = cpu_result;
341 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
344 cpu_result = ublas_v1[0] + ublas_v2[0];
345 for (std::size_t i=0; i<ublas_v1.size(); ++i)
346 cpu_result = std::min<NumericT>(cpu_result, ublas_v1[i] + ublas_v2[i]);
347 gpu_result = cpu_result;
351 if (
check(cpu_result, gpu_result, epsilon) != EXIT_SUCCESS)
362 ublas::vector<NumericT> x = ublas_v1;
363 ublas::vector<NumericT> y = ublas_v2;
364 ublas::vector<NumericT> t = ublas_v1;
365 t.assign (NumericT(1.1) * x + NumericT(2.3) * y),
366 y.assign (- NumericT(2.3) * x + NumericT(1.1) * y),
371 if (
check(x, vcl_v1, epsilon) != EXIT_SUCCESS)
373 if (
check(y, vcl_v2, epsilon) != EXIT_SUCCESS)
378 std::cout <<
"Testing assignments..." << std::endl;
379 NumericT val =
static_cast<NumericT
>(1e-1);
380 for (
size_t i=0; i < ublas_v1.size(); ++i)
383 for (
size_t i=0; i < vcl_v1.size(); ++i)
386 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
389 std::cout <<
"Testing assignments via iterators..." << std::endl;
391 ublas_v1[2] =
static_cast<NumericT
>(1.9);
392 vcl_v1[2] =
static_cast<NumericT
>(1.9);
394 typename UblasVectorType::iterator ublas_v1_it = ublas_v1.begin();
397 *ublas_v1_it =
static_cast<NumericT
>(1.5);
398 typename ViennaCLVectorType1::iterator vcl_v1_it = vcl_v1.begin();
401 *vcl_v1_it =
static_cast<NumericT
>(1.5);
403 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
409 for (
size_t i=0; i < ublas_v1.size(); ++i)
410 ublas_v1(i) = NumericT(1.0) + random<NumericT>();
411 ublas_v2 = NumericT(3.1415) * ublas_v1;
415 std::cout <<
"Testing scaling with CPU scalar..." << std::endl;
416 NumericT alpha =
static_cast<NumericT
>(1.7182);
419 ublas_v1 *= long(alpha);
420 vcl_v1 *= long(alpha);
422 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
425 ublas_v1 *= float(alpha);
426 vcl_v1 *= float(alpha);
428 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
431 ublas_v1 *= double(alpha);
432 vcl_v1 *= double(alpha);
434 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
438 std::cout <<
"Testing scaling with GPU scalar..." << std::endl;
442 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
445 std::cout <<
"Testing scaling with scalar expression..." << std::endl;
449 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
452 NumericT beta =
static_cast<NumericT
>(1.4153);
455 std::cout <<
"Testing shrinking with CPU scalar..." << std::endl;
456 ublas_v1 /= long(beta);
457 vcl_v1 /= long(beta);
459 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
462 ublas_v1 /= float(beta);
463 vcl_v1 /= float(beta);
465 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
468 ublas_v1 /= double(beta);
469 vcl_v1 /= double(beta);
471 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
475 std::cout <<
"Testing shrinking with GPU scalar..." << std::endl;
479 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
487 for (
size_t i=0; i < ublas_v1.size(); ++i)
488 ublas_v1(i) = NumericT(1.0) + random<NumericT>();
489 ublas_v2 = NumericT(3.1415) * ublas_v1;
493 std::cout <<
"Testing add on vector..." << std::endl;
495 std::cout <<
"Checking for successful copy..." << std::endl;
496 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
498 if (
check(ublas_v2, vcl_v2, epsilon) != EXIT_SUCCESS)
501 ublas_v1 = ublas_v1 + ublas_v2;
502 vcl_v1 = vcl_v1 + vcl_v2;
504 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
507 std::cout <<
"Testing add on vector with flipsign..." << std::endl;
508 ublas_v1 = - ublas_v1 + ublas_v2;
509 vcl_v1 = - vcl_v1 + vcl_v2;
511 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
514 std::cout <<
"Testing inplace-add on vector..." << std::endl;
515 ublas_v1 += ublas_v2;
518 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
521 std::cout <<
"Testing assignment to vector with vector multiplied by scalar expression..." << std::endl;
522 ublas_v1 =
inner_prod(ublas_v1, ublas_v2) * ublas_v2;
528 std::cout <<
"Testing sub on vector..." << std::endl;
529 ublas_v2 = NumericT(3.1415) * ublas_v1;
533 ublas_v1 = ublas_v1 - ublas_v2;
534 vcl_v1 = vcl_v1 - vcl_v2;
536 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
539 std::cout <<
"Testing inplace-sub on vector..." << std::endl;
540 ublas_v1 -= ublas_v2;
543 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
551 std::cout <<
"Testing multiply-add on vector with CPU scalar (right)..." << std::endl;
552 for (
size_t i=0; i < ublas_v1.size(); ++i)
553 ublas_v1(i) = NumericT(1.0) + random<NumericT>();
554 ublas_v2 = NumericT(3.1415) * ublas_v1;
558 ublas_v1 = ublas_v1 + ublas_v2 * float(alpha);
559 vcl_v1 = vcl_v1 + vcl_v2 * float(alpha);
561 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
564 ublas_v1 = ublas_v1 + ublas_v2 * double(alpha);
565 vcl_v1 = vcl_v1 + vcl_v2 * double(alpha);
567 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
571 std::cout <<
"Testing multiply-add on vector with CPU scalar (left)..." << std::endl;
572 ublas_v2 = NumericT(3.1415) * ublas_v1;
576 ublas_v1 = long(alpha) * ublas_v1 + ublas_v2;
577 vcl_v1 = long(alpha) * vcl_v1 + vcl_v2;
579 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
582 ublas_v1 = float(alpha) * ublas_v1 + ublas_v2;
583 vcl_v1 = float(alpha) * vcl_v1 + vcl_v2;
585 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
588 ublas_v1 = double(alpha) * ublas_v1 + ublas_v2;
589 vcl_v1 = double(alpha) * vcl_v1 + vcl_v2;
591 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
595 std::cout <<
"Testing multiply-add on vector with CPU scalar (both)..." << std::endl;
596 ublas_v2 = NumericT(3.1415) * ublas_v1;
600 ublas_v1 = long(alpha) * ublas_v1 + long(beta) * ublas_v2;
601 vcl_v1 = long(alpha) * vcl_v1 + long(beta) * vcl_v2;
603 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
606 ublas_v1 = float(alpha) * ublas_v1 + float(beta) * ublas_v2;
607 vcl_v1 = float(alpha) * vcl_v1 + float(beta) * vcl_v2;
609 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
612 ublas_v1 = double(alpha) * ublas_v1 + double(beta) * ublas_v2;
613 vcl_v1 = double(alpha) * vcl_v1 + double(beta) * vcl_v2;
615 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
619 std::cout <<
"Testing inplace multiply-add on vector with CPU scalar..." << std::endl;
620 ublas_v2 = NumericT(3.1415) * ublas_v1;
624 ublas_v1 += ublas_v2 * long(alpha);
625 vcl_v1 += vcl_v2 * long(alpha);
627 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
630 ublas_v1 += ublas_v2 * float(alpha);
631 vcl_v1 += vcl_v2 * float(alpha);
633 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
636 ublas_v1 += double(alpha) * ublas_v2;
637 vcl_v1 += double(alpha) * vcl_v2;
639 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
643 std::cout <<
"Testing multiply-add on vector with GPU scalar (right)..." << std::endl;
644 ublas_v2 = NumericT(3.1415) * ublas_v1;
648 ublas_v1 = ublas_v1 + alpha * ublas_v2;
649 vcl_v1 = vcl_v1 + gpu_alpha * vcl_v2;
651 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
654 std::cout <<
"Testing multiply-add on vector with GPU scalar (left)..." << std::endl;
655 ublas_v2 = NumericT(3.1415) * ublas_v1;
659 ublas_v1 = ublas_v1 + alpha * ublas_v2;
660 vcl_v1 = vcl_v1 + gpu_alpha * vcl_v2;
662 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
665 std::cout <<
"Testing multiply-add on vector with GPU scalar (both)..." << std::endl;
666 ublas_v2 = NumericT(3.1415) * ublas_v1;
670 ublas_v1 = alpha * ublas_v1 + beta * ublas_v2;
671 vcl_v1 = gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
673 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
677 std::cout <<
"Testing inplace multiply-add on vector with GPU scalar (both, adding)..." << std::endl;
678 ublas_v2 = NumericT(3.1415) * ublas_v1;
682 ublas_v1 += alpha * ublas_v1 + beta * ublas_v2;
683 vcl_v1 += gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
685 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
688 std::cout <<
"Testing inplace multiply-add on vector with GPU scalar (both, subtracting)..." << std::endl;
689 ublas_v2 = NumericT(3.1415) * ublas_v1;
693 ublas_v1 += alpha * ublas_v1 - beta * ublas_v2;
694 vcl_v1 += gpu_alpha * vcl_v1 - gpu_beta * vcl_v2;
696 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
701 std::cout <<
"Testing inplace multiply-add on vector with GPU scalar..." << std::endl;
702 ublas_v2 = NumericT(3.1415) * ublas_v1;
706 ublas_v1 += alpha * ublas_v2;
707 vcl_v1 += gpu_alpha * vcl_v2;
709 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
716 std::cout <<
"Testing division-add on vector with CPU scalar (right)..." << std::endl;
717 for (
size_t i=0; i < ublas_v1.size(); ++i)
718 ublas_v1(i) = NumericT(1.0) + random<NumericT>();
719 ublas_v2 = NumericT(3.1415) * ublas_v1;
723 ublas_v1 = ublas_v1 + ublas_v2 / long(alpha);
724 vcl_v1 = vcl_v1 + vcl_v2 / long(alpha);
726 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
729 ublas_v1 = ublas_v1 + ublas_v2 / float(alpha);
730 vcl_v1 = vcl_v1 + vcl_v2 / float(alpha);
732 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
735 ublas_v1 = ublas_v1 + ublas_v2 / double(alpha);
736 vcl_v1 = vcl_v1 + vcl_v2 / double(alpha);
738 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
742 std::cout <<
"Testing division-add on vector with CPU scalar (left)..." << std::endl;
743 ublas_v2 = NumericT(3.1415) * ublas_v1;
747 ublas_v1 = ublas_v1 / float(alpha) + ublas_v2;
748 vcl_v1 = vcl_v1 / float(alpha) + vcl_v2;
750 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
753 ublas_v1 = ublas_v1 / double(alpha) + ublas_v2;
754 vcl_v1 = vcl_v1 / double(alpha) + vcl_v2;
756 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
760 std::cout <<
"Testing division-add on vector with CPU scalar (both)..." << std::endl;
761 ublas_v2 = NumericT(3.1415) * ublas_v1;
765 ublas_v1 = ublas_v1 / float(alpha) + ublas_v2 / float(beta);
766 vcl_v1 = vcl_v1 / float(alpha) + vcl_v2 / float(beta);
768 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
771 ublas_v1 = ublas_v1 / double(alpha) + ublas_v2 / double(beta);
772 vcl_v1 = vcl_v1 / double(alpha) + vcl_v2 / double(beta);
774 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
777 std::cout <<
"Testing division-multiply-add on vector with CPU scalar..." << std::endl;
778 ublas_v2 = NumericT(3.1415) * ublas_v1;
782 ublas_v1 = ublas_v1 / alpha + ublas_v2 * beta;
783 vcl_v1 = vcl_v1 / alpha + vcl_v2 * beta;
785 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
789 std::cout <<
"Testing multiply-division-add on vector with CPU scalar..." << std::endl;
790 ublas_v2 = NumericT(3.1415) * ublas_v1;
794 ublas_v1 = ublas_v1 * alpha + ublas_v2 / beta;
795 vcl_v1 = vcl_v1 * alpha + vcl_v2 / beta;
797 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
802 std::cout <<
"Testing inplace division-add on vector with CPU scalar..." << std::endl;
803 ublas_v2 = NumericT(3.1415) * ublas_v1;
807 ublas_v1 += ublas_v2 / alpha;
808 vcl_v1 += vcl_v2 / alpha;
810 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
814 std::cout <<
"Testing division-add on vector with GPU scalar (right)..." << std::endl;
815 ublas_v2 = NumericT(3.1415) * ublas_v1;
819 ublas_v1 = ublas_v1 + ublas_v2 / alpha;
820 vcl_v1 = vcl_v1 + vcl_v2 / gpu_alpha;
822 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
825 std::cout <<
"Testing division-add on vector with GPU scalar (left)..." << std::endl;
826 ublas_v2 = NumericT(3.1415) * ublas_v1;
830 ublas_v1 = ublas_v1 + ublas_v2 / alpha;
831 vcl_v1 = vcl_v1 + vcl_v2 / gpu_alpha;
833 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
836 std::cout <<
"Testing division-add on vector with GPU scalar (both)..." << std::endl;
837 ublas_v2 = NumericT(3.1415) * ublas_v1;
841 ublas_v1 = ublas_v1 / alpha + ublas_v2 / beta;
842 vcl_v1 = vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
844 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
848 std::cout <<
"Testing inplace division-add on vector with GPU scalar (both, adding)..." << std::endl;
849 ublas_v2 = NumericT(3.1415) * ublas_v1;
853 ublas_v1 += ublas_v1 / alpha + ublas_v2 / beta;
854 vcl_v1 += vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
856 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
859 std::cout <<
"Testing inplace division-add on vector with GPU scalar (both, subtracting)..." << std::endl;
860 ublas_v2 = NumericT(3.1415) * ublas_v1;
864 ublas_v1 += ublas_v1 / alpha - ublas_v2 / beta;
865 vcl_v1 += vcl_v1 / gpu_alpha - vcl_v2 / gpu_beta;
867 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
870 std::cout <<
"Testing inplace division-multiply-add on vector with GPU scalar (adding)..." << std::endl;
871 ublas_v2 = NumericT(3.1415) * ublas_v1;
875 ublas_v1 += ublas_v1 / alpha + ublas_v2 * beta;
876 vcl_v1 += vcl_v1 / gpu_alpha + vcl_v2 * gpu_beta;
878 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
881 std::cout <<
"Testing inplace multiply-division-add on vector with GPU scalar (subtracting)..." << std::endl;
882 ublas_v2 = NumericT(3.1415) * ublas_v1;
886 ublas_v1 += ublas_v1 * alpha - ublas_v2 / beta;
887 vcl_v1 += vcl_v1 * gpu_alpha - vcl_v2 / gpu_beta;
889 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
894 std::cout <<
"Testing inplace division-add on vector with GPU scalar..." << std::endl;
895 ublas_v2 = NumericT(3.1415) * ublas_v1;
899 ublas_v1 += ublas_v2 * alpha;
900 vcl_v1 += vcl_v2 * gpu_alpha;
902 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
910 std::cout <<
"Testing multiply-subtract on vector with CPU scalar (right)..." << std::endl;
911 for (
size_t i=0; i < ublas_v1.size(); ++i)
912 ublas_v1(i) = NumericT(1.0) + random<NumericT>();
913 ublas_v2 = NumericT(3.1415) * ublas_v1;
917 ublas_v1 = ublas_v1 - alpha * ublas_v2;
918 vcl_v1 = vcl_v1 - alpha * vcl_v2;
920 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
924 std::cout <<
"Testing multiply-subtract on vector with CPU scalar (left)..." << std::endl;
925 ublas_v2 = NumericT(3.1415) * ublas_v1;
929 ublas_v1 = alpha * ublas_v1 - ublas_v2;
930 vcl_v1 = alpha * vcl_v1 - vcl_v2;
932 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
935 std::cout <<
"Testing multiply-subtract on vector with CPU scalar (both)..." << std::endl;
936 ublas_v2 = NumericT(3.1415) * ublas_v1;
940 ublas_v1 = alpha * ublas_v1 - beta * ublas_v2;
941 vcl_v1 = alpha * vcl_v1 - beta * vcl_v2;
943 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
947 std::cout <<
"Testing inplace multiply-subtract on vector with CPU scalar..." << std::endl;
948 ublas_v2 = NumericT(3.1415) * ublas_v1;
952 ublas_v1 -= alpha * ublas_v2;
953 vcl_v1 -= alpha * vcl_v2;
955 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
959 std::cout <<
"Testing multiply-subtract on vector with GPU scalar (right)..." << std::endl;
960 ublas_v2 = NumericT(3.1415) * ublas_v1;
964 ublas_v1 = ublas_v1 - alpha * ublas_v2;
965 vcl_v1 = vcl_v1 - gpu_alpha * vcl_v2;
967 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
970 std::cout <<
"Testing multiply-subtract on vector with GPU scalar (left)..." << std::endl;
971 ublas_v2 = NumericT(3.1415) * ublas_v1;
975 ublas_v1 = ublas_v1 - alpha * ublas_v2;
976 vcl_v1 = vcl_v1 - gpu_alpha * vcl_v2;
978 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
981 std::cout <<
"Testing multiply-subtract on vector with GPU scalar (both)..." << std::endl;
982 ublas_v2 = NumericT(3.1415) * ublas_v1;
986 ublas_v1 = alpha * ublas_v1 - beta * ublas_v2;
987 vcl_v1 = gpu_alpha * vcl_v1 - gpu_beta * vcl_v2;
989 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
992 std::cout <<
"Testing inplace multiply-subtract on vector with GPU scalar (both, adding)..." << std::endl;
993 ublas_v2 = NumericT(3.1415) * ublas_v1;
997 ublas_v1 -= alpha * ublas_v1 + beta * ublas_v2;
998 vcl_v1 -= gpu_alpha * vcl_v1 + gpu_beta * vcl_v2;
1000 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1001 return EXIT_FAILURE;
1003 std::cout <<
"Testing inplace multiply-subtract on vector with GPU scalar (both, subtracting)..." << std::endl;
1004 ublas_v2 = NumericT(3.1415) * ublas_v1;
1005 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1006 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1008 ublas_v1 -= alpha * ublas_v1 - beta * ublas_v2;
1009 vcl_v1 -= gpu_alpha * vcl_v1 - gpu_beta * vcl_v2;
1011 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1012 return EXIT_FAILURE;
1015 std::cout <<
"Testing inplace multiply-subtract on vector with GPU scalar..." << std::endl;
1016 ublas_v2 = NumericT(3.1415) * ublas_v1;
1017 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1018 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1020 ublas_v1 -= alpha * ublas_v2;
1021 vcl_v1 -= gpu_alpha * vcl_v2;
1023 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1024 return EXIT_FAILURE;
1031 std::cout <<
"Testing division-subtract on vector with CPU scalar (right)..." << std::endl;
1032 for (
size_t i=0; i < ublas_v1.size(); ++i)
1033 ublas_v1(i) = NumericT(1.0) + random<NumericT>();
1034 ublas_v2 = NumericT(3.1415) * ublas_v1;
1035 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1036 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1038 ublas_v1 = ublas_v1 - ublas_v2 / alpha;
1039 vcl_v1 = vcl_v1 - vcl_v2 / alpha;
1041 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1042 return EXIT_FAILURE;
1045 std::cout <<
"Testing division-subtract on vector with CPU scalar (left)..." << std::endl;
1046 ublas_v2 = NumericT(3.1415) * ublas_v1;
1047 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1048 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1050 ublas_v1 = ublas_v1 / alpha - ublas_v2;
1051 vcl_v1 = vcl_v1 / alpha - vcl_v2;
1053 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1054 return EXIT_FAILURE;
1056 std::cout <<
"Testing division-subtract on vector with CPU scalar (both)..." << std::endl;
1057 ublas_v2 = NumericT(3.1415) * ublas_v1;
1058 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1059 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1061 ublas_v1 = ublas_v1 / alpha - ublas_v2 / alpha;
1062 vcl_v1 = vcl_v1 / alpha - vcl_v2 / alpha;
1064 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1065 return EXIT_FAILURE;
1068 std::cout <<
"Testing inplace division-subtract on vector with CPU scalar..." << std::endl;
1069 ublas_v2 = NumericT(3.1415) * ublas_v1;
1070 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1071 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1073 ublas_v1 -= ublas_v2 / alpha;
1074 vcl_v1 -= vcl_v2 / alpha;
1076 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1077 return EXIT_FAILURE;
1079 std::cout <<
"Testing inplace division-subtract on vector with GPU scalar..." << std::endl;
1080 ublas_v2 = NumericT(3.1415) * ublas_v1;
1081 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1082 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1084 ublas_v1 -= ublas_v2 / alpha;
1085 vcl_v1 -= vcl_v2 / gpu_alpha;
1087 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1088 return EXIT_FAILURE;
1091 std::cout <<
"Testing division-subtract on vector with GPU scalar (right)..." << std::endl;
1092 ublas_v2 = NumericT(3.1415) * ublas_v1;
1093 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1094 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1096 ublas_v1 = ublas_v1 - ublas_v2 / alpha;
1097 vcl_v1 = vcl_v1 - vcl_v2 / gpu_alpha;
1099 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1100 return EXIT_FAILURE;
1102 std::cout <<
"Testing division-subtract on vector with GPU scalar (left)..." << std::endl;
1103 ublas_v2 = NumericT(3.1415) * ublas_v1;
1104 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1105 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1107 ublas_v1 = ublas_v1 - ublas_v2 / alpha;
1108 vcl_v1 = vcl_v1 - vcl_v2 / gpu_alpha;
1110 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1111 return EXIT_FAILURE;
1113 std::cout <<
"Testing division-subtract on vector with GPU scalar (both)..." << std::endl;
1114 ublas_v2 = NumericT(3.1415) * ublas_v1;
1115 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1116 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1118 ublas_v1 = ublas_v1 / alpha - ublas_v2 / beta;
1119 vcl_v1 = vcl_v1 / gpu_alpha - vcl_v2 / gpu_beta;
1121 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1122 return EXIT_FAILURE;
1124 std::cout <<
"Testing inplace division-subtract on vector with GPU scalar (both, adding)..." << std::endl;
1125 ublas_v2 = NumericT(3.1415) * ublas_v1;
1126 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1127 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1129 ublas_v1 -= ublas_v1 / alpha + ublas_v2 / beta;
1130 vcl_v1 -= vcl_v1 / gpu_alpha + vcl_v2 / gpu_beta;
1132 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1133 return EXIT_FAILURE;
1135 std::cout <<
"Testing inplace division-subtract on vector with GPU scalar (both, subtracting)..." << std::endl;
1136 ublas_v2 = NumericT(3.1415) * ublas_v1;
1137 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1138 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1140 ublas_v1 -= ublas_v1 / alpha - ublas_v2 / beta;
1141 vcl_v1 -= vcl_v1 / gpu_alpha - vcl_v2 / gpu_beta;
1143 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1144 return EXIT_FAILURE;
1146 std::cout <<
"Testing multiply-division-subtract on vector with GPU scalar..." << std::endl;
1147 ublas_v2 = NumericT(3.1415) * ublas_v1;
1148 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1149 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1151 ublas_v1 = ublas_v1 * alpha - ublas_v2 / beta;
1152 vcl_v1 = vcl_v1 * gpu_alpha - vcl_v2 / gpu_beta;
1154 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1155 return EXIT_FAILURE;
1157 std::cout <<
"Testing division-multiply-subtract on vector with GPU scalar..." << std::endl;
1158 ublas_v2 = NumericT(3.1415) * ublas_v1;
1159 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1160 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1162 ublas_v1 = ublas_v1 / alpha - ublas_v2 * beta;
1163 vcl_v1 = vcl_v1 / gpu_alpha - vcl_v2 * gpu_beta;
1165 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1166 return EXIT_FAILURE;
1168 std::cout <<
"Testing inplace multiply-division-subtract on vector with GPU scalar (adding)..." << std::endl;
1169 ublas_v2 = NumericT(3.1415) * ublas_v1;
1170 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1171 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1173 ublas_v1 -= ublas_v1 * alpha + ublas_v2 / beta;
1174 vcl_v1 -= vcl_v1 * gpu_alpha + vcl_v2 / gpu_beta;
1176 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1177 return EXIT_FAILURE;
1179 std::cout <<
"Testing inplace division-multiply-subtract on vector with GPU scalar (adding)..." << std::endl;
1180 ublas_v2 = NumericT(3.1415) * ublas_v1;
1181 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1182 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1184 ublas_v1 -= ublas_v1 / alpha + ublas_v2 * beta;
1185 vcl_v1 -= vcl_v1 / gpu_alpha + vcl_v2 * gpu_beta;
1187 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1188 return EXIT_FAILURE;
1190 std::cout <<
"Testing inplace multiply-division-subtract on vector with GPU scalar (subtracting)..." << std::endl;
1191 ublas_v2 = NumericT(3.1415) * ublas_v1;
1192 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1193 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1195 ublas_v1 -= ublas_v1 * alpha - ublas_v2 / beta;
1196 vcl_v1 -= vcl_v1 * gpu_alpha - vcl_v2 / gpu_beta;
1198 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1199 return EXIT_FAILURE;
1201 std::cout <<
"Testing inplace division-multiply-subtract on vector with GPU scalar (subtracting)..." << std::endl;
1202 ublas_v2 = NumericT(3.1415) * ublas_v1;
1203 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1204 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1206 ublas_v1 -= ublas_v1 / alpha - ublas_v2 * beta;
1207 vcl_v1 -= vcl_v1 / gpu_alpha - vcl_v2 * gpu_beta;
1209 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1210 return EXIT_FAILURE;
1213 std::cout <<
"Testing inplace division-subtract on vector with GPU scalar..." << std::endl;
1214 ublas_v2 = NumericT(3.1415) * ublas_v1;
1215 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1216 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1218 ublas_v1 -= alpha * ublas_v2;
1219 vcl_v1 -= gpu_alpha * vcl_v2;
1221 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1222 return EXIT_FAILURE;
1229 for (
size_t i=0; i < ublas_v1.size(); ++i)
1230 ublas_v1(i) = NumericT(1.0) + random<NumericT>();
1231 ublas_v2 = NumericT(3.1415) * ublas_v1;
1232 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1233 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1235 std::cout <<
"Testing three vector additions..." << std::endl;
1236 ublas_v1 = ublas_v2 + ublas_v1 + ublas_v2;
1237 vcl_v1 = vcl_v2 + vcl_v1 + vcl_v2;
1239 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1240 return EXIT_FAILURE;
1243 ublas_v2 = NumericT(3.1415) * ublas_v1;
1244 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1245 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1247 std::cout <<
"Testing complicated vector expression with CPU scalar..." << std::endl;
1248 ublas_v1 = beta * (ublas_v1 - alpha * ublas_v2);
1249 vcl_v1 = beta * (vcl_v1 - alpha * vcl_v2);
1251 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1252 return EXIT_FAILURE;
1254 std::cout <<
"Testing complicated vector expression with GPU scalar..." << std::endl;
1255 ublas_v1 = beta * (ublas_v1 - alpha * ublas_v2);
1256 vcl_v1 = gpu_beta * (vcl_v1 - gpu_alpha * vcl_v2);
1258 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1259 return EXIT_FAILURE;
1262 ublas_v2 = NumericT(3.1415) * ublas_v1;
1263 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1264 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1266 std::cout <<
"Testing swap..." << std::endl;
1267 swap(ublas_v1, ublas_v2);
1268 swap(vcl_v1, vcl_v2);
1270 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1271 return EXIT_FAILURE;
1274 for (std::size_t i=0; i<ublas_v1.size(); ++i)
1276 ublas_v1[i] = NumericT(1.0) + random<NumericT>();
1277 ublas_v2[i] = NumericT(5.0) + random<NumericT>();
1280 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1281 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1283 std::cout <<
"Testing unary operator-..." << std::endl;
1284 ublas_v1 = - ublas_v2;
1287 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1288 return EXIT_FAILURE;
1291 std::cout <<
"Testing elementwise multiplication..." << std::endl;
1292 std::cout <<
" v1 = element_prod(v1, v2);" << std::endl;
1296 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1297 return EXIT_FAILURE;
1299 std::cout <<
" v1 += element_prod(v1, v2);" << std::endl;
1303 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1304 return EXIT_FAILURE;
1306 std::cout <<
" v1 -= element_prod(v1, v2);" << std::endl;
1310 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1311 return EXIT_FAILURE;
1314 std::cout <<
" v1 = element_prod(v1 + v2, v2);" << std::endl;
1318 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1319 return EXIT_FAILURE;
1321 std::cout <<
" v1 += element_prod(v1 + v2, v2);" << std::endl;
1325 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1326 return EXIT_FAILURE;
1328 std::cout <<
" v1 -= element_prod(v1 + v2, v2);" << std::endl;
1332 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1333 return EXIT_FAILURE;
1336 std::cout <<
" v1 = element_prod(v1, v2 + v1);" << std::endl;
1340 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1341 return EXIT_FAILURE;
1343 std::cout <<
" v1 += element_prod(v1, v2 + v1);" << std::endl;
1347 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1348 return EXIT_FAILURE;
1350 std::cout <<
" v1 -= element_prod(v1, v2 + v1);" << std::endl;
1354 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1355 return EXIT_FAILURE;
1358 std::cout <<
" v1 = element_prod(v1 + v2, v2 + v1);" << std::endl;
1362 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1363 return EXIT_FAILURE;
1365 std::cout <<
" v1 += element_prod(v1 + v2, v2 + v1);" << std::endl;
1369 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1370 return EXIT_FAILURE;
1372 std::cout <<
" v1 -= element_prod(v1 + v2, v2 + v1);" << std::endl;
1376 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1377 return EXIT_FAILURE;
1380 std::cout <<
"Testing elementwise division..." << std::endl;
1381 for (std::size_t i=0; i<ublas_v1.size(); ++i)
1383 ublas_v1[i] = NumericT(1.0) + random<NumericT>();
1384 ublas_v2[i] = NumericT(5.0) + random<NumericT>();
1387 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1388 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1393 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1394 return EXIT_FAILURE;
1399 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1400 return EXIT_FAILURE;
1405 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1406 return EXIT_FAILURE;
1412 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1413 return EXIT_FAILURE;
1418 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1419 return EXIT_FAILURE;
1424 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1425 return EXIT_FAILURE;
1431 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1432 return EXIT_FAILURE;
1437 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1438 return EXIT_FAILURE;
1443 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1444 return EXIT_FAILURE;
1450 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1451 return EXIT_FAILURE;
1456 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1457 return EXIT_FAILURE;
1462 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1463 return EXIT_FAILURE;
1466 std::cout <<
"Testing elementwise power function..." << std::endl;
1467 for (std::size_t i=0; i<ublas_v1.size(); ++i)
1469 ublas_v1[i] = NumericT(1.1) + NumericT(0.5) * random<NumericT>();
1470 ublas_v2[i] = NumericT(1.1) + NumericT(0.5) * random<NumericT>();
1472 UblasVectorType ublas_v3 = ublas_v1;
1474 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1475 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1477 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1478 ublas_v3[i] = std::pow(ublas_v1[i], ublas_v2[i]);
1479 vcl_v1 = viennacl::linalg::element_pow(vcl_v1, vcl_v2);
1481 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1483 std::cerr <<
"** Failure in v1 = pow(v1, v2);" << std::endl;
1484 return EXIT_FAILURE;
1487 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1488 ublas_v3 = ublas_v1;
1489 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1490 ublas_v3[i] += std::pow(ublas_v1[i], ublas_v2[i]);
1491 vcl_v1 += viennacl::linalg::element_pow(vcl_v1, vcl_v2);
1493 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1495 std::cerr <<
"** Failure in v1 += pow(v1, v2);" << std::endl;
1496 return EXIT_FAILURE;
1499 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1500 ublas_v3 = ublas_v1;
1501 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1502 ublas_v3[i] -= std::pow(ublas_v1[i], ublas_v2[i]);
1503 vcl_v1 -= viennacl::linalg::element_pow(vcl_v1, vcl_v2);
1505 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1507 std::cerr <<
"** Failure in v1 -= pow(v1, v2);" << std::endl;
1508 return EXIT_FAILURE;
1512 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1513 ublas_v3 = ublas_v1;
1514 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1515 ublas_v3[i] = std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i]);
1516 vcl_v1 = viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2);
1518 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1520 std::cerr <<
"** Failure in v1 = pow(v1 + v2, v2);" << std::endl;
1521 return EXIT_FAILURE;
1524 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1525 ublas_v3 = ublas_v1;
1526 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1527 ublas_v3[i] += std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i]);
1528 vcl_v1 += viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2);
1530 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1532 std::cerr <<
"** Failure in v1 += pow(v1 + v2, v2);" << std::endl;
1533 return EXIT_FAILURE;
1536 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1537 ublas_v3 = ublas_v1;
1538 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1539 ublas_v3[i] -= std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i]);
1540 vcl_v1 -= viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2);
1542 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1544 std::cerr <<
"** Failure in v1 -= pow(v1 + v2, v2);" << std::endl;
1545 return EXIT_FAILURE;
1549 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1550 ublas_v3 = ublas_v1;
1551 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1552 ublas_v3[i] = std::pow(ublas_v1[i], ublas_v2[i] + ublas_v1[i]);
1553 vcl_v1 = viennacl::linalg::element_pow(vcl_v1, vcl_v2 + vcl_v1);
1555 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1557 std::cerr <<
"** Failure in v1 = pow(v1, v2 + v1);" << std::endl;
1558 return EXIT_FAILURE;
1561 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1562 ublas_v3 = ublas_v1;
1563 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1564 ublas_v3[i] += std::pow(ublas_v1[i], ublas_v2[i] + ublas_v1[i]);
1565 vcl_v1 += viennacl::linalg::element_pow(vcl_v1, vcl_v2 + vcl_v1);
1567 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1569 std::cerr <<
"** Failure in v1 += pow(v1, v2 + v1);" << std::endl;
1570 return EXIT_FAILURE;
1573 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1574 ublas_v3 = ublas_v1;
1575 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1576 ublas_v3[i] -= std::pow(ublas_v1[i], ublas_v2[i] + ublas_v1[i]);
1577 vcl_v1 -= viennacl::linalg::element_pow(vcl_v1, vcl_v2 + vcl_v1);
1579 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1581 std::cerr <<
"** Failure in v1 -= pow(v1, v2 + v1);" << std::endl;
1582 return EXIT_FAILURE;
1586 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1587 ublas_v3 = ublas_v1;
1588 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1589 ublas_v3[i] = std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i] + ublas_v1[i]);
1590 vcl_v1 = viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1592 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1594 std::cerr <<
"** Failure in v1 = pow(v1 + v2, v2 + v1);" << std::endl;
1595 return EXIT_FAILURE;
1598 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1599 ublas_v3 = ublas_v1;
1600 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1601 ublas_v3[i] += std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i] + ublas_v1[i]);
1602 vcl_v1 += viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1604 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1606 std::cerr <<
"** Failure in v1 += pow(v1 + v2, v2 + v1);" << std::endl;
1607 return EXIT_FAILURE;
1610 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1611 ublas_v3 = ublas_v1;
1612 for (std::size_t i=0; i<ublas_v3.size(); ++i)
1613 ublas_v3[i] -= std::pow(ublas_v1[i] + ublas_v2[i], ublas_v2[i] + ublas_v1[i]);
1614 vcl_v1 -= viennacl::linalg::element_pow(vcl_v1 + vcl_v2, vcl_v2 + vcl_v1);
1616 if (
check(ublas_v3, vcl_v1, epsilon) != EXIT_SUCCESS)
1618 std::cerr <<
"** Failure in v1 -= pow(v1 + v2, v2 + v1);" << std::endl;
1619 return EXIT_FAILURE;
1622 std::cout <<
"Testing unary elementwise operations..." << std::endl;
1623 for (
size_t i=0; i < ublas_v1.size(); ++i)
1624 ublas_v1(i) = random<NumericT>() / NumericT(4);
1626 #define GENERATE_UNARY_OP_TEST(FUNCNAME) \
1627 ublas_v2 = NumericT(3.1415) * ublas_v1; \
1628 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin()); \
1629 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin()); \
1631 for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1632 ublas_v1[i] = std::FUNCNAME(ublas_v2[i]); \
1633 vcl_v1 = viennacl::linalg::element_##FUNCNAME(vcl_v2); \
1635 if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1637 std::cout << "Failure at v1 = " << #FUNCNAME << "(v2)" << std::endl; \
1638 return EXIT_FAILURE; \
1641 for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1642 ublas_v1[i] = std::FUNCNAME(ublas_v1[i] + ublas_v2[i]); \
1643 vcl_v1 = viennacl::linalg::element_##FUNCNAME(vcl_v1 + vcl_v2); \
1645 if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1647 std::cout << "Failure at v1 = " << #FUNCNAME << "(v1 + v2)" << std::endl; \
1648 return EXIT_FAILURE; \
1651 for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1652 ublas_v1[i] += std::FUNCNAME(ublas_v1[i]); \
1653 vcl_v1 += viennacl::linalg::element_##FUNCNAME(vcl_v1); \
1655 if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1657 std::cout << "Failure at v1 += " << #FUNCNAME << "(v2)" << std::endl; \
1658 return EXIT_FAILURE; \
1661 for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1662 ublas_v1[i] += std::FUNCNAME(ublas_v1[i] + ublas_v2[i]); \
1663 vcl_v1 += viennacl::linalg::element_##FUNCNAME(vcl_v1 + vcl_v2); \
1665 if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1667 std::cout << "Failure at v1 += " << #FUNCNAME << "(v1 + v2)" << std::endl; \
1668 return EXIT_FAILURE; \
1671 for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1672 ublas_v1[i] -= std::FUNCNAME(ublas_v2[i]); \
1673 vcl_v1 -= viennacl::linalg::element_##FUNCNAME(vcl_v2); \
1675 if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1677 std::cout << "Failure at v1 -= " << #FUNCNAME << "(v2)" << std::endl; \
1678 return EXIT_FAILURE; \
1681 for (std::size_t i=0; i<ublas_v1.size(); ++i) \
1682 ublas_v1[i] -= std::FUNCNAME(ublas_v1[i] + ublas_v2[i]); \
1683 vcl_v1 -= viennacl::linalg::element_##FUNCNAME(vcl_v1 + vcl_v2); \
1685 if (check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS) \
1687 std::cout << "Failure at v1 -= " << #FUNCNAME << "(v1 + v2)" << std::endl; \
1688 return EXIT_FAILURE; \
1693 for (
size_t i=0; i < ublas_v1.size(); ++i)
1694 ublas_v1(i) = random<NumericT>() / NumericT(4);
1709 ublas_v2 = NumericT(3.1415) * ublas_v1;
1710 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1711 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1713 std::cout <<
"Testing another complicated vector expression with CPU scalars..." << std::endl;
1714 ublas_v1 = ublas_v2 / alpha + beta * (ublas_v1 - alpha*ublas_v2);
1715 vcl_v1 = vcl_v2 / alpha + beta * (vcl_v1 - alpha*vcl_v2);
1717 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1718 return EXIT_FAILURE;
1720 std::cout <<
"Testing another complicated vector expression with GPU scalars..." << std::endl;
1721 ublas_v2 = NumericT(3.1415) * ublas_v1;
1722 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1723 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1725 ublas_v1 = ublas_v2 / alpha + beta * (ublas_v1 - alpha*ublas_v2);
1726 vcl_v1 = vcl_v2 / gpu_alpha + gpu_beta * (vcl_v1 - gpu_alpha*vcl_v2);
1728 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1729 return EXIT_FAILURE;
1732 std::cout <<
"Testing lenghty sum of scaled vectors..." << std::endl;
1733 ublas_v2 = NumericT(3.1415) * ublas_v1;
1734 viennacl::copy(ublas_v1.begin(), ublas_v1.end(), vcl_v1.begin());
1735 viennacl::copy(ublas_v2.begin(), ublas_v2.end(), vcl_v2.begin());
1737 ublas_v1 = ublas_v2 / alpha + beta * ublas_v1 - alpha * ublas_v2 + beta * ublas_v1 - alpha * ublas_v1;
1738 vcl_v1 = vcl_v2 / gpu_alpha + gpu_beta * vcl_v1 - alpha * vcl_v2 + beta * vcl_v1 - alpha * vcl_v1;
1740 if (
check(ublas_v1, vcl_v1, epsilon) != EXIT_SUCCESS)
1741 return EXIT_FAILURE;
1748 template<
typename NumericT,
typename Epsilon >
1751 int retval = EXIT_SUCCESS;
1752 std::size_t
size = 24656;
1754 std::cout <<
"Running tests for vector of size " << size << std::endl;
1759 ublas::vector<NumericT> ublas_full_vec(size);
1760 ublas::vector<NumericT> ublas_full_vec2(ublas_full_vec.size());
1762 for (std::size_t i=0; i<ublas_full_vec.size(); ++i)
1764 ublas_full_vec[i] = NumericT(1.0) + random<NumericT>();
1765 ublas_full_vec2[i] = NumericT(1.0) + random<NumericT>();
1768 ublas::range r1( ublas_full_vec.size() / 4, 2 * ublas_full_vec.size() / 4);
1769 ublas::range r2(2 * ublas_full_vec2.size() / 4, 3 * ublas_full_vec2.size() / 4);
1770 ublas::vector_range< ublas::vector<NumericT> > ublas_range_vec(ublas_full_vec, r1);
1771 ublas::vector_range< ublas::vector<NumericT> > ublas_range_vec2(ublas_full_vec2, r2);
1773 ublas::slice s1( ublas_full_vec.size() / 4, 3, ublas_full_vec.size() / 4);
1774 ublas::slice s2(2 * ublas_full_vec2.size() / 4, 2, ublas_full_vec2.size() / 4);
1775 ublas::vector_slice< ublas::vector<NumericT> > ublas_slice_vec(ublas_full_vec,
s1);
1776 ublas::vector_slice< ublas::vector<NumericT> > ublas_slice_vec2(ublas_full_vec2,
s2);
1785 viennacl::copy(ublas_full_vec2.begin(), ublas_full_vec2.end(), vcl_full_vec2.begin());
1787 viennacl::range vcl_r1( vcl_full_vec.size() / 4, 2 * vcl_full_vec.size() / 4);
1788 viennacl::range vcl_r2(2 * vcl_full_vec2.size() / 4, 3 * vcl_full_vec2.size() / 4);
1796 ublas::vector<NumericT> ublas_short_vec(ublas_range_vec);
1797 ublas::vector<NumericT> ublas_short_vec2(ublas_range_vec2);
1799 std::cout <<
"Testing creation of vectors from range..." << std::endl;
1800 if (
check(ublas_short_vec, vcl_short_vec, epsilon) != EXIT_SUCCESS)
1801 return EXIT_FAILURE;
1802 if (
check(ublas_short_vec2, vcl_short_vec2, epsilon) != EXIT_SUCCESS)
1803 return EXIT_FAILURE;
1806 viennacl::slice vcl_s1( vcl_full_vec.size() / 4, 3, vcl_full_vec.size() / 4);
1807 viennacl::slice vcl_s2(2 * vcl_full_vec2.size() / 4, 2, vcl_full_vec2.size() / 4);
1814 ublas::vector<NumericT> ublas_short_vec(ublas_slice_vec);
1815 ublas::vector<NumericT> ublas_short_vec2(ublas_slice_vec2);
1817 std::cout <<
"Testing creation of vectors from slice..." << std::endl;
1818 if (
check(ublas_short_vec, vcl_short_vec, epsilon) != EXIT_SUCCESS)
1819 return EXIT_FAILURE;
1820 if (
check(ublas_short_vec2, vcl_short_vec2, epsilon) != EXIT_SUCCESS)
1821 return EXIT_FAILURE;
1828 std::cout <<
" ** vcl_v1 = vector, vcl_v2 = vector **" << std::endl;
1829 retval = test<NumericT>(epsilon,
1830 ublas_short_vec, ublas_short_vec2,
1831 vcl_short_vec, vcl_short_vec2);
1832 if (retval != EXIT_SUCCESS)
1833 return EXIT_FAILURE;
1835 std::cout <<
" ** vcl_v1 = vector, vcl_v2 = range **" << std::endl;
1836 retval = test<NumericT>(epsilon,
1837 ublas_short_vec, ublas_short_vec2,
1838 vcl_short_vec, vcl_range_vec2);
1839 if (retval != EXIT_SUCCESS)
1840 return EXIT_FAILURE;
1842 std::cout <<
" ** vcl_v1 = vector, vcl_v2 = slice **" << std::endl;
1843 retval = test<NumericT>(epsilon,
1844 ublas_short_vec, ublas_short_vec2,
1845 vcl_short_vec, vcl_slice_vec2);
1846 if (retval != EXIT_SUCCESS)
1847 return EXIT_FAILURE;
1851 std::cout <<
" ** vcl_v1 = range, vcl_v2 = vector **" << std::endl;
1852 retval = test<NumericT>(epsilon,
1853 ublas_short_vec, ublas_short_vec2,
1854 vcl_range_vec, vcl_short_vec2);
1855 if (retval != EXIT_SUCCESS)
1856 return EXIT_FAILURE;
1858 std::cout <<
" ** vcl_v1 = range, vcl_v2 = range **" << std::endl;
1859 retval = test<NumericT>(epsilon,
1860 ublas_short_vec, ublas_short_vec2,
1861 vcl_range_vec, vcl_range_vec2);
1862 if (retval != EXIT_SUCCESS)
1863 return EXIT_FAILURE;
1865 std::cout <<
" ** vcl_v1 = range, vcl_v2 = slice **" << std::endl;
1866 retval = test<NumericT>(epsilon,
1867 ublas_short_vec, ublas_short_vec2,
1868 vcl_range_vec, vcl_slice_vec2);
1869 if (retval != EXIT_SUCCESS)
1870 return EXIT_FAILURE;
1874 std::cout <<
" ** vcl_v1 = slice, vcl_v2 = vector **" << std::endl;
1875 retval = test<NumericT>(epsilon,
1876 ublas_short_vec, ublas_short_vec2,
1877 vcl_slice_vec, vcl_short_vec2);
1878 if (retval != EXIT_SUCCESS)
1879 return EXIT_FAILURE;
1881 std::cout <<
" ** vcl_v1 = slice, vcl_v2 = range **" << std::endl;
1882 retval = test<NumericT>(epsilon,
1883 ublas_short_vec, ublas_short_vec2,
1884 vcl_slice_vec, vcl_range_vec2);
1885 if (retval != EXIT_SUCCESS)
1886 return EXIT_FAILURE;
1888 std::cout <<
" ** vcl_v1 = slice, vcl_v2 = slice **" << std::endl;
1889 retval = test<NumericT>(epsilon,
1890 ublas_short_vec, ublas_short_vec2,
1891 vcl_slice_vec, vcl_slice_vec2);
1892 if (retval != EXIT_SUCCESS)
1893 return EXIT_FAILURE;
1895 return EXIT_SUCCESS;
1904 std::cout << std::endl;
1905 std::cout <<
"----------------------------------------------" << std::endl;
1906 std::cout <<
"----------------------------------------------" << std::endl;
1907 std::cout <<
"## Test :: Vector" << std::endl;
1908 std::cout <<
"----------------------------------------------" << std::endl;
1909 std::cout <<
"----------------------------------------------" << std::endl;
1910 std::cout << std::endl;
1912 int retval = EXIT_SUCCESS;
1914 std::cout << std::endl;
1915 std::cout <<
"----------------------------------------------" << std::endl;
1916 std::cout << std::endl;
1918 typedef float NumericT;
1919 NumericT epsilon =
static_cast<NumericT
>(1.0E-2);
1920 std::cout <<
"# Testing setup:" << std::endl;
1921 std::cout <<
" eps: " << epsilon << std::endl;
1922 std::cout <<
" numeric: float" << std::endl;
1923 retval = test<NumericT>(epsilon);
1924 if ( retval == EXIT_SUCCESS )
1925 std::cout <<
"# Test passed" << std::endl;
1929 std::cout << std::endl;
1930 std::cout <<
"----------------------------------------------" << std::endl;
1931 std::cout << std::endl;
1932 #ifdef VIENNACL_WITH_OPENCL
1937 typedef double NumericT;
1938 NumericT epsilon = 1.0E-10;
1939 std::cout <<
"# Testing setup:" << std::endl;
1940 std::cout <<
" eps: " << epsilon << std::endl;
1941 std::cout <<
" numeric: double" << std::endl;
1942 retval = test<NumericT>(epsilon);
1943 if ( retval == EXIT_SUCCESS )
1944 std::cout <<
"# Test passed" << std::endl;
1948 std::cout << std::endl;
1949 std::cout <<
"----------------------------------------------" << std::endl;
1950 std::cout << std::endl;
1953 std::cout << std::endl;
1954 std::cout <<
"------- Test completed --------" << std::endl;
1955 std::cout << std::endl;
viennacl::vector_expression< const vector_base< T >, const vector_base< T >, op_element_binary< op_div > > element_div(vector_base< T > const &v1, vector_base< T > const &v2)
T norm_2(std::vector< T, A > const &v1)
vcl_size_t index_norm_inf(vector_base< T > const &vec)
Computes the index of the first entry that is equal to the supremum-norm in modulus.
This class represents a single scalar value on the GPU and behaves mostly like a built-in scalar type...
Generic interface for the l^2-norm. See viennacl/linalg/vector_operations.hpp for implementations...
void plane_rotation(vector_base< T > &vec1, vector_base< T > &vec2, T alpha, T beta)
Computes a plane rotation of two vectors.
void finish()
Synchronizes the execution. finish() will only return after all compute kernels (CUDA, OpenCL) have completed.
ScalarType diff(ScalarType const &s1, ScalarType const &s2)
viennacl::enable_if< viennacl::is_stl< typename viennacl::traits::tag_of< VectorT1 >::type >::value, typename VectorT1::value_type >::type inner_prod(VectorT1 const &v1, VectorT2 const &v2)
#define GENERATE_UNARY_OP_TEST(FUNCNAME)
viennacl::scalar< int > s2
viennacl::scalar< float > s1
T max(const T &lhs, const T &rhs)
Maximum.
viennacl::ocl::device const & current_device()
Convenience function for returning the active device in the current context.
Generic interface for the computation of inner products. See viennacl/linalg/vector_operations.hpp for implementations.
Generic interface for the l^1-norm. See viennacl/linalg/vector_operations.hpp for implementations...
viennacl::vector< float > v1
vcl_size_t size(VectorType const &vec)
Generic routine for obtaining the size of a vector (ViennaCL, uBLAS, etc.)
Class for representing non-strided subvectors of a bigger vector x.
int check(T1 const &t1, T2 const &t2, double epsilon)
Class for representing strided subvectors of a bigger vector x.
bool double_support() const
ViennaCL convenience function: Returns true if the device supports double precision.
Proxy classes for vectors.
viennacl::enable_if< viennacl::is_scalar< ScalarT1 >::value &&viennacl::is_scalar< ScalarT2 >::value >::type swap(ScalarT1 &s1, ScalarT2 &s2)
Swaps the contents of two scalars, data is copied.
Represents a vector consisting of 1 at a given index and zeros otherwise.
The vector type with operator-overloads and proxy classes is defined here. Linear algebra operations ...
Represents a vector consisting of scalars 's' only, i.e. v[i] = s for all i. To be used as an initial...
NumericT max(std::vector< NumericT > const &v1)
T norm_inf(std::vector< T, A > const &v1)
void copy(std::vector< NumericT > &cpu_vec, circulant_matrix< NumericT, AlignmentV > &gpu_mat)
Copies a circulant matrix from the std::vector to the OpenCL device (either GPU or multi-core CPU) ...
T norm_1(std::vector< T, A > const &v1)
A range class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
viennacl::vector_expression< const vector_base< T >, const vector_base< T >, op_element_binary< op_prod > > element_prod(vector_base< T > const &v1, vector_base< T > const &v2)
int test(Epsilon const &epsilon, UblasVectorType &ublas_v1, UblasVectorType &ublas_v2, ViennaCLVectorType1 &vcl_v1, ViennaCLVectorType2 &vcl_v2)
A slice class that refers to an interval [start, stop), where 'start' is included, and 'stop' is excluded.
A proxy class for a single element of a vector or matrix. This proxy should not be noticed by end-use...
Generic interface for the l^infty-norm. See viennacl/linalg/vector_operations.hpp for implementations...
NumericT min(std::vector< NumericT > const &v1)
void fast_copy(const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_begin, const const_vector_iterator< SCALARTYPE, ALIGNMENT > &gpu_end, CPU_ITERATOR cpu_begin)