#ifndef glas_abs_hpp
#define glas_abs_hpp

#include <boost/static_assert.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_float.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/assert.hpp>
#ifdef GLAS_COMPLEX
#  include <complex>
#endif
#include <cmath>

namespace glas {

template <class T>
struct abs_functor {
  typedef T                               argument_type ;
  typedef T                               result_type ;
  //BOOST_MPL_ASSERT( (boost::mpl::or_< boost::is_integral<T>,boost::is_float<T> >) ) ;

  inline result_type operator() ( argument_type const& v ) const {
    return std::abs( v ) ;
  }
};

#ifdef GLAS_COMPLEX
template <class T>
struct abs_functor< std::complex<T> > {
  typedef std::complex<T> argument_type ;
  typedef T               result_type ;

  inline result_type operator() ( argument_type const& v ) const {
    return std::abs( v ) ;
  }
};
#endif // GLAS_COMPLEX

template <class T>
struct abs_functor<T&>
  : abs_functor< T >
{} ;

template <class T>
inline typename abs_functor<T>::result_type
abs( T const& v ) {
  return abs_functor<T>() ( v ) ;
}


/// square_abs()
template <class T>
struct square_abs_functor {
  typedef T                                                argument_type ;
  typedef typename abs_functor<argument_type>::result_type result_type ;
  //BOOST_STATIC_ASSERT( (boost::is_integral<T>::value || boost::is_float<T>::value) ) ;

  inline result_type operator() ( argument_type const& t ) const {
    return t * t ;
  }
};

#ifdef GLAS_COMPLEX
template <class T>
struct square_abs_functor< std::complex<T> > {
  typedef std::complex<T>                                  argument_type ;
  typedef typename abs_functor<argument_type>::result_type result_type ;

  inline result_type operator() ( argument_type const& t ) const {
    return t.real() * t.real() + t.imag() * t.imag() ;
  }
};
#endif // GLAS_COMPLEX

template <class T>
struct square_abs_functor<T&>
  : square_abs_functor<T>
{} ;

template <class T>
inline typename square_abs_functor<T>::result_type
square_abs( T const& t ) {
  return square_abs_functor<T>() ( t ) ;
}


}

#endif