forwards.h

Go to the documentation of this file.

#ifndef VIENNACL_FORWARDS_H
#define VIENNACL_FORWARDS_H

/* =========================================================================
   Copyright (c) 2010-2016, Institute for Microelectronics,
                            Institute for Analysis and Scientific Computing,
                            TU Wien.
   Portions of this software are copyright by UChicago Argonne, LLC.

                            -----------------
                  ViennaCL - The Vienna Computing Library
                            -----------------

   Project Head:    Karl Rupp                   rupp@iue.tuwien.ac.at

   (A list of authors and contributors can be found in the manual)

   License:         MIT (X11), see file LICENSE in the base directory
============================================================================= */


//compatibility defines:
#ifdef VIENNACL_HAVE_UBLAS
  #define VIENNACL_WITH_UBLAS
#endif

#ifdef VIENNACL_HAVE_EIGEN
  #define VIENNACL_WITH_EIGEN
#endif

#ifdef VIENNACL_HAVE_MTL4
  #define VIENNACL_WITH_MTL4
#endif

#include <cstddef>
#include <cassert>
#include <string>
#include <stdexcept>

#include "viennacl/meta/enable_if.hpp"
#include "viennacl/version.hpp"

namespace viennacl
{
  typedef std::size_t                                       vcl_size_t;
  typedef std::ptrdiff_t                                    vcl_ptrdiff_t;



  struct op_assign {};
  struct op_inplace_add {};
  struct op_inplace_sub {};

  struct op_add {};
  struct op_sub {};
  struct op_mult {};
  struct op_prod {};
  struct op_mat_mat_prod {};
  struct op_div {};
  struct op_pow {};

 struct op_eq {};
 struct op_neq {};
 struct op_greater {};
 struct op_less {};
 struct op_geq {};
 struct op_leq {};

  struct op_sum {};

  struct op_row_sum {};

  struct op_col_sum {};

  template<typename OP>
  struct op_element_cast {};

  template<typename OP>
  struct op_element_binary {};

  template<typename OP>
  struct op_element_unary {};

  struct op_abs {};
  struct op_acos {};
  struct op_asin {};
  struct op_argmax {};
  struct op_argmin {};
  struct op_atan {};
  struct op_atan2 {};
  struct op_ceil {};
  struct op_cos {};
  struct op_cosh {};
  struct op_exp {};
  struct op_fabs {};
  struct op_fdim {};
  struct op_floor {};
  struct op_fmax {};
  struct op_fmin {};
  struct op_fmod {};
  struct op_log {};
  struct op_log10 {};
  struct op_sin {};
  struct op_sinh {};
  struct op_sqrt {};
  struct op_tan {};
  struct op_tanh {};

  struct op_matrix_diag {};

  struct op_vector_diag {};

  struct op_row {};

  struct op_column {};

  struct op_inner_prod {};

  struct op_norm_1 {};

  struct op_norm_2 {};

  struct op_norm_inf {};

  struct op_max {};

  struct op_min {};


  struct op_norm_frobenius {};

  struct op_trans {};

  struct op_flip_sign {};

  //forward declaration of basic types:
  template<class TYPE>
  class scalar;

  template<typename LHS, typename RHS, typename OP>
  class scalar_expression;

  template<typename SCALARTYPE>
  class entry_proxy;

  template<typename SCALARTYPE>
  class const_entry_proxy;

  template<typename LHS, typename RHS, typename OP>
  class vector_expression;

  template<class SCALARTYPE, unsigned int ALIGNMENT>
  class vector_iterator;

  template<class SCALARTYPE, unsigned int ALIGNMENT>
  class const_vector_iterator;

  template<typename SCALARTYPE>
  class implicit_vector_base;

  template<typename SCALARTYPE>
  struct zero_vector;

  template<typename SCALARTYPE>
  struct unit_vector;

  template<typename SCALARTYPE>
  struct one_vector;

  template<typename SCALARTYPE>
  struct scalar_vector;

  template<class SCALARTYPE, typename SizeType = vcl_size_t, typename DistanceType = vcl_ptrdiff_t>
  class vector_base;

  template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
  class vector;

  template<typename ScalarT>
  class vector_tuple;

