/build/buildd/viennacl-1.1.2/viennacl/linalg/tag_of.hpp

Go to the documentation of this file.

/* =======================================================================
   Copyright (c) 2010, Institute for Microelectronics, TU Vienna.
   http://www.iue.tuwien.ac.at
                             -----------------
                     ViennaCL - The Vienna Computing Library
                             -----------------
                            
   authors:    Karl Rupp                          rupp@iue.tuwien.ac.at
               Florian Rudolf                     flo.rudy+viennacl@gmail.com
               Josef Weinbub                      weinbub@iue.tuwien.ac.at

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


#ifndef _VIENNACL_TAGOF_HPP_
#define _VIENNACL_TAGOF_HPP_

#ifdef VIENNACL_HAVE_UBLAS  
#include <boost/numeric/ublas/matrix_sparse.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/vector.hpp>
#endif

#ifdef VIENNACL_HAVE_EIGEN  
#include <Eigen/Core>
#include <Eigen/Sparse>
#endif

#ifdef VIENNACL_HAVE_MTL4
#include <boost/numeric/mtl/mtl.hpp>
#endif

namespace viennacl
{

  // ----------------------------------------------------
  // TAGS
  //
  struct tag_none     {};
  struct tag_mtl4     {};
  struct tag_eigen    {};
  struct tag_ublas    {};
  struct tag_stl      {};
  struct tag_viennacl {};

  namespace traits
  {
    // ----------------------------------------------------
    // GENERIC BASE
    //
    template< typename T, typename Active = void >
    struct tag_of;
   
    template < typename Sequence, typename Active >
    struct tag_of
    {
      typedef viennacl::tag_none  type;
    };
    
    #ifdef VIENNACL_HAVE_MTL4
    // ----------------------------------------------------
    // MTL4
    //
    template <typename ScalarType>
    struct tag_of< mtl::dense_vector<ScalarType> >
    {
      typedef viennacl::tag_mtl4  type;
    };

    template <typename ScalarType>
    struct tag_of< mtl::compressed2D<ScalarType> >
    {
      typedef viennacl::tag_mtl4  type;
    };

    template <typename ScalarType, typename T>
    struct tag_of< mtl::dense2D<ScalarType, T> >
    {
      typedef viennacl::tag_mtl4  type;
    };
    #endif
    
    
    #ifdef VIENNACL_HAVE_EIGEN
    // ----------------------------------------------------
    // Eigen
    //
    template <>
    struct tag_of< Eigen::VectorXf >
    {
      typedef viennacl::tag_eigen  type;
    };

    template <>
    struct tag_of< Eigen::VectorXd >
    {
      typedef viennacl::tag_eigen  type;
    };

    template <>
    struct tag_of< Eigen::MatrixXf >
    {
      typedef viennacl::tag_eigen  type;
    };

    template <>
    struct tag_of< Eigen::MatrixXd >
    {
      typedef viennacl::tag_eigen  type;
    };

    template <typename ScalarType, int option>
    struct tag_of< Eigen::SparseMatrix<ScalarType, option> >
    {
      typedef viennacl::tag_eigen  type;
    };
    
    #endif
    
    #ifdef VIENNACL_HAVE_UBLAS
    // ----------------------------------------------------
    // UBLAS
    //
    template< typename T >
    struct tag_of< boost::numeric::ublas::vector<T> >
    {
      typedef viennacl::tag_ublas  type;
    };

    template< typename T >
    struct tag_of< boost::numeric::ublas::matrix<T> >
    {
      typedef viennacl::tag_ublas  type;
    };

    template< typename T1, typename T2 >
    struct tag_of< boost::numeric::ublas::matrix_unary2<T1,T2> >
    {
      typedef viennacl::tag_ublas  type;
    };

    template< typename T1, typename T2 >
    struct tag_of< boost::numeric::ublas::compressed_matrix<T1,T2> >
    {
      typedef viennacl::tag_ublas  type;
    };
    
    #endif

    // ----------------------------------------------------
    // STL types
    //
    
    //vector
    template< typename T, typename A >
    struct tag_of< std::vector<T, A> >
    {
      typedef viennacl::tag_stl  type;
    };

    //dense matrix
    template< typename T, typename A >
    struct tag_of< std::vector<std::vector<T, A>, A> >
    {
      typedef viennacl::tag_stl  type;
    };

    //sparse matrix (vector of maps)
    template< typename KEY, typename DATA, typename COMPARE, typename AMAP, typename AVEC>
    struct tag_of< std::vector<std::map<KEY, DATA, COMPARE, AMAP>, AVEC> >
    {
      typedef viennacl::tag_stl  type;
    };
    
    
    // ----------------------------------------------------
    // VIENNACL
    //
    template< typename T, unsigned int alignment >
    struct tag_of< viennacl::vector<T, alignment> >
    {
      typedef viennacl::tag_viennacl  type;
    };

    template< typename T, typename F, unsigned int alignment >
    struct tag_of< viennacl::matrix<T, F, alignment> >
    {
      typedef viennacl::tag_viennacl  type;
    };

    template< typename T1, typename T2, typename OP >
    struct tag_of< viennacl::matrix_expression<T1,T2,OP> >
    {
      typedef viennacl::tag_viennacl  type;
    };

    template< typename T, unsigned int I>
    struct tag_of< viennacl::compressed_matrix<T,I> >
    {
      typedef viennacl::tag_viennacl  type;
    };

    template< typename T, unsigned int I>
    struct tag_of< viennacl::coordinate_matrix<T,I> >
    {
      typedef viennacl::tag_viennacl  type;
    };
    // ----------------------------------------------------
  } // end namespace traits


  template <typename Tag>
  struct is_mtl4
  {
     enum { value = false };  
  };

  template <>
  struct is_mtl4< viennacl::tag_mtl4 >
  {
     enum { value = true };  
  };

  template <typename Tag>
  struct is_eigen
  {
     enum { value = false };  
  };

  template <>
  struct is_eigen< viennacl::tag_eigen >
  {
     enum { value = true };  
  };


  template <typename Tag>
  struct is_ublas
  {
     enum { value = false };  
  };

  template <>
  struct is_ublas< viennacl::tag_ublas >
  {
     enum { value = true };  
  };

  template <typename Tag>
  struct is_stl
  {
     enum { value = false };  
  };

  template <>
  struct is_stl< viennacl::tag_stl >
  {
     enum { value = true };  
  };

  
  template <typename Tag>
  struct is_viennacl
  {
     enum { value = false };  
  };

  template <>
  struct is_viennacl< viennacl::tag_viennacl >
  {
     enum { value = true };  
  };

} // end namespace viennacl

#endif