typedefs.hh

Go to the documentation of this file.

 
#ifndef typedefs_hh
#define typedefs_hh
 
#define _USE_MATH_DEFINES
#include <cmath>
// Define the constant M_PI, if not defined (e.g. with Windows Microsoft C++ compiler)
#ifndef M_PI
#define M_PI 3.14159265358979323846264338327
#endif
 
// Define the epsilon machine, i.e. the difference between 1 and the next representable value of double type 
#if __GNUC__ == 2
#  include <float.h>
#  define EPS DBL_EPSILON
#else
#  include <limits>
#  define EPS std::numeric_limits<double>::epsilon()
#endif
 
#if __GNUC__ >= 9
#include <stddef.h>
#endif
#include <sys/types.h>
#include <string>
#include <complex>
 
namespace concepts {
 
  typedef double Real;
 
  typedef std::complex<Real> Cmplx;
 
  typedef signed int sint;
 
  typedef unsigned char uchar;
 
  typedef unsigned short ushort;
 
  // **************************************************************** number **
 
  template<typename F>
  struct number {};
 
  template<>
  struct number<double> {
    static inline std::string name() { return "double"; }
  };
 
  template<>
  struct number<long double> {
    static inline std::string name() { return "long double"; }
  };
 
  template<>
  struct number<std::complex<double> > {
    static inline std::string name() { return "complex<double>"; }
  };
 
  template<>
  struct number<std::complex<long double> > {
    static inline std::string name() { return "complex<long double>"; }
  };
 
  // ************************************************************** Realtype **
 
  template<typename F>
  struct Realtype {
    typedef F type;
  };
 
  template<typename F>
  struct Realtype<std::complex<F> > {
    typedef F type;
  };
 
  // ************************************************************* Cmplxtype **
 
  template<typename F>
  struct Cmplxtype {
    typedef std::complex<F> type;
  };
 
  template<typename F>
  struct Cmplxtype<std::complex<F> > {
    typedef std::complex<F> type;
  };
 
  // ************************************************************** Combtype **
  
  template<typename F, typename G>
  struct Combtype {
    typedef F type;
  };
 
  template<typename F>
  struct Combtype<std::complex<F>, F> {
    typedef std::complex<F> type;
  };
 
  template<typename F>
  struct Combtype<F, std::complex<F> > {
    typedef std::complex<F> type;
  };
 
  template<typename F>
  struct Combtype<int, F> {
    typedef F type;
  };
 
  template<typename F>
  struct Combtype<F, int> {
    typedef F type;
  };
 
  // ************************************************************** Datatype **
 
  template<typename F>
  struct Datatype {
    typedef F type;
  };
 
} // namespace concepts
 
#endif // typedefs_hh