viennacl/linalg/norm_inf.hpp

Go to the documentation of this file.

#ifndef VIENNACL_LINALG_NORM_INF_HPP_
#define VIENNACL_LINALG_NORM_INF_HPP_

/* =========================================================================
   Copyright (c) 2010-2013, 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 PDF manual)

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

#include <cmath>
#include "viennacl/forwards.h"
#include "viennacl/tools/tools.hpp"
#include "viennacl/meta/enable_if.hpp"
#include "viennacl/meta/tag_of.hpp"

namespace viennacl
{
  //
  // generic norm_inf function
  //   uses tag dispatch to identify which algorithm
  //   should be called 
  //
  namespace linalg 
  {
    
    #ifdef VIENNACL_WITH_UBLAS
    // ----------------------------------------------------
    // UBLAS
    //
    template< typename VectorT >
    typename viennacl::enable_if< viennacl::is_ublas< typename viennacl::traits::tag_of< VectorT >::type >::value,
                                  typename VectorT::value_type      
                                >::type    
    norm_inf(VectorT const& v1)
    {
      return boost::numeric::ublas::norm_inf(v1);
    }
    #endif
    
    
    // ----------------------------------------------------
    // STL
    //
    template< typename T, typename A >
    T norm_inf(std::vector<T, A> const & v1)
    {
      //std::cout << "stl .. " << std::endl;
      T result = 0;
      for (typename std::vector<T, A>::size_type i=0; i<v1.size(); ++i)
      {
        if (std::fabs(v1[i]) > result)
          result = std::fabs(v1[i]);
      }
      
      return result;
    }
    
    // ----------------------------------------------------
    // VIENNACL
    //
    template< typename ScalarType, unsigned int alignment >
    viennacl::scalar_expression< const viennacl::vector<ScalarType, alignment>, 
                                 const viennacl::vector<ScalarType, alignment>,
                                 viennacl::op_norm_inf >
    norm_inf(viennacl::vector<ScalarType, alignment> const & v1)
    {
       //std::cout << "viennacl .. " << std::endl;
      return viennacl::scalar_expression< const viennacl::vector<ScalarType, alignment>, 
                                          const viennacl::vector<ScalarType, alignment>,
                                          viennacl::op_norm_inf >(v1, v1);
    }

    template< typename VectorType >
    viennacl::scalar_expression< const viennacl::vector_range<VectorType>, 
                                 const viennacl::vector_range<VectorType>,
                                 viennacl::op_norm_inf >
    norm_inf(viennacl::vector_range<VectorType> const & vector)
    {
      return viennacl::scalar_expression< const viennacl::vector_range<VectorType>, 
                                          const viennacl::vector_range<VectorType>,
                                          viennacl::op_norm_inf >(vector, vector);
    }

    template< typename VectorType >
    viennacl::scalar_expression< const viennacl::vector_slice<VectorType>, 
                                 const viennacl::vector_slice<VectorType>,
                                 viennacl::op_norm_inf >
    norm_inf(viennacl::vector_slice<VectorType> const & vector)
    {
      return viennacl::scalar_expression< const viennacl::vector_slice<VectorType>, 
                                          const viennacl::vector_slice<VectorType>,
                                          viennacl::op_norm_inf >(vector, vector);
    }

    // with vector expression:
    template <typename LHS, typename RHS, typename OP>
    viennacl::scalar_expression<const viennacl::vector_expression<const LHS, const RHS, OP>, 
                                const viennacl::vector_expression<const LHS, const RHS, OP>,
                                viennacl::op_norm_inf>
    norm_inf(viennacl::vector_expression<const LHS, const RHS, OP> const & vector)
    {
      return viennacl::scalar_expression< const viennacl::vector_expression<const LHS, const RHS, OP>, 
                                          const viennacl::vector_expression<const LHS, const RHS, OP>,
                                          viennacl::op_norm_inf >(vector, vector);
    }
    
    
  } // end namespace linalg
} // end namespace viennacl
#endif