In This Package:

LHCbMath.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
#ifndef LHCBMATH_LHCBMATH_H 
#define LHCBMATH_LHCBMATH_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL 
// ============================================================================
#include <cmath>
#include <algorithm>
#include <functional>
// ============================================================================
// Boost 
// ============================================================================
#include "boost/call_traits.hpp"
#include "boost/integer_traits.hpp"
#include "boost/static_assert.hpp"
// ============================================================================
namespace LHCb 
{
  // ==========================================================================
  namespace Math 
  {
    static const double hiTolerance    = 1e-40;
    static const double lowTolerance   = 1e-20;
    static const double looseTolerance = 1e-5;
    static const double     sqrt_12 = 3.4641016151377546; // sqrt(12.)
    static const double inv_sqrt_12 = 0.2886751345948129; // 1./sqrt(12.)
    // ========================================================================
    template <class TYPE>
    struct abs_less : std::binary_function<TYPE,TYPE,TYPE>
    {
      inline TYPE operator() 
        ( typename boost::call_traits<const TYPE>::param_type v1 ,
          typename boost::call_traits<const TYPE>::param_type v2 ) const 
      {
        return m_eval ( std::fabs( v1 ) , std::fabs( v2 ) ) ; 
      }
      std::less<TYPE> m_eval ;
    } ;
    // ========================================================================
    template <class TYPE>
    struct abs_greater : std::binary_function<TYPE,TYPE,TYPE>
    {
      inline TYPE operator() 
      ( typename boost::call_traits<const TYPE>::param_type v1 ,
        typename boost::call_traits<const TYPE>::param_type v2 ) const 
      {
        return m_eval ( std::fabs( v1 ) , std::fabs( v2 ) ) ; 
      }
      std::greater<TYPE> m_eval ;
    } ;
    // ========================================================================
    template <class TYPE> 
    inline TYPE absMin ( TYPE v1 , TYPE v2 ) 
    { return std::min ( std::fabs ( v1 ) , std::fabs ( v2 ) ) ; }
    // ========================================================================
    template <class TYPE> 
    inline TYPE absMax ( TYPE v1 , TYPE v2 ) 
    { return std::max ( std::fabs ( v1 ) , std::fabs ( v2 ) ) ; }

    // ========================================================================
    bool equal_to_double
    ( const double value1           ,
      const double value2           ,
      const double epsilon = 1.0e-6 ) ;
    // ========================================================================
    template <class TYPE>
    struct Equal_To : public std::binary_function<TYPE,TYPE,bool>
    {
      typedef typename boost::call_traits<const TYPE>::param_type T ;
      Equal_To ( T /* v */ ) {}
      inline bool operator() ( T v1 , T v2 ) const
      {
        std::equal_to<TYPE> cmp ;
        return cmp ( v1 , v2 ) ;
      }
    } ;
    // ========================================================================
    template <class TYPE>
    struct Equal_To<const TYPE>: public Equal_To<TYPE>{} ;
    // ========================================================================
    template <class TYPE>
    struct Equal_To<TYPE&>: public Equal_To<TYPE>{} ;
    // ========================================================================
    template <>
    struct Equal_To<double>
    {
      Equal_To ( const double eps = 1.0e-6 ) : m_eps ( eps ) {}
      inline bool operator() ( const double v1 , const double v2 ) const
      {
        return equal_to_double ( v1 , v2 , m_eps ) ;
      }
    private :
      double m_eps ;  // the precision 
    };
    // ========================================================================
    template <>
    struct Equal_To<long double>
    {
      Equal_To ( const long double eps = 1.0e-6 ) : m_eps ( eps ) {}
      inline bool operator() ( const long double v1 ,
                               const long double v2 ) const
      {
        return equal_to_double
          ( static_cast<double> ( v1    ) ,
            static_cast<double> ( v2    ) ,
            static_cast<double> ( m_eps ) ) ;
      }
    private :
      long double m_eps ; // the precision 
    };
    // ========================================================================
    template <>
    struct Equal_To<float>
    {
      Equal_To ( const float eps = 1.0e-6 ) : m_eps ( eps ) {}
      inline bool operator() ( const float v1 , const float v2 ) const
      {
        return equal_to_double ( v1 , v2 , m_eps ) ;
      }
    private :
      float m_eps ; // the precision 
    } ;
    // ========================================================================
    inline int round ( const double x )  {
      int i;
      LHCb::Math::Equal_To<double> equal_to(lowTolerance);
      if (x >= 0.0) {
        i = int(x + 0.5);
        if (equal_to(x + 0.5, double(i)) && i & 1) --i;
      }
      else {
        i = int(x - 0.5);
        if (equal_to(x - 0.5 , double(i)) && i & 1) ++i;
        
      }
      return i;
    }
    // ======================================================================== 
    inline int round ( const float x )  
    {
      return LHCb::Math::round ( double ( x ) ) ;
    }
    // ========================================================================
    inline bool equal_to_int 
    ( const double val          , 
      const int    ref          , 
      const double eps1 = 1.e-6 , 
      const double eps2 = 0.5e-3 / boost::integer_traits<int>::const_max )
    {
      BOOST_STATIC_ASSERT(boost::integer_traits<int>::is_specialized ) ;
      // 1) try the straightforward comparison 
      if ( val == ref                 ) { return true ; } // RETURN 
      // 2) check the limits 
      if ( val > boost::integer_traits<int>::const_max || 
           val < boost::integer_traits<int>::const_min ) { return false ; }
      // 3) compare the doubles 
      if ( std::fabs ( val - ref ) <= eps1 ) { return true  ; }
      // 3') compare the doubles  
      LHCb::Math::Equal_To<double> cmp ( eps2 ) ;
      return cmp ( val , ref ) ;
    }
    // ========================================================================
    inline bool equal_to_int 
    ( const int    ref          , 
      const double val          , 
      const double eps1 = 1.e-6 , 
      const double eps2 = 0.5e-3 / boost::integer_traits<int>::const_max ) 
    { 
      BOOST_STATIC_ASSERT(boost::integer_traits<int>::is_specialized ) ;
      return equal_to_int ( val , ref , eps1 , eps2 ) ; 
    }
    // ========================================================================
    inline bool equal_to_uint 
    ( const double       val         , 
      const unsigned int ref         , 
      const double eps1 = 1.e-6      , 
      const double eps2 = 1.e-3 / boost::integer_traits<unsigned int>::const_max )
    {
      BOOST_STATIC_ASSERT(boost::integer_traits<unsigned int>::is_specialized ) ;
      // 1) straightforward comparison 
      if ( val == ref ) { return true ; }                             // RETURN 
      // check the limits 
      if ( val > boost::integer_traits<unsigned int>::const_max || 
           val < boost::integer_traits<unsigned int>::const_min ) { return false ; }
      // 3) compare the doubles 
      if ( std::fabs ( val - ref ) <= eps1 ) { return true  ; }
      // 3') compare the doubles  
      LHCb::Math::Equal_To<double> cmp ( eps2 ) ;
      return cmp ( val , ref ) ;
    }
    // ========================================================================
    inline bool equal_to_uint 
    ( const unsigned int ref          , 
      const double       val          ,
      const double       eps1 = 1.e-6 , 
      const double       eps2 = 1.e-3 / boost::integer_traits<unsigned int>::const_max )
    { return equal_to_uint ( val , ref , eps1 , eps2 ) ; }
    // ========================================================================
  } // end of namespace LHcb::Math 
  // ==========================================================================
} // end of namespace LHCb 
// ============================================================================
// The END 
// ============================================================================
#endif // LHCBMATH_LHCBMATH_H
// ============================================================================

---