libs/CppAddons/CAMath.h

   1 // Copyright 2003 "Gilles Degottex"
   2
   3 // This file is part of "CppAddons"
   4
   5 // "CppAddons" is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU Lesser General Public License as published by
   7 // the Free Software Foundation; either version 2.1 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // "CppAddons" is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13 // GNU Lesser General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Lesser General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19
  20 #ifndef _Math_h_
  21 #define _Math_h_
  22
  23 #include <math.h>
  24 #include <cmath>
  25 #include <complex>
  26 using namespace std;
  27
  28 #undef min
  29 #undef max
  30
  31 namespace Math
  32 {
  33         template<typename TypeData> inline TypeData sgn(TypeData a)                     {return (a<0)?-1:1;}
  34
  35         static const double Pi = 2*acos(0);
  36     static const double Pi2 = 2*Pi;
  37         static const float fPi = 2*acos(0);
  38
  39         static const double E = exp(1);
  40         static const float fE = exp(1);
  41
  42         // résoud une equation du 2ème degré
  43         class SolOfEq2
  44         {
  45           public:
  46                 enum ENError{NE_OK=0, NE_DISCRIMINENT_NEG, NE_A_AND_B_EQ_ZERO, NE_RACINE_NEG, NE_X1_AND_X2_NEG, NE_X1_AND_X2_POS};
  47
  48           private:
  49                 ENError m_err;
  50
  51                 double  x1;
  52                 double  x2;
  53
  54           public:
  55                 double getX1(){return x1;}
  56                 double getX2(){return x2;}
  57                 double getPosSol();
  58
  59                 SolOfEq2(double a, double b, double c);
  60         };
  61
  62         // calcul l'intérale de f sur [a;b] avec un pas de h
  63         // méhode de Simpson
  64         template<class Function>
  65         double Simpson(double a, double b, Function f, double h)
  66         {
  67                 double I4=f(a+h/2.0), I2=0;
  68                 for(double x4=a+(h/2.0)+h, x2=a+h; x4<b; x4+=h, x2+=h)
  69                 {
  70                         I4+=f(x4);
  71                         I2+=f(x2);
  72                 }
  73                 return (h/6.0)*(f(a)+4*I4+2*I2+f(b));
  74         }
  75
  76         template<typename Type> std::complex<Type> make_complex(Type value[]){return std::complex<Type>(value[0], value[1]);}
  77
  78         inline double modulo(double d1, double d2)
  79         {
  80                     return d1-int(d1/d2)*d2;
  81         }
  82         inline double mod2(const double c[2])
  83         {
  84                 return c[0]*c[0]+c[1]*c[1];
  85         }
  86         inline double mod(const double c[2])
  87         {
  88                 return sqrt(mod2(c));
  89         }
  90         inline double mod2(const std::complex<double>& c)
  91         {
  92                 return c.real()*c.real()+c.imag()*c.imag();
  93         }
  94         inline double mod(const std::complex<double>& c)
  95         {
  96                 return sqrt(mod2(c));
  97         }
  98
  99         inline double mod_equal(double& d1, double d2)
 100         {
 101                     return d1 -= int(d1/d2)*d2;
 102         }
 103
 104         //! gauss fonction
 105         /*!
 106                 * \param x \f$\in ]-\infty,\infty[\f$
 107         */
 108         inline double gauss(double x)
 109         {
 110                 return exp(-Math::Pi*x*x);
 111         }
 112
 113         inline double sinc(double t)
 114         {
 115                 if(t==0.0)      return 1.0;
 116
 117                 return sin(Math::Pi*t)/(Math::Pi*t);
 118         }
 119
 120 /*      doesn't need for Linux for sure, seems to be probelatic under win32 (macro ambiquity)
 121         template<typename TypeData1, typename TypeData2>
 122         TypeData1 max(const TypeData1& a, const TypeData2& b)
 123         {
 124         return (a>b)?a:b;
 125 }
 126
 127         template<typename TypeData1, typename TypeData2>
 128         TypeData1 min(const TypeData1& a, const TypeData2& b)
 129         {
 130         return (a<b)?a:b;
 131 }*/
 132
 133 //      template<typename TypeData> TypeData abs(const TypeData& a) {return (a<0)?-a:a;}        // include <cmath> instead
 134 //      template<typename TypeData> TypeData abs(TypeData a)            {return (a<0)?-a:a;}    // include <cmath> instead
 135
 136 }
 137
 138 #endif
 139