  //the following forwards are needed for GMRES
  template<typename SCALARTYPE, unsigned int ALIGNMENT, typename CPU_ITERATOR>
  void copy(CPU_ITERATOR const & cpu_begin,
            CPU_ITERATOR const & cpu_end,
            vector_iterator<SCALARTYPE, ALIGNMENT> gpu_begin);

  template<typename SCALARTYPE, unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>
  void copy(const_vector_iterator<SCALARTYPE, ALIGNMENT_SRC> const & gpu_src_begin,
            const_vector_iterator<SCALARTYPE, ALIGNMENT_SRC> const & gpu_src_end,
            vector_iterator<SCALARTYPE, ALIGNMENT_DEST> gpu_dest_begin);

  template<typename SCALARTYPE, unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>
  void copy(const_vector_iterator<SCALARTYPE, ALIGNMENT_SRC> const & gpu_src_begin,
            const_vector_iterator<SCALARTYPE, ALIGNMENT_SRC> const & gpu_src_end,
            const_vector_iterator<SCALARTYPE, ALIGNMENT_DEST> gpu_dest_begin);

  template<typename SCALARTYPE, unsigned int ALIGNMENT, typename CPU_ITERATOR>
  void fast_copy(const const_vector_iterator<SCALARTYPE, ALIGNMENT> & gpu_begin,
                 const const_vector_iterator<SCALARTYPE, ALIGNMENT> & gpu_end,
                 CPU_ITERATOR cpu_begin );

  template<typename CPU_ITERATOR, typename SCALARTYPE, unsigned int ALIGNMENT>
  void fast_copy(CPU_ITERATOR const & cpu_begin,
                  CPU_ITERATOR const & cpu_end,
                  vector_iterator<SCALARTYPE, ALIGNMENT> gpu_begin);


  struct row_major_tag {};
  struct column_major_tag {};

  struct row_major
  {
    typedef row_major_tag         orientation_category;

    static vcl_size_t mem_index(vcl_size_t i, vcl_size_t j, vcl_size_t /* num_rows */, vcl_size_t num_cols)
    {
      return i * num_cols + j;
    }
  };

  struct column_major
  {
    typedef column_major_tag         orientation_category;

    static vcl_size_t mem_index(vcl_size_t i, vcl_size_t j, vcl_size_t num_rows, vcl_size_t /* num_cols */)
    {
      return i + j * num_rows;
    }
  };

  struct row_iteration;
  struct col_iteration;

  template<typename LHS, typename RHS, typename OP>
  class matrix_expression;

  class context;

  enum memory_types
  {
    MEMORY_NOT_INITIALIZED
    , MAIN_MEMORY
    , OPENCL_MEMORY
    , CUDA_MEMORY
  };

  namespace backend
  {
    class mem_handle;
  }

  //
  // Matrix types:
  //
  static const vcl_size_t dense_padding_size = 128;

  template<typename ROWCOL, typename MATRIXTYPE>
  class matrix_iterator;

  template<class SCALARTYPE, typename SizeType = vcl_size_t, typename DistanceType = vcl_ptrdiff_t>
  class matrix_base;

  template<class SCALARTYPE, typename F = row_major, unsigned int ALIGNMENT = 1>
  class matrix;

  template<typename SCALARTYPE>
  class implicit_matrix_base;

  template<class SCALARTYPE>
  class identity_matrix;

  template<class SCALARTYPE>
  class zero_matrix;

  template<class SCALARTYPE>
  class scalar_matrix;

  template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
  class compressed_matrix;

  template<class SCALARTYPE>
  class compressed_compressed_matrix;


  template<class SCALARTYPE, unsigned int ALIGNMENT = 128>
  class coordinate_matrix;

  template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
  class ell_matrix;

  template<typename ScalarT, typename IndexT = unsigned int>
  class sliced_ell_matrix;

  template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
  class hyb_matrix;

  template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
  class circulant_matrix;

  template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
  class hankel_matrix;

  template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
  class toeplitz_matrix;

  template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
  class vandermonde_matrix;

  //
  // Proxies:
  //
  template<typename SizeType = vcl_size_t, typename DistanceType = std::ptrdiff_t>
  class basic_range;

  typedef basic_range<>  range;

  template<typename SizeType = vcl_size_t, typename DistanceType = std::ptrdiff_t>
  class basic_slice;

  typedef basic_slice<>  slice;

