void inplace_solve(const matrix_base<NumericT> & mat,
                             vector_base<NumericT> & vec,
                       SOLVERTAG)
    {
      assert( (mat.size1() == vec.size()) && bool("Size check failed in inplace_solve(): size1(A) != size(b)"));
      assert( (mat.size2() == vec.size()) && bool("Size check failed in inplace_solve(): size2(A) != size(b)"));

      switch (viennacl::traits::handle(mat).get_active_handle_id())
      {
        case viennacl::MAIN_MEMORY:
          viennacl::linalg::host_based::inplace_solve(mat, false, vec, SOLVERTAG());
          break;
#ifdef VIENNACL_WITH_OPENCL
        case viennacl::OPENCL_MEMORY:
          viennacl::linalg::opencl::inplace_solve(mat, false, vec, SOLVERTAG());
          break;
#endif
#ifdef VIENNACL_WITH_CUDA
        case viennacl::CUDA_MEMORY:
          viennacl::linalg::cuda::inplace_solve(mat, false, vec, SOLVERTAG());
          break;
#endif
        case viennacl::MEMORY_NOT_INITIALIZED:
          throw memory_exception("not initialised!");
        default:
          throw memory_exception("not implemented");
      }
    }

 void norm_frobenius_cpu(matrix_base<T> const & A,
                          T & result)
 {
   typedef typename matrix_base<T>::handle_type  HandleType;
   viennacl::vector_base<T> temp(const_cast<HandleType &>(A.handle()), A.internal_size(), 0, 1);
   norm_2_cpu(temp, result);
 }

 result_type operator()(matrix_base<ScalarType, Layout> const & mat) const {
   mapped_matrix * p = new mapped_matrix(utils::type_to_string<ScalarType>::value());
   p->name_ = create_name(current_arg_, memory_, (void*)&mat);
   p->is_row_major_ = static_cast<bool>(utils::is_same_type<Layout, viennacl::row_major>::value);
   if(mat.start1() > 0)
     p->start1_name_ = p->name_ +"_start1";
   if(mat.stride1() > 1)
     p->stride1_name_ = p->name_ + "_stride1";
   if(mat.start2() > 0)
     p->start2_name_ = p->name_ +"_start2";
   if(mat.stride2() > 1)
     p->stride2_name_ = p->name_ + "_stride2";
   return container_ptr_type(p);
 }

void inplace_solve(matrix_base<NumericT> const & mat,
                   vector_base<NumericT> & vec,
                   SolverTagT)
{
  typedef NumericT        value_type;

  value_type const * data_A = detail::extract_raw_pointer<value_type>(mat);
  value_type       * data_v = detail::extract_raw_pointer<value_type>(vec);

  vcl_size_t A_start1 = viennacl::traits::start1(mat);
  vcl_size_t A_start2 = viennacl::traits::start2(mat);
  vcl_size_t A_inc1   = viennacl::traits::stride1(mat);
  vcl_size_t A_inc2   = viennacl::traits::stride2(mat);
  vcl_size_t A_size2  = viennacl::traits::size2(mat);
  vcl_size_t A_internal_size1  = viennacl::traits::internal_size1(mat);
  vcl_size_t A_internal_size2  = viennacl::traits::internal_size2(mat);

  vcl_size_t start1 = viennacl::traits::start(vec);
  vcl_size_t inc1   = viennacl::traits::stride(vec);

  if (mat.row_major())
  {
    detail::matrix_array_wrapper<value_type const, row_major, false>   wrapper_A(data_A, A_start1, A_start2, A_inc1, A_inc2, A_internal_size1, A_internal_size2);
    detail::vector_array_wrapper<value_type> wrapper_v(data_v, start1, inc1);

    detail::inplace_solve_vector(wrapper_A, wrapper_v, A_size2, SolverTagT());
  }
  else
  {
    detail::matrix_array_wrapper<value_type const, column_major, false>   wrapper_A(data_A, A_start1, A_start2, A_inc1, A_inc2, A_internal_size1, A_internal_size2);
    detail::vector_array_wrapper<value_type> wrapper_v(data_v, start1, inc1);

    detail::inplace_solve_vector(wrapper_A, wrapper_v, A_size2, SolverTagT());
  }
}

bool op_aliasing(matrix_base<NumericT> const & lhs, matrix_base<NumericT> const & b)
{
  return lhs.handle() == b.handle();
}

typename result_of::size_type< matrix_base<NumericT> >::type
stride2(matrix_base<NumericT> const & s) { return s.stride2(); }

bool row_major(matrix_base<NumericT> const & A) { return A.row_major(); }

 vcl_size_t internal_size2(matrix_base<NumericT, F> const & mat) { return mat.internal_size2(); }

vcl_size_t nld(matrix_base<NumericT> const & mat)
{
  if (mat.row_major())
    return mat.stride2();
  return mat.stride1();
}

vcl_size_t ld(matrix_base<NumericT> const & mat)
{
  if (mat.row_major())
    return mat.internal_size2();
  return mat.internal_size1();
}