vpMath.h

/****************************************************************************
 *
 * $Id: vpMath.h 4604 2014-01-21 14:15:23Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2014 by INRIA. All rights reserved.
 * 
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact INRIA about acquiring a ViSP Professional 
 * Edition License.
 *
 * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * If you have questions regarding the use of this file, please contact
 * INRIA at visp@inria.fr
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * Description:
 * Simple mathematical function not available in the C math library (math.h).
 *
 * Authors:
 * Eric Marchand
 *
 *****************************************************************************/

#ifndef vpMATH_HH
#define vpMATH_HH

#include <visp/vpConfig.h>

#include <math.h>

#if defined(_WIN32) // Not defined in Microsoft math.h

# ifndef M_PI
#   define M_PI            3.14159265358979323846f
# endif

# ifndef M_PI_2
#   define M_PI_2          (M_PI/2.f)
# endif

# ifndef M_PI_4
#   define M_PI_4          (M_PI/4.f)
# endif

#endif


class VISP_EXPORT vpMath
{
 public:

  static inline double deg(double rad) { return (rad*180.0)/M_PI ; }

  static inline double rad(double deg) { return (deg*M_PI)/180.0 ; }

  static inline double sqr(double x) { return x*x ; }

  //  factorial of x
  static inline double fact(unsigned int x) ;

  // combinaison
  static inline long double comb(unsigned int n, unsigned int p) ;

  //   round x to the nearest integer
  static inline int round(const double x) ;

  //   return the sign of x (+-1)
  static inline int sign(double x) ;


  // test if a number equals 0 (with threshold value)
  static inline bool nul(double x, double s=0.001);

  // test if two numbers are equals (with a user defined threshold)
  static inline bool equal(double x, double y, double s=0.001);

  // test if a number is greater than another (with a user defined threshold)
  static inline bool greater(double x, double y, double s=0.001);


  template <class Type> static Type maximum(const Type& a, const Type& b)
  {
    return (a > b) ? a : b;
  }

  template <class Type> static Type minimum(const Type& a, const Type& b)
  {
    return (a < b) ? a : b;
  }

  template <class Type> static Type abs(const Type& x)
  {
    return (x < 0) ? -x : x;
  }


  // sinus cardinal
  static inline double sinc(double x) ;
  static inline double sinc(double sinx, double x) ;
  static inline double mcosc(double cosx, double x) ;
  static inline double msinc(double sinx, double x) ;

  // sigmoid
  static inline double sigmoid(double x, double x0=0.,double x1=1., double n=12.);

  template <class Type> static void swap(Type& a, Type& b)
  {
    Type tmp = b;
    b = a;
    a = tmp;
  }

 private:
  static const double ang_min_sinc;
  static const double ang_min_mc;
};



//Begining of the inline functions definition

double vpMath::fact(unsigned int x)
{
  if ( (x == 1) || (x == 0)) return 1;
  return x * fact(x-1);
}

long double vpMath::comb(unsigned int n, unsigned int p)
{
  if (n == p) return 1;
  return fact(n)/ (fact(n-p) * fact(p));
}


int vpMath::round(const double x)
{
  if (sign(x) > 0)
    {
      if ((x-(int)x) <= 0.5) return (int)x ;
      else return (int)x+1 ;
    }
  else
    {
      if (fabs(x-(int)x) <= 0.5) return (int)x ;
      else return (int)x-1 ;
    }
}

int vpMath::sign(double x)
{
  if (fabs(x) < 1e-15) return 0 ;else
    {
      if (x<0) return -1 ; else return 1 ;
    }
}

bool vpMath::nul(double x, double s)
{
  return(fabs(x)<s);
}

bool vpMath::equal(double x, double y, double s)
{
  return( nul(x-y, s) );
}

bool vpMath::greater(double x, double y, double s)
{
  return(x>(y-s));
}

double vpMath::sinc(double x)
{
  if (fabs(x) < ang_min_sinc) return 1.0 ;
  else  return sin(x)/x ;
}
double vpMath::sinc(double sinx, double x)
{
  if (fabs(x) < ang_min_sinc) return 1.0 ;
  else  return (sinx/x) ;
}

double vpMath::mcosc(double cosx, double x)
{
  if (fabs(x) < ang_min_mc) return 0.5 ;
  else  return ((1.0-cosx)/x/x) ;
}

double vpMath::msinc(double sinx, double x)
{
  if (fabs(x) < ang_min_mc) return (1./6.0) ;
  else  return ((1.0-sinx/x)/x/x) ;
}

double vpMath::sigmoid(double x, double x0,double x1, double n)
{
    if(x < x0)
        return 0.;
    else if(x > x1)
        return 1.;
    double l0 = 1./(1.+exp(0.5*n));
    double l1 = 1./(1.+exp(-0.5*n));
    return (1./(1.+exp(-n*((x-x0)/(x1-x0)-0.5)))-l0)/(l1-l0);
}

#endif

/*
 * Local variables:
 * c-basic-offset: 2
 * End:
 */