C++ (Cpp) matrix_base示例

示例#1

文件： direct_solve.hpp 项目： GnsP/viennacl-dev

    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");
      }
    }

示例#2

文件： matrix_operations.hpp 项目： GnsP/viennacl-dev

 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);
 }

示例#3

文件： map_functor.hpp 项目： YannCobigo/viennacl-dev

 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);
 }

示例#4

文件： direct_solve.hpp 项目： 10imaging/viennacl

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());
  }
}

示例#5

文件： direct_solve.hpp 项目： 10imaging/viennacl

void inplace_solve(matrix_base<NumericT> const & A,
                   matrix_base<NumericT> & B,
                   SolverTagT)
{
  typedef NumericT        value_type;

  value_type const * data_A = detail::extract_raw_pointer<value_type>(A);
  value_type       * data_B = detail::extract_raw_pointer<value_type>(B);

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

  vcl_size_t B_start1 = viennacl::traits::start1(B);
  vcl_size_t B_start2 = viennacl::traits::start2(B);
  vcl_size_t B_inc1   = viennacl::traits::stride1(B);
  vcl_size_t B_inc2   = viennacl::traits::stride2(B);
  //vcl_size_t B_size1  = viennacl::traits::size1(B);
  vcl_size_t B_size2  = viennacl::traits::size2(B);
  vcl_size_t B_internal_size1  = viennacl::traits::internal_size1(B);
  vcl_size_t B_internal_size2  = viennacl::traits::internal_size2(B);


  if (A.row_major() && B.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::matrix_array_wrapper<value_type,       row_major, false>   wrapper_B(data_B, B_start1, B_start2, B_inc1, B_inc2, B_internal_size1, B_internal_size2);

    detail::inplace_solve_matrix(wrapper_A, wrapper_B, A_size2, B_size2, SolverTagT());
  }
  else if (A.row_major() && !B.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::matrix_array_wrapper<value_type,       column_major, false>   wrapper_B(data_B, B_start1, B_start2, B_inc1, B_inc2, B_internal_size1, B_internal_size2);

    detail::inplace_solve_matrix(wrapper_A, wrapper_B, A_size2, B_size2, SolverTagT());
  }
  else if (!A.row_major() && B.row_major())
  {
    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::matrix_array_wrapper<value_type,       row_major,    false>   wrapper_B(data_B, B_start1, B_start2, B_inc1, B_inc2, B_internal_size1, B_internal_size2);

    detail::inplace_solve_matrix(wrapper_A, wrapper_B, A_size2, B_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::matrix_array_wrapper<value_type,       column_major, false>   wrapper_B(data_B, B_start1, B_start2, B_inc1, B_inc2, B_internal_size1, B_internal_size2);

    detail::inplace_solve_matrix(wrapper_A, wrapper_B, A_size2, B_size2, SolverTagT());
  }
}

示例#6

文件： op_executor.hpp 项目： 10imaging/viennacl

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

示例#7

文件： stride.hpp 项目： cdeterman/RViennaCL

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

示例#8

文件： row_major.hpp 项目： Rombur/viennacl-dev

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

示例#9

文件： size.hpp 项目： KratosCSIC/trunk

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

示例#10

文件： size.hpp 项目： a9raag/mahout

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

示例#11

文件： size.hpp 项目： a9raag/mahout

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