00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00028 #ifndef VIENNACL_FORWARDS_H
00029 #define VIENNACL_FORWARDS_H
00030
00031
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
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
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
00127
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
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
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
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
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
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 };
00195 struct upper_tag
00196 {
00197 static const char * const name() { return "upper"; }
00198 };
00200 struct unit_lower_tag
00201 {
00202 static const char * const name() { return "unit_lower"; }
00203 };
00205 struct unit_upper_tag
00206 {
00207 static const char * const name() { return "unit_upper"; }
00208 };
00209
00210
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 }
00223 }
00224
00225 #endif
00226