void inner_prod_cpu(vector_base<T> const & vec1,
vector_base<T> const & vec2,
T & result)
{
assert( vec1.size() == vec2.size() && bool("Size mismatch") );
switch (viennacl::traits::handle(vec1).get_active_handle_id())
{
case viennacl::MAIN_MEMORY:
viennacl::linalg::host_based::inner_prod_impl(vec1, vec2, result);
break;
#ifdef VIENNACL_WITH_OPENCL
case viennacl::OPENCL_MEMORY:
viennacl::linalg::opencl::inner_prod_cpu(vec1, vec2, result);
break;
#endif
#ifdef VIENNACL_WITH_CUDA
case viennacl::CUDA_MEMORY:
viennacl::linalg::cuda::inner_prod_cpu(vec1, vec2, result);
break;
#endif
default:
throw "not implemented";
}
}
void inner_prod_impl(vector_base<T> const & x,
vector_tuple<T> const & y_tuple,
vector_base<T> & result)
{
assert( x.size() == y_tuple.const_at(0).size() && bool("Size mismatch") );
assert( result.size() == y_tuple.const_size() && bool("Number of elements does not match result size") );
switch (viennacl::traits::handle(x).get_active_handle_id())
{
case viennacl::MAIN_MEMORY:
viennacl::linalg::host_based::inner_prod_impl(x, y_tuple, result);
break;
#ifdef VIENNACL_WITH_OPENCL
case viennacl::OPENCL_MEMORY:
viennacl::linalg::opencl::inner_prod_impl(x, y_tuple, result);
break;
#endif
#ifdef VIENNACL_WITH_CUDA
case viennacl::CUDA_MEMORY:
viennacl::linalg::cuda::inner_prod_impl(x, y_tuple, result);
break;
#endif
default:
throw "not implemented";
}
}
result_type operator()(vector_base<ScalarType> const & vec) const {
mapped_vector * p = new mapped_vector(utils::type_to_string<ScalarType>::value());
p->name_ = create_name(current_arg_, memory_, (void*)&vec);
if(vec.start() > 0)
p->start_name_ = p->name_ +"_start";
if(vec.stride() > 1)
p->stride_name_ = p->name_ + "_stride";
return container_ptr_type(p);
}
void inplace_solve(const matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_trans> & proxy,
vector_base<NumericT> & vec,
SOLVERTAG)
{
assert( (proxy.lhs().size1() == vec.size()) && bool("Size check failed in inplace_solve(): size1(A) != size(b)"));
assert( (proxy.lhs().size2() == vec.size()) && bool("Size check failed in inplace_solve(): size2(A) != size(b)"));
switch (viennacl::traits::handle(proxy.lhs()).get_active_handle_id())
{
case viennacl::MAIN_MEMORY:
viennacl::linalg::host_based::inplace_solve(proxy.lhs(), true, vec, SOLVERTAG());
break;
#ifdef VIENNACL_WITH_OPENCL
case viennacl::OPENCL_MEMORY:
viennacl::linalg::opencl::inplace_solve(proxy.lhs(), true, vec, SOLVERTAG());
break;
#endif
#ifdef VIENNACL_WITH_CUDA
case viennacl::CUDA_MEMORY:
viennacl::linalg::cuda::inplace_solve(proxy.lhs(), true, vec, SOLVERTAG());
break;
#endif
case viennacl::MEMORY_NOT_INITIALIZED:
throw memory_exception("not initialised!");
default:
throw memory_exception("not implemented");
}
}
result_type operator()(vector_base<ScalarType> const & vec) const {
*ptr_++='v'; //vector
if(viennacl::traits::start(vec)>0)
*ptr_++='r';
if(vec.stride()>1)
*ptr_++='s';
*ptr_++=utils::first_letter_of_type<ScalarType>::value();
append_id(ptr_, get_id((void*)&vec));
}
void vector_assign(vector_base<T> & vec1, const T & alpha)
{
typedef T value_type;
value_type * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
std::size_t start1 = viennacl::traits::start(vec1);
std::size_t inc1 = viennacl::traits::stride(vec1);
std::size_t size1 = viennacl::traits::size(vec1);
std::size_t internal_size1 = vec1.internal_size(); //Note: Do NOT use traits::internal_size() here, because vector proxies don't require padding.
value_type data_alpha = static_cast<value_type>(alpha);
#ifdef VIENNACL_WITH_OPENMP
#pragma omp parallel for if (internal_size1 > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
#endif
for (std::size_t i = 0; i < internal_size1; ++i)
data_vec1[i*inc1+start1] = (i < size1) ? data_alpha : 0;
}
void vector_assign(vector_base<NumericT> & vec1, const NumericT & alpha, bool up_to_internal_size = false)
{
typedef NumericT value_type;
value_type * data_vec1 = detail::extract_raw_pointer<value_type>(vec1);
vcl_size_t start1 = viennacl::traits::start(vec1);
vcl_size_t inc1 = viennacl::traits::stride(vec1);
vcl_size_t size1 = viennacl::traits::size(vec1);
vcl_size_t loop_bound = up_to_internal_size ? vec1.internal_size() : size1; //Note: Do NOT use traits::internal_size() here, because vector proxies don't require padding.
value_type data_alpha = static_cast<value_type>(alpha);
#ifdef VIENNACL_WITH_OPENMP
#pragma omp parallel for if (loop_bound > VIENNACL_OPENMP_VECTOR_MIN_SIZE)
#endif
for (long i = 0; i < static_cast<long>(loop_bound); ++i)
data_vec1[static_cast<vcl_size_t>(i)*inc1+start1] = data_alpha;
}
bool op_aliasing(vector_base<NumericT> const & lhs, vector_base<NumericT> const & b)
{
return lhs.handle() == b.handle();
}
vcl_size_t internal_size(vector_base<NumericT> const & vec)
{
return vec.internal_size();
}