  template<typename VectorType>
  class vector_range;

  template<typename VectorType>
  class vector_slice;

  template<typename MatrixType>
  class matrix_range;

  template<typename MatrixType>
  class matrix_slice;


  template<typename T>
  struct is_cpu_scalar
  {
    enum { value = false };
  };

  template<typename T>
  struct is_scalar
  {
    enum { value = false };
  };

  template<typename T>
  struct is_flip_sign_scalar
  {
    enum { value = false };
  };

  template<typename T>
  struct is_any_scalar
  {
    enum { value = (is_scalar<T>::value || is_cpu_scalar<T>::value || is_flip_sign_scalar<T>::value )};
  };

  template<typename T>
  struct is_any_vector { enum { value = 0 }; };

  template<typename T>
  struct is_any_dense_matrix { enum { value = 0 }; };

  template<typename T>
  struct is_row_major
  {
    enum { value = false };
  };

  template<typename T>
  struct is_compressed_matrix
  {
    enum { value = false };
  };

  template<typename T>
  struct is_coordinate_matrix
  {
    enum { value = false };
  };

  template<typename T>
  struct is_ell_matrix
  {
    enum { value = false };
  };

  template<typename T>
  struct is_sliced_ell_matrix
  {
    enum { value = false };
  };


  template<typename T>
  struct is_hyb_matrix
  {
    enum { value = false };
  };

  template<typename T>
  struct is_any_sparse_matrix
  {
    enum { value = false };
  };


  template<typename T>
  struct is_circulant_matrix
  {
    enum { value = false };
  };

  template<typename T>
  struct is_hankel_matrix
  {
    enum { value = false };
  };

  template<typename T>
  struct is_toeplitz_matrix
  {
    enum { value = false };
  };

  template<typename T>
  struct is_vandermonde_matrix
  {
    enum { value = false };
  };

  template<typename T>
  struct is_any_dense_structured_matrix
  {
    enum { value = viennacl::is_circulant_matrix<T>::value || viennacl::is_hankel_matrix<T>::value || viennacl::is_toeplitz_matrix<T>::value || viennacl::is_vandermonde_matrix<T>::value };
  };




  class memory_exception : public std::exception
  {
  public:
    memory_exception() : message_() {}
    memory_exception(std::string message) : message_("ViennaCL: Internal memory error: " + message) {}

    virtual const char* what() const throw() { return message_.c_str(); }

    virtual ~memory_exception() throw() {}
  private:
    std::string message_;
  };

  class cuda_not_available_exception : public std::exception
  {
  public:
    cuda_not_available_exception() : message_("ViennaCL was compiled without CUDA support, but CUDA functionality required for this operation.") {}

    virtual const char* what() const throw() { return message_.c_str(); }

    virtual ~cuda_not_available_exception() throw() {}
  private:
    std::string message_;
  };

  class zero_on_diagonal_exception : public std::runtime_error
  {
  public:
    zero_on_diagonal_exception(std::string const & what_arg) : std::runtime_error(what_arg) {}
  };

  class unknown_norm_exception : public std::runtime_error
  {
  public:
    unknown_norm_exception(std::string const & what_arg) : std::runtime_error(what_arg) {}
  };



  namespace tools
  {
    //helper for matrix row/col iterators
    //must be specialized for every viennacl matrix type
    template<typename ROWCOL, typename MATRIXTYPE>
    struct MATRIX_ITERATOR_INCREMENTER
    {
      typedef typename MATRIXTYPE::ERROR_SPECIALIZATION_FOR_THIS_MATRIX_TYPE_MISSING          ErrorIndicator;

      static void apply(const MATRIXTYPE & /*mat*/, unsigned int & /*row*/, unsigned int & /*col*/) {}
    };
  }

  namespace linalg
  {
#if !defined(_MSC_VER) || defined(__CUDACC__)

    template<class SCALARTYPE, unsigned int ALIGNMENT>
    void convolve_i(viennacl::vector<SCALARTYPE, ALIGNMENT>& input1,
                    viennacl::vector<SCALARTYPE, ALIGNMENT>& input2,
                    viennacl::vector<SCALARTYPE, ALIGNMENT>& output);

    template<typename T>
    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);

