MATHS/common.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: common.h,v 1.29.16.1 2007/03/25 21:23:45 oliver Exp $
//

#ifndef BALL_MATHS_COMMON_H
#define BALL_MATHS_COMMON_H

#ifndef BALL_CONFIG_CONFIG_H
# include <BALL/CONFIG/config.h>
#endif

#include <cmath>

#ifdef BALL_HAS_IEEEFP_H
# include <ieeefp.h>
#endif

#ifdef BALL_HAS_FLOAT_H
# include <float.h>
#endif

#ifndef BALL_COMMON_CONSTANTS_H
# include <BALL/COMMON/constants.h>
#endif

#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/COMMON/global.h>
#endif

#ifndef BALL_COMMON_MACROS_H
# include <BALL/COMMON/macros.h>
#endif

namespace BALL 
{
  
  namespace Maths 
  {


    template <typename T>
    inline 
    T abs(const T& t)
    {
      return BALL_ABS(t);
    }

    template <typename T>
    inline 
    T frac(const T& t)
    { 
      long tmp = (long)t;
      return (t - (T)tmp);
    }

#ifndef max 

    template <typename T>
    inline 
    T max(const T& a, const T& b)
    { 
      return BALL_MAX(a, b);
    }

    template <typename T>
    inline 
    T max(const T& a, const T& b, const T &ct)
    { 
      return BALL_MAX3(a, b, ct);
    }
#endif

#ifndef min

    template <typename T>
    inline 
    T min(const T& a, const T& b)
    { 
      return BALL_MIN(a, b);
    }

    template <typename T>
    inline 
    T min(const T& a, const T& b, const T &ct)
    { 
      return BALL_MIN3(a, b, ct);
    }
#endif

    template <typename T>
    inline 
    T round(const T& t)
    { 
      return (T)(t > 0 ? long(t + 0.5) : long(t - 0.5)); 
    }

    template <typename T>
    inline 
    T sgn(const T& t)
    {
      return BALL_SGN(t);
    }

    template <typename T>
    inline 
    bool isFinite(const T& t)
    {
#ifdef BALL_COMPILER_MSVC
      return ::_finite(t);
#else
      return finite(t);
#endif
    }

    template <typename T>
    inline 
    bool isNan(const T& t)
    {
      #ifdef BALL_COMPILER_MSVC
        return (_isnan(t) != 0);
      #elif  defined(BALL_OS_DARWIN)
        return ( __inline_isnand(t) != 0);
      #else
        return (isnan(t) != 0);
      #endif
    }

    template <typename T>
    inline 
    bool isInfinite(const T& t)
    {
      return (!Maths::isFinite(t) && !Maths::isNan(t));
    }

    template <typename T>
    inline 
    bool isZero(const T& t)
    {
      return (abs(t) < Constants::EPSILON);
    }

    template <typename T>
    inline 
    bool isNotZero(const T& t)
    {
      return (abs(t) >= Constants::EPSILON);
    }

    template <typename T1, typename T2>
    inline 
    bool isEqual(const T1& a, const T2& b)
    {
      return (abs(a - b) < Constants::EPSILON);
    }

    template <typename T1, typename T2>
    inline 
    bool isNotEqual(const T1& a, const T2& b)
    {
      return (abs(a - b) >= Constants::EPSILON);
    }

    template <typename T1, typename T2>
    inline 
    bool isLess(const T1& a, const T2& b)

    {
      return ((a - b) <= -Constants::EPSILON);
    }

    template <typename T1, typename T2>
    inline 
    bool isLessOrEqual(const T1& a, const T2& b)
    {
      return ((a - b) < Constants::EPSILON);
    }

    template <typename T1, typename T2>
    inline 
    bool isGreaterOrEqual(const T1& a, const T2& b)
    {
      return ((a - b) > -Constants::EPSILON);
    }

    template <typename T1, typename T2>
    inline 
    bool isGreater(const T1& a, const T2& b)
    {
      return (a - b >= Constants::EPSILON);
    }

    template <typename T>
    inline 
    long floor(const T& t)
    {
      return (long)(Maths::isGreater(t, 0) ? t: (Maths::isEqual(t, (T)(long)t) ? t : t - 1));
    }

    template <typename T>
    inline 
    long ceiling(const T& t)
    {
      return (long)(Maths::isLess(t, 0) ? t: (Maths::isEqual(t, (T)(long)t) ? t : t + 1));
    }

    template <typename T1, typename T2>
    inline 
    Index compare(const T1& a, const T2& b)
    {
      return (Maths::isLess(a, b) ? -1 : Maths::isEqual(a, b) ? 0 : 1);
    }

    template <typename T>
    inline 
    bool isNear(const T& a, const T& b, const T& max_diff)
    {
      return (abs((double)a - (double)b) < abs((double)max_diff));
    }


    inline double rint(double x)
    {
      if (x < 0.0) return (double)(int)(x - 0.5);
      else return (double)(int)(x + 0.5);
    }

    
  } // namespace Maths
} // namespace BALL

#endif // BALL_MATHS_COMMON_H