Public API Reference

csgeom/math.h

Go to the documentation of this file.

/*
  Copyright (C) 2005 by Marten Svanfeldt
  
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Library General Public License for more details.

  You should have received a copy of the GNU Library General Public
  License along with this library; if not, write to the Free
  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_MATH_H__
#define __CS_MATH_H__

#include "csutil/algorithms.h"

template<class T>
const T& csMax (const T& a, const T& b)
{
  if (b < a) return a;
  return b;
}

template<class T>
const T& csMin (const T& a, const T& b)
{
  if (a < b) return a;
  return b;
}

template<class T>
void csSort (T& a, T& b)
{
  if (b < a)
    CS::Swap (a, b);
}

template<class T, class U>
void csSort (T& a, T& b, U& x, U& y)
{
  if (b < a)
  {
    CS::Swap (a, b);
    CS::Swap (x, y);
  }
}


template<class T>
T csClamp (const T& a, T max, T min)
{
  return csMin (csMax (a, min), max);
}

template<class T>
T csSmoothStep (const T& a, T max, T min)
{
  T tmp, tmp2;
  if (a <= min)
    tmp = 0.0f;
  else if (a >= max)
    tmp = 1.0f;
  else
  {
    tmp2 = (a - min) / (max-min);
    tmp = tmp2*tmp2 * (3.0 - 2.0*tmp2);
  }
  return tmp;
}

template<class T, class Tfactor>
T csLerp (const T& a, const T& b, const Tfactor& f)
{
  return (a + (b - a) * f);
}

template<class T>
T csSquare (const T& x)
{
  return x * x;
}

namespace CS
{
  /* IsNaN() is implemented by looking at the binary values directly
     as using built-in functions turned out to be unreliable.
     (Specifically, gcc's built-in isnan() always returns false if
     -ffast-math is enabled.) */
  CS_FORCEINLINE bool IsNaN (float f)
  {
  #ifdef CS_IEEE_DOUBLE_FORMAT
    const uint32 exponentMask = 0x7f800000;
    const uint32 mantissaMask = 0x007fffff;
    union
    {
      float f;
      uint32 ui32;
    } u;
    u.f = f;
    return ((u.ui32 & exponentMask) == exponentMask)
        && ((u.ui32 & mantissaMask) != 0);
  #else
    #error Do not know how to test for NaN
  #endif
  }
  // External definition; used below as a workaround for __STRICT_ANSI__
  CS_CRYSTALSPACE_EXPORT bool IsNaN_ext (double d);
  CS_FORCEINLINE bool IsNaN (double d)
  {
  #ifdef __STRICT_ANSI__
    return IsNaN_ext (d);
  #else
  #ifdef CS_IEEE_DOUBLE_FORMAT
    const uint64 exponentMask = CONST_UINT64(0x7ff0000000000000);
    const uint64 mantissaMask = CONST_UINT64(0x000fffffffffffff);
    union
    {
      double d;
      uint64 ui64;
    } u;
    u.d = d;
    return ((u.ui64 & exponentMask) == exponentMask)
        && ((u.ui64 & mantissaMask) != 0);
  #else
    #error Do not know how to test for NaN
  #endif
  #endif
  }
  
  CS_FORCEINLINE bool IsFinite (float f)
  {
  #ifdef CS_IEEE_DOUBLE_FORMAT
    const uint32 exponentMask = 0x7f800000;
    union
    {
      float f;
      uint32 ui32;
    } u;
    u.f = f;
    return ((u.ui32 & exponentMask) != exponentMask);
  #else
    #error Do not know how to test for NaN
  #endif
  }
  // External definition; used below as a workaround for __STRICT_ANSI__
  CS_CRYSTALSPACE_EXPORT bool IsFinite_ext (double d);
  CS_FORCEINLINE bool IsFinite (double d)
  {
  #ifdef __STRICT_ANSI__
    return IsFinite_ext (d);
  #else
  #ifdef CS_IEEE_DOUBLE_FORMAT
    const uint64 exponentMask = CONST_UINT64(0x7ff0000000000000);
    union
    {
      double d;
      uint64 ui64;
    } u;
    u.d = d;
    return ((u.ui64 & exponentMask) != exponentMask);
  #else
    #error Do not know how to test for NaN
  #endif
  #endif
  }
  
  CS_FORCEINLINE float Infinity()
  {
  #ifdef CS_IEEE_DOUBLE_FORMAT
    union
    {
      uint32 ui32;
      float f;
    } u;
    u.ui32 = 0x7f800000;
    return u.f;
  #else
    return std::numeric_limits<float>::infinity();
  #endif
  }
} // namespace CS


CS_DEPRECATED_METHOD_MSG("Use CS::IsFinite(x) instead")
CS_FORCEINLINE bool csFinite (float f)
{
  return CS::IsFinite (f);
}
CS_DEPRECATED_METHOD_MSG("Use CS::IsFinite(x) instead")
CS_FORCEINLINE bool csFinite (double d)
{
  return CS::IsFinite (d);
}

CS_DEPRECATED_METHOD_MSG("Use CS::IsNaN(x) instead")
CS_FORCEINLINE bool csNaN (float f)
{
  return CS::IsNaN (f);
}
CS_DEPRECATED_METHOD_MSG("Use CS::IsNaN(x) instead")
CS_FORCEINLINE bool csNaN (double d)
{
  return CS::IsNaN (d);
}

CS_DEPRECATED_METHOD_MSG("Usage not recommended, inconsistent results")
CS_FORCEINLINE bool csNormal (float f)
{
#if defined (CS_HAVE_NORMALF)
  return normalf (f);
#elif defined (CS_HAVE_STD__ISNORMAL)
  return std::isnormal (f);
#elif defined(CS_HAVE_ISNORMAL)
  return isnormal (f);
#else
  return CS::IsFinite(f) && !CS::IsNaN(f);
#endif
}
CS_DEPRECATED_METHOD_MSG("Usage not recommended, inconsistent results")
CS_FORCEINLINE bool csNormal (double d)
{
#if defined (CS_HAVE_STD__ISNORMAL)
  return std::isnormal (d);
#elif defined(CS_HAVE_ISNORMAL)
  return isnormal (d);
#else
  return CS::IsFinite(d) && !CS::IsNaN(d);
#endif
}


namespace CS
{
namespace Math
{
  template<typename T>
  CS_FORCEINLINE_TEMPLATEMETHOD T NextModulo3 (T number)
  {
    return (1 << number) & 0x3;
  }
}
}


#endif //__CS_MATH_H__

---