    template<typename T>
    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);



    template<typename T>
    void inner_prod_impl(vector_base<T> const & vec1,
                         vector_base<T> const & vec2,
                         scalar<T> & result);

    template<typename LHS, typename RHS, typename OP, typename T>
    void inner_prod_impl(viennacl::vector_expression<LHS, RHS, OP> const & vec1,
                         vector_base<T> const & vec2,
                         scalar<T> & result);

    template<typename T, typename LHS, typename RHS, typename OP>
    void inner_prod_impl(vector_base<T> const & vec1,
                         viennacl::vector_expression<LHS, RHS, OP> const & vec2,
                         scalar<T> & result);

    template<typename LHS1, typename RHS1, typename OP1,
              typename LHS2, typename RHS2, typename OP2, typename T>
    void inner_prod_impl(viennacl::vector_expression<LHS1, RHS1, OP1> const & vec1,
                         viennacl::vector_expression<LHS2, RHS2, OP2> const & vec2,
                         scalar<T> & result);


    template<typename T>
    void inner_prod_cpu(vector_base<T> const & vec1,
                        vector_base<T> const & vec2,
                        T & result);

    template<typename LHS, typename RHS, typename OP, typename T>
    void inner_prod_cpu(viennacl::vector_expression<LHS, RHS, OP> const & vec1,
                        vector_base<T> const & vec2,
                        T & result);

    template<typename T, typename LHS, typename RHS, typename OP>
    void inner_prod_cpu(vector_base<T> const & vec1,
                        viennacl::vector_expression<LHS, RHS, OP> const & vec2,
                        T & result);

    template<typename LHS1, typename RHS1, typename OP1,
              typename LHS2, typename RHS2, typename OP2, typename S3>
    void inner_prod_cpu(viennacl::vector_expression<LHS1, RHS1, OP1> const & vec1,
                        viennacl::vector_expression<LHS2, RHS2, OP2> const & vec2,
                        S3 & result);



    //forward definition of norm_1_impl function
    template<typename T>
    void norm_1_impl(vector_base<T> const & vec, scalar<T> & result);

    template<typename LHS, typename RHS, typename OP, typename T>
    void norm_1_impl(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                     scalar<T> & result);


    template<typename T>
    void norm_1_cpu(vector_base<T> const & vec,
                    T & result);

    template<typename LHS, typename RHS, typename OP, typename S2>
    void norm_1_cpu(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                    S2 & result);

    //forward definition of norm_2_impl function
    template<typename T>
    void norm_2_impl(vector_base<T> const & vec, scalar<T> & result);

    template<typename LHS, typename RHS, typename OP, typename T>
    void norm_2_impl(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                     scalar<T> & result);

    template<typename T>
    void norm_2_cpu(vector_base<T> const & vec, T & result);

    template<typename LHS, typename RHS, typename OP, typename S2>
    void norm_2_cpu(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                    S2 & result);


    //forward definition of norm_inf_impl function
    template<typename T>
    void norm_inf_impl(vector_base<T> const & vec, scalar<T> & result);

    template<typename LHS, typename RHS, typename OP, typename T>
    void norm_inf_impl(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                      scalar<T> & result);


    template<typename T>
    void norm_inf_cpu(vector_base<T> const & vec, T & result);

    template<typename LHS, typename RHS, typename OP, typename S2>
    void norm_inf_cpu(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                      S2 & result);

    //forward definition of max()-related functions
    template<typename T>
    void max_impl(vector_base<T> const & vec, scalar<T> & result);

    template<typename LHS, typename RHS, typename OP, typename T>
    void max_impl(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                  scalar<T> & result);


    template<typename T>
    void max_cpu(vector_base<T> const & vec, T & result);

    template<typename LHS, typename RHS, typename OP, typename S2>
    void max_cpu(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                 S2 & result);

    //forward definition of min()-related functions
    template<typename T>
    void min_impl(vector_base<T> const & vec, scalar<T> & result);

    template<typename LHS, typename RHS, typename OP, typename T>
    void min_impl(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                  scalar<T> & result);


    template<typename T>
    void min_cpu(vector_base<T> const & vec, T & result);

    template<typename LHS, typename RHS, typename OP, typename S2>
    void min_cpu(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                 S2 & result);

    //forward definition of sum()-related functions
    template<typename T>
    void sum_impl(vector_base<T> const & vec, scalar<T> & result);

    template<typename LHS, typename RHS, typename OP, typename T>
    void sum_impl(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                  scalar<T> & result);


    template<typename T>
    void sum_cpu(vector_base<T> const & vec, T & result);

    template<typename LHS, typename RHS, typename OP, typename S2>
    void sum_cpu(viennacl::vector_expression<LHS, RHS, OP> const & vec,
                 S2 & result);


    // forward definition of frobenius norm:
    template<typename T>
    void norm_frobenius_impl(matrix_base<T> const & vec, scalar<T> & result);

    template<typename T>
    void norm_frobenius_cpu(matrix_base<T> const & vec, T & result);


    template<typename T>
    vcl_size_t index_norm_inf(vector_base<T> const & vec);

    template<typename LHS, typename RHS, typename OP>
    vcl_size_t index_norm_inf(viennacl::vector_expression<LHS, RHS, OP> const & vec);

    //forward definition of prod_impl functions

    template<typename NumericT>
    void prod_impl(const matrix_base<NumericT> & mat,
                   const vector_base<NumericT> & vec,
                         vector_base<NumericT> & result);

    template<typename NumericT>
    void prod_impl(const matrix_expression< const matrix_base<NumericT>, const matrix_base<NumericT>, op_trans> & mat_trans,
                   const vector_base<NumericT> & vec,
                         vector_base<NumericT> & result);

    template<typename SparseMatrixType, class SCALARTYPE, unsigned int ALIGNMENT>
    typename viennacl::enable_if< viennacl::is_any_sparse_matrix<SparseMatrixType>::value,
                                  vector_expression<const SparseMatrixType,
                                                    const vector<SCALARTYPE, ALIGNMENT>,
                                                    op_prod >
                                 >::type
    prod_impl(const SparseMatrixType & mat,
              const vector<SCALARTYPE, ALIGNMENT> & vec);

    // forward definition of summation routines for matrices:

    template<typename NumericT>
    void row_sum_impl(const matrix_base<NumericT> & A,
                            vector_base<NumericT> & result);

    template<typename NumericT>
    void column_sum_impl(const matrix_base<NumericT> & A,
                               vector_base<NumericT> & result);

