math-extension.hh

Go to the documentation of this file.

/*
 * lib-gmapkernel : Un noyau de 3-G-cartes et des opérations.
 * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
 *               http://www.sic.sp2mi.univ-poitiers.fr/
 * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
 *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
 *
 * This file is part of lib-gmapkernel
 *
 * This program 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
 */

//******************************************************************************
#ifndef MATH_EXTENSION_HH
#define MATH_EXTENSION_HH
//******************************************************************************
#include <cassert>
#include <cmath> // Pour la macro M_PI et fabs
//******************************************************************************
class CVertex;
//******************************************************************************
//******************************************************************************
// @name Macros
// @{

#ifndef MIN
#define MIN(a, b)  (((a) < (b)) ? (a) : (b))
#endif //MIN

#ifndef  MAX
#define MAX(a, b)  (((a) > (b)) ? (a) : (b))
#endif //MAX

#ifndef M_PI
#define M_PI (3.141592653589793238462643383279)
#endif // M_PI

// @}
//******************************************************************************
// @name Types de base
// @{

typedef double TCoordinate;

extern const TCoordinate EPSILON;

typedef enum
{
  FUNCTION_LIN  , //@< x -> x
  FUNCTION_QUAD , //@< x -> x^2
  FUNCTION_EXP  , //@< x -> e^x
  FUNCTION_LOG  , //@< x -> ln(x) si x>0, x -> 0
  FUNCTION_SIN  , //@< x -> sin(x)
  FUNCTION_COS    //@< x -> cos(x)
}
TFunctionType;

static const int NB_FUNCTION_TYPES = 6;

// @}
//******************************************************************************
// @name Fonctions mathématiques de base
// @{

inline int sqr(int AValue)
{
  return AValue*AValue;
}

inline float sqr(float AValue)
{
  return AValue*AValue;
}

inline double sqr(double AValue)
{
  return AValue*AValue;
}

inline bool isPositive(const TCoordinate& AValue)
{
  // return AValue > 0 || areEqual(fabs(AValue), 0.0);
  return AValue > -EPSILON;
}

inline bool isNegative(const TCoordinate& AValue)
{
  // return AValue < 0 || areEqual(fabs(AValue), 0.0);
  return AValue < +EPSILON;
}

inline bool isZero(const TCoordinate& AValue)
{
  // return areEqual(fabs(AValue), 0.0);
  return fabs(AValue) < EPSILON;
}
  
inline int sign(const TCoordinate& AValue)
{
  if (isZero(AValue))
    return 0;

  return AValue<0 ? -1 : +1;
}

inline int combineSigns(int ASign1, int ASign2)
{
  assert(-1 <= ASign1 && ASign1 <= +1);
  assert(-1 <= ASign2 && ASign2 <= +1);

  if (ASign1==0 || ASign2==0)
    return 0;

  return ASign1==ASign2 ? +1 : -1;
}

inline bool isLessThan(const TCoordinate& AValue1, const TCoordinate& AValue2)
{
  return AValue1 + EPSILON < AValue2;
}
  
inline bool areEqual(const TCoordinate& AValue1, const TCoordinate& AValue2)
{
  return fabs(AValue1 - AValue2) < EPSILON;
}

inline TCoordinate deg(const TCoordinate& AAngle)
{
  return AAngle/M_PI*180.0;
}

inline TCoordinate rad(const TCoordinate& AAngle)
{
  return AAngle*M_PI/180.0;
}

inline TCoordinate dSin(const TCoordinate& AAngle)
{
  return sin(rad(AAngle));
}

inline TCoordinate dCos(const TCoordinate& AAngle)
{
  return cos(rad(AAngle));
}

inline TCoordinate dTan(const TCoordinate& AAngle)
{
  return tan(rad(AAngle));
}

inline TCoordinate dAsin(const TCoordinate& AValue)
{
  return deg(asin(AValue));
}

inline TCoordinate dAcos(const TCoordinate& AValue)
{
  return deg(acos(AValue));
}

inline TCoordinate dAtan(const TCoordinate& AValue)
{
  return deg(atan(AValue));
}

inline TCoordinate limit(const TCoordinate& AAngle)
{
  TCoordinate angle = AAngle;

  if (angle<0)
    while (angle<=-180)
      angle += 360;
  else
    while (angle> +180)
      angle -= 360;

  return angle;
}

inline TCoordinate positifAngle(const TCoordinate& AAngle)
{
  TCoordinate angle = AAngle;

  if ( angle<0 )
    {
      do { angle += 360; } while (angle<0);
    }
  else
    while (angle>=360 )
      angle -= 360;

  return angle;
}

inline TCoordinate angle(const TCoordinate& Ax, const TCoordinate& Ay)
{
  if (isZero(Ax))
    {
      if (isZero(Ay))
    return 0;

      if (Ay<0)
    return -90;
      else
    return +90;
    }

  if (Ax>0)
    return dAtan(Ay/Ax);
  else
    return dAtan(Ay/Ax)+180.0;
}

TCoordinate det(const CVertex& ALine1, const CVertex& ALine2,
        const CVertex& ALine3);

inline int pgcd(int Ax, int Ay)
{
  assert(0 <= Ax);
  assert(0 <= Ay);

  if (Ax < Ay)
    {
      int temp = Ax;
      Ax = Ay;
      Ay = temp;
    }

  while (Ay != 0)
    {
      int temp = Ax % Ay;
      Ax = Ay;
      Ay = temp;
    }

  return Ax;
}

// @}
//******************************************************************************
#endif // MATH_EXTENSION_HH
//******************************************************************************