• Main Page
  • Namespaces
  • Data Structures
  • Files
  • File List
  • Globals

/data/development/ViennaCL/ViennaCL-1.1.2/viennacl/forwards.h

Go to the documentation of this file.
00001 /* =======================================================================
00002    Copyright (c) 2010, Institute for Microelectronics, TU Vienna.
00003    http://www.iue.tuwien.ac.at
00004                              -----------------
00005                      ViennaCL - The Vienna Computing Library
00006                              -----------------
00007                             
00008    authors:    Karl Rupp                          rupp@iue.tuwien.ac.at
00009                Florian Rudolf                     flo.rudy+viennacl@gmail.com
00010                Josef Weinbub                      weinbub@iue.tuwien.ac.at
00011 
00012    license:    MIT (X11), see file LICENSE in the ViennaCL base directory
00013 ======================================================================= */
00014 
00028 #ifndef VIENNACL_FORWARDS_H
00029 #define VIENNACL_FORWARDS_H
00030 
00031 //#include <stddef.h>
00032 #include <cstddef>
00033 #include "viennacl/ocl/forwards.h"
00034 
00035 namespace viennacl
00036 {
00037   typedef std::size_t                                       vcl_size_t;
00038   typedef std::ptrdiff_t                                    vcl_ptrdiff_t;
00039  
00040   
00042   struct op_add;
00044   struct op_sub;
00046   struct op_div;
00047   
00049   struct op_inner_prod;
00050 
00052   struct op_norm_1;
00053 
00055   struct op_norm_2;
00056 
00058   struct op_norm_inf;
00059 
00061   struct op_prod;
00062   
00064   struct op_trans;
00065   
00066 
00067   //forward declaration of basic types:
00068   template<class TYPE>
00069   class scalar;
00070 
00071   template <typename LHS, typename RHS, typename OP>
00072   class scalar_expression;
00073 
00074   template <typename SCALARTYPE>
00075   class entry_proxy;
00076   
00077   template <typename LHS, typename RHS, typename OP>
00078   class vector_expression;
00079 
00080   template<class SCALARTYPE, unsigned int ALIGNMENT>
00081   class vector_iterator;
00082 
00083   template<class SCALARTYPE, unsigned int ALIGNMENT>
00084   class const_vector_iterator;
00085   
00086   template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
00087   class vector;
00088   
00089   //the following forwards are needed for GMRES
00090   template <typename SCALARTYPE, unsigned int ALIGNMENT, typename CPU_ITERATOR>
00091   void copy(CPU_ITERATOR const & cpu_begin,
00092             CPU_ITERATOR const & cpu_end,
00093             vector_iterator<SCALARTYPE, ALIGNMENT> gpu_begin);
00094 
00095   template <typename SCALARTYPE, unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>
00096   void copy(const_vector_iterator<SCALARTYPE, ALIGNMENT_SRC> const & gpu_src_begin,
00097             const_vector_iterator<SCALARTYPE, ALIGNMENT_SRC> const & gpu_src_end,
00098             vector_iterator<SCALARTYPE, ALIGNMENT_DEST> gpu_dest_begin);
00099   
00100   template <typename SCALARTYPE, unsigned int ALIGNMENT_SRC, unsigned int ALIGNMENT_DEST>
00101   void copy(const_vector_iterator<SCALARTYPE, ALIGNMENT_SRC> const & gpu_src_begin,
00102             const_vector_iterator<SCALARTYPE, ALIGNMENT_SRC> const & gpu_src_end,
00103             const_vector_iterator<SCALARTYPE, ALIGNMENT_DEST> gpu_dest_begin);
00104   
00105   
00106   struct row_major;    
00107   struct column_major;    
00108   
00109   struct row_iteration;
00110   struct col_iteration;
00111 
00112   template <typename LHS, typename RHS, typename OP>
00113   class matrix_expression;
00114 
00115   template <class SCALARTYPE, typename F = row_major, unsigned int ALIGNMENT = 1>
00116   class matrix;
00117 
00118   template<class SCALARTYPE, unsigned int ALIGNMENT = 1>
00119   class compressed_matrix;
00120   
00121   template<class SCALARTYPE, unsigned int ALIGNMENT = 128>
00122   class coordinate_matrix;    
00123   
00124   namespace tools
00125   {
00126     //helper for matrix row/col iterators 
00127     //must be specialized for every viennacl matrix type
00128     template <typename ROWCOL, typename MATRIXTYPE>
00129     struct MATRIX_ITERATOR_INCREMENTER
00130     {
00131       static void apply(const MATRIXTYPE & mat, unsigned int & row, unsigned int & col)
00132       {
00133           typedef typename MATRIXTYPE::ERROR_SPECIALIZATION_FOR_THIS_MATRIX_TYPE_MISSING          ErrorIndicator;
00134       }
00135     };
00136   }
00137     
00138   namespace linalg
00139   {
00140     //forward definition of norm_1_impl function
00141     template<class SCALARTYPE, unsigned int ALIGNMENT>
00142     void norm_1_impl(const viennacl::vector<SCALARTYPE, ALIGNMENT> & vcl_vec,
00143                      scalar<SCALARTYPE> & result);
00144 
00145     //forward definition of norm_2_impl function
00146     template<class SCALARTYPE, unsigned int ALIGNMENT>
00147     void norm_2_impl(const viennacl::vector<SCALARTYPE, ALIGNMENT> & vcl_vec,
00148                      scalar<SCALARTYPE> & result);
00149 
00150     //forward definition of norm_inf_impl function
00151     template<class SCALARTYPE, unsigned int ALIGNMENT>
00152     void norm_inf_impl(const viennacl::vector<SCALARTYPE, ALIGNMENT> & vcl_vec,
00153                      scalar<SCALARTYPE> & result);
00154     
00155     //forward definition of prod_impl functions
00156     template<class SCALARTYPE, typename F, unsigned int ALIGNMENT, unsigned int VECTOR_ALIGNMENT>
00157     viennacl::vector_expression<const viennacl::matrix<SCALARTYPE, F, ALIGNMENT>,
00158                                 const viennacl::vector<SCALARTYPE, VECTOR_ALIGNMENT>, 
00159                                 op_prod > prod_impl(const viennacl::matrix<SCALARTYPE, F, ALIGNMENT> &, 
00160                                                     const viennacl::vector<SCALARTYPE, VECTOR_ALIGNMENT> &);
00161 
00162     template<class SCALARTYPE, unsigned int ALIGNMENT, unsigned int VECTOR_ALIGNMENT>
00163     viennacl::vector_expression<const viennacl::compressed_matrix<SCALARTYPE, ALIGNMENT>,
00164                                 const viennacl::vector<SCALARTYPE, VECTOR_ALIGNMENT>, 
00165                                 op_prod > prod_impl(const viennacl::compressed_matrix<SCALARTYPE, ALIGNMENT> & , 
00166                                                     const viennacl::vector<SCALARTYPE, VECTOR_ALIGNMENT> &);
00167 
00168     template<class SCALARTYPE, unsigned int ALIGNMENT, unsigned int VECTOR_ALIGNMENT>
00169     viennacl::vector_expression<const viennacl::coordinate_matrix<SCALARTYPE, ALIGNMENT>,
00170                                 const viennacl::vector<SCALARTYPE, VECTOR_ALIGNMENT>, 
00171                                 op_prod > prod_impl(const viennacl::coordinate_matrix<SCALARTYPE, ALIGNMENT> & , 
00172                                                     const viennacl::vector<SCALARTYPE, VECTOR_ALIGNMENT> &);
00173 
00174                                                     
00175     //forward definition of inner_prod_impl function
00176     template<class SCALARTYPE, unsigned int ALIGNMENT1, unsigned int ALIGNMENT2>
00177     viennacl::scalar_expression< const viennacl::vector<SCALARTYPE, ALIGNMENT1>, 
00178                                  const viennacl::vector<SCALARTYPE, ALIGNMENT2>,
00179                                  viennacl::op_inner_prod >
00180     inner_prod_impl(const viennacl::vector<SCALARTYPE, ALIGNMENT1> &,
00181                     const viennacl::vector<SCALARTYPE, ALIGNMENT2> &);
00182                     
00183     template<class SCALARTYPE, unsigned int ALIGNMENT>
00184     void inner_prod_impl(const viennacl::vector<SCALARTYPE, ALIGNMENT> & vec1,
00185                          const viennacl::vector<SCALARTYPE, ALIGNMENT> & vec2,
00186                          scalar<SCALARTYPE> & result);
00187                     
00188       
00190     struct lower_tag 
00191     {
00192       static const char * const name() { return "lower"; }
00193     };      //lower triangular matrix
00195     struct upper_tag 
00196     {
00197       static const char * const name() { return "upper"; }
00198     };      //upper triangular matrix
00200     struct unit_lower_tag
00201     {
00202       static const char * const name() { return "unit_lower"; }
00203     }; //unit lower triangular matrix
00205     struct unit_upper_tag
00206     {
00207       static const char * const name() { return "unit_upper"; }
00208     }; //unit upper triangular matrix
00209     
00210     //preconditioner tags
00211     class ilut_tag;
00212     
00214     class no_precond
00215     {
00216       public:
00217         template <typename VectorType>
00218         void apply(VectorType & vec) const {}
00219     };
00220     
00221     
00222   } //namespace linalg
00223 } //namespace viennacl
00224 
00225 #endif
00226 

Generated on Sat May 21 2011 20:36:50 for ViennaCL - The Vienna Computing Library by  doxygen 1.7.1