Math.hpp

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Base Library
 * Module     : Math
 * Package    : Zeus.ZeusBase.Math
 * Author     : Benjamin Hadorn
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 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 Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef Zeus__MathHPP
#define Zeus__MathHPP

#include <zeusbase/Config/PlatformDefines.hpp>
#include <math.h>

BEGIN_NAMESPACE_Zeus

/**************************************************************************/
/**************************************************************************/
class TMath
{
  public:
    /**************************************************************************/
    /**************************************************************************/
    inline static Float ceil(const Float& rfValue)
    {
      #if defined(ENABLE_LINUX_BINDING)
        return ::ceil(rfValue);
      #else
        #if defined(_MSC_VER)
          return ::ceil(rfValue);
        #else
          return std::ceil(rfValue);
        #endif
      #endif
    }

    /**************************************************************************/
    /**************************************************************************/
    inline static Int ceilInt(const Float& rfValue)
    {
      return static_cast<Int>(TMath::ceil(rfValue));
    }

    /**************************************************************************/
    /**************************************************************************/
    inline static Float exp(const Float& rfX)
    {
      return ::exp(rfX);
    }

    /**************************************************************************/
    /**************************************************************************/
    inline static Int expInt(const Float& rfX)
    {
      return roundInt(TMath::exp(rfX));
    }

    /**************************************************************************/
    /**************************************************************************/
    inline static Float floor(const Float& rfValue)
    {
      #if defined(ENABLE_LINUX_BINDING)
        return ::floor(rfValue);
      #else
        #if defined(_MSC_VER)
          return ::floor(rfValue);
        #else
          return std::floor(rfValue);
        #endif
      #endif
    }

    /**************************************************************************/
    /**************************************************************************/
    inline static Int floorInt(const Float& rfValue)
    {
      return static_cast<Int>(TMath::floor(rfValue));
    }

    /************************************************************************/
    /************************************************************************/
    inline static Float ln(const Float& rfValue)
    {
      return ::log(rfValue);
    }

    /************************************************************************/
    /************************************************************************/
    inline static Int lnInt(const Float& rfValue)
    {
      return roundInt(TMath::ln(rfValue));
    }

    /************************************************************************/
    /************************************************************************/
    inline static Float log(const Float& rfValue, const Float& rfBase)
    {
      return (::log(rfValue) / ::log(rfBase));
    }

    /************************************************************************/
    /************************************************************************/
    inline static Int logInt(const Float& rfValue, const Float& rfBase)
    {
      return static_cast<Int>(TMath::log(rfValue, rfBase));
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Float maxFloat(Float fD1, Float fD2)
    {
      Float fRetval = fD1;
      if (fD1 < fD2)
      {
        fRetval = fD2;
      }
      return fRetval;
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Float minFloat(Float fD1, Float fD2)
    {
      Float fRetval = fD1;
      if (fD1 > fD2)
      {
        fRetval = fD2;
      }
      return fRetval;
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Int maxInt(Int iD1, Int iD2)
    {
      Int iRetval = iD1;
      if (iD1 < iD2)
      {
        iRetval = iD2;
      }
      return iRetval;
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Int minInt(Int iD1, Int iD2)
    {
      Int iRetval = iD1;
      if (iD1 > iD2)
      {
        iRetval = iD2;
      }
      return iRetval;
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Float pow(const Float& rfBase, const Float& rfExp)
    {
      return ::pow(rfBase, rfExp);
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Int powInt(const Float& rfBase, const Float& rfExp)
    {
      return static_cast<Int>(::pow(rfBase, rfExp));
    }

    /**********************************************************************/
    /**********************************************************************/
    static Float roundEx(Float fValue, Float fPrecision)
    {
      Float fRetval = fValue;
      if (fPrecision != 0.0)
      {
        Float fX = fValue/fPrecision;
        Float dXTest = fX - floor(fX);

        if (dXTest < 0.5)
        {
          fRetval = floor(fX)*fPrecision;
        }
        else
        {
          fRetval = ceil(fX)*fPrecision;
        }
      }
      return fRetval;
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Float round(const Float& rfValue)
    {
      return roundEx(rfValue, 1.0);
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Int roundInt(const Float& rfValue)
    {
      return static_cast<Int>(roundEx(rfValue, 1.0));
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Float sqrt(const Float& rfValue)
    {
      return ::sqrt(rfValue);
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Int sqrtInt(const Float& rfValue)
    {
      return roundInt(TMath::sqrt(rfValue));
    }

    /**********************************************************************/
    /**********************************************************************/
    inline static Int gcd(Int iA, Int iB)
    {
      while (iB != 0)
      {
        Int iTemp = iB;
        iB = iA % iB;
        iA = iTemp;
      }
      return iA;
    }

    /**********************************************************************/
    /**********************************************************************/
    static Int gcd(Int iA, Int iB, Int& rX, Int& rY)
    {
      rX = 1;
      rY = 0;
      Int iX1 = 0;
      Int iY1 = 1;
      while (iB != 0)
      {
        Int iTemp = iB;
        Int iQuotient = iA / iB; //integer div
        iB = iA % iB;
        iA = iTemp;

        iTemp = iX1;
        iX1 = rX - iQuotient * iX1;
        rX = iTemp;

        iTemp = iY1;
        iY1 = rY - iQuotient * iY1;
        rY = iTemp;
      }
      return iA;
    }

  protected:
    inline TMath() {}
    inline virtual ~TMath() {}
};

END_NAMESPACE_Zeus

#endif