#endif

    namespace detail
    {
      enum row_info_types
      {
        SPARSE_ROW_NORM_INF = 0,
        SPARSE_ROW_NORM_1,
        SPARSE_ROW_NORM_2,
        SPARSE_ROW_DIAGONAL
      };

    }


    struct lower_tag
    {
      static const char * name() { return "lower"; }
    };      //lower triangular matrix
    struct upper_tag
    {
      static const char * name() { return "upper"; }
    };      //upper triangular matrix
    struct unit_lower_tag
    {
      static const char * name() { return "unit_lower"; }
    }; //unit lower triangular matrix
    struct unit_upper_tag
    {
      static const char * name() { return "unit_upper"; }
    }; //unit upper triangular matrix

    //preconditioner tags
    class ilut_tag;

    class no_precond
    {
      public:
        template<typename VectorType>
        void apply(VectorType &) const {}
    };


  } //namespace linalg

  //
  // More namespace comments to follow:
  //

  namespace backend
  {
    namespace cpu_ram
    {
      namespace detail {}
    }

    namespace cuda
    {
      namespace detail {}
    }

    namespace detail {}

    namespace opencl
    {
      namespace detail {}
    }
  }


  namespace detail
  {
    namespace fft
    {
      namespace FFT_DATA_ORDER {}
    }
  }


  namespace device_specific
  {
    namespace autotune {}

    namespace detail {}

    namespace profiles {}

    namespace utils {}
  }

  namespace io
  {
    namespace detail {}

    namespace tag {}

    namespace val {}
  }

  namespace linalg
  {
    namespace cuda
    {
      namespace detail {}
    }

    namespace detail
    {
      namespace amg {}

      namespace spai {}
    }

    namespace host_based
    {
      namespace detail {}
    }

    namespace kernels {}

    namespace opencl
    {
      namespace detail {}

      namespace kernels
      {
        namespace detail {}
      }
    }
  }

  namespace ocl {}

  namespace result_of {}

  namespace tools
  {
    namespace detail {}
  }

  namespace traits {}

  namespace scheduler
  {
    namespace detail {}

    namespace result_of {}
  }

} //namespace viennacl

#endif