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

/data/development/ViennaCL/ViennaCL-1.1.2/viennacl/tools/matrix_size_deducer.hpp

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 
00015 #ifndef _VIENNACL_TOOLS_MATRIX_SIZE_DEDUCER_HPP_
00016 #define _VIENNACL_TOOLS_MATRIX_SIZE_DEDUCER_HPP_
00017 
00022 #include <string>
00023 #include <fstream>
00024 #include <sstream>
00025 #include "viennacl/forwards.h"
00026 #include "viennacl/tools/adapter.hpp"
00027 
00028 #include <vector>
00029 #include <map>
00030 
00031 namespace viennacl
00032 {
00033   namespace tools
00034   {
00035 
00042     template <typename LHS, typename RHS, typename OP>
00043     struct MATRIX_SIZE_DEDUCER
00044     {
00045       //Standard case: size1 from lhs, size2 from rhs (fits most cases)
00046       static size_t size1(LHS & lhs, RHS & rhs) { return lhs.size1(); }
00047       static size_t size2(LHS & lhs, RHS & rhs) { return rhs.size2(); }
00048     };
00049     
00050     //special case: outer vector product:
00051     template <typename ScalarType, unsigned int A1, unsigned int A2>
00052     struct MATRIX_SIZE_DEDUCER<viennacl::vector<ScalarType, A1>,
00053                                viennacl::vector<ScalarType, A2>,
00054                                viennacl::op_prod>
00055     {
00056       static size_t size1(viennacl::vector<ScalarType, A1> & lhs,
00057                           viennacl::vector<ScalarType, A2> & rhs) { return lhs.size1(); }
00058 
00059       static size_t size2(viennacl::vector<ScalarType, A1> & lhs,
00060                           viennacl::vector<ScalarType, A2> & rhs) { return rhs.size2(); }
00061     };
00062 
00063     //special case: transposed matrix-Something product: Return the number of rows of the matrix
00064     /*template <typename MatrixType, typename ScalarType, unsigned int A>
00065     struct MATRIX_SIZE_DEDUCER<MatrixType, const viennacl::vector<ScalarType, A>, viennacl::op_prod>
00066     {
00067       static unsigned int size(MatrixType & lhs, const viennacl::vector<ScalarType, A> & rhs) { return lhs.size1(); }
00068     };*/
00069 
00070     template <typename ScalarType, typename F1, unsigned int A1, typename F2, unsigned int A2>
00071     struct MATRIX_SIZE_DEDUCER<const viennacl::matrix_expression<const viennacl::matrix<ScalarType, F1, A1>,
00072                                                                  const viennacl::matrix<ScalarType, F1, A1>, op_trans>,
00073                                const viennacl::matrix<ScalarType, F2, A2>,
00074                                viennacl::op_prod>
00075     {
00076       static size_t size1(viennacl::matrix_expression<const viennacl::matrix<ScalarType, F1, A1>,
00077                                                       const viennacl::matrix<ScalarType, F1, A1>,
00078                                                       op_trans> const & lhs,
00079                           viennacl::matrix<ScalarType, F2, A2> const & rhs) { return lhs.lhs().size2(); }
00080       static size_t size2(viennacl::matrix_expression<const viennacl::matrix<ScalarType, F1, A1>,
00081                                                       const viennacl::matrix<ScalarType, F1, A1>,
00082                                                       op_trans> const & lhs,
00083                           viennacl::matrix<ScalarType, F2, A2> const & rhs) { return rhs.size2(); }
00084     };
00085     
00086     template <typename ScalarType, typename F1, unsigned int A1, typename F2, unsigned int A2>
00087     struct MATRIX_SIZE_DEDUCER<const viennacl::matrix<ScalarType, F1, A1>,
00088                                const viennacl::matrix_expression<const viennacl::matrix<ScalarType, F2, A2>,
00089                                                                  const viennacl::matrix<ScalarType, F2, A2>, op_trans>,
00090                                viennacl::op_prod>
00091     {
00092       static size_t size1(viennacl::matrix<ScalarType, F1, A1> const & lhs,
00093                           viennacl::matrix_expression<const viennacl::matrix<ScalarType, F2, A2>,
00094                                                       const viennacl::matrix<ScalarType, F2, A2>,
00095                                                       op_trans> const & rhs) { return lhs.size1(); }
00096       static size_t size2(viennacl::matrix<ScalarType, F1, A1> const & lhs,
00097                           viennacl::matrix_expression<const viennacl::matrix<ScalarType, F2, A2>,
00098                                                       const viennacl::matrix<ScalarType, F2, A2>,
00099                                                       op_trans> const & rhs) { return rhs.lhs().size1(); }
00100     };
00101     
00102   }
00103 }
00104 
00105 #endif
00106 

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