Arith.hpp

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of BORDERBASIX software. *
*      (C) B. Mourrain,  INRIA                                       *
**********************************************************************
History: 
$Id: Arith.hpp,v 1.1.1.1 2006/10/06 08:01:40 trebuche Exp $
**********************************************************************/
#ifndef _Arith_H_
#define _Arith_H_

#include <stdlib.h>

template <class C> struct CST {
  const static C Zero;
  const static C Un;
};

template <class C> const C CST<C>::Zero=0;
template <class C> const C CST<C>::Un=1;

template <class C> inline void convert (C &, char *);
template <class C> inline bool IsNull (const C);
template <class C> inline bool IsDivide (const C, const C);
template <class C> inline C Gcd (const C, const C);

//----------------------------------------------------------------------
// Generic implementation
//----------------------------------------------------------------------
template <class C> inline bool IsNull(const C c) {
    return c==CST<C>::Zero;
}

//----------------------------------------------------------------------
// Specialization for int
//----------------------------------------------------------------------
template <> const int CST<int>::Zero = 0;
template <> const int CST<int>::Un = 1;

template <>
inline void convert(int &i, char *s) {
     i = atoi(s);
}

template <> inline bool IsNull(const int i) {
    return i==0;
}

template <> 
inline bool IsDivide (int a, int b) {
    return b != 0 && a % b == 0;
}

template <>
inline int Gcd (int a, int b) {
    int r;
    while ((r = a % b) != 0)
        {
            a = b;
            b = r;
        }
    return b;
}


inline double factorial (int n) {
        double res=1;
        for (int i = n; i > 1; --i)
                        res *= i;
                return res;
}

//----------------------------------------------------------------------
// specification for double
//----------------------------------------------------------------------
template <> const double CST<double>::Zero = 0.0;
template <> const double CST<double>::Un = 1.0;
template <>
inline void convert(double & d,char *s) {
 d = atof(s);
}
template<typename T>
inline void convert (T & dd, char *s)
{
  T tmp=0;
  long ttmp;
  int i=0;
  T comp=1;
  char *reslook,sign;
  ttmp=atoll(s);
  tmp+=(T)ttmp;
  sign=(*s=='-')?-1:1;
  for(;(tmp/comp)>(T)1;i++) comp*=10;
  comp=10;
  //strchr(s,'.');
  if (strchr(s,'.')!=NULL)
    {
      i=strchr(s,'.')-s;
      i++;
      //cout<<"s["<<i<<"]"<<s[i]<<endl;
      for(;;i++)
    {
      switch(s[i]) {
      case '1':{tmp+=sign*1/comp;comp*=10;break;}
      case '2':{tmp+=sign*2/comp;comp*=10;break;}
      case '3':{tmp+=sign*3/comp;comp*=10;break;}
      case '4':{tmp+=sign*4/comp;comp*=10;break;}
      case '5':{tmp+=sign*5/comp;comp*=10;break;}
      case '6':{tmp+=sign*6/comp;comp*=10;break;}
      case '7':{tmp+=sign*7/comp;comp*=10;break;}
      case '8':{tmp+=sign*8/comp;comp*=10;break;}
      case '9':{tmp+=sign*9/comp;comp*=10;break;}
      case '0':
        {
          comp*=10;
          break;
        }
      default:goto end;
      }
    }
    }
    end:dd=tmp;
   reslook=strchr(s,'e');
   if(reslook!=NULL)
     {
       comp=atoi(reslook+1);
       for (int k=0;(T)k<comp;k++)
     dd*=10;
       for (int k=0;(T)k>comp;k--)
     dd/=(T)10;
     }
  //cout<<"valeur de retour "<<dd<<endl;
  return;
}
template <> inline bool IsNull(const double d) {
    return d ==0;
}
template <>
bool IsDivide (double a, double b) {
    return b != 0;
}

template <>
double Gcd (double a, double b) {
    return 1;
}

#endif // //_Arith_H_