defs.hpp

Go to the documentation of this file.

/* --------------------------------------------------------------- *\

   author:

      mathias gumz

\* --------------------------------------------------------------- */

#ifndef _DEFS_HPP_
#define _DEFS_HPP_


#include <ak/platform.hpp>


namespace math
{

#ifndef M_PI
# define M_PI       3.14159265358979323846
# define M_PI_2     1.57079632679489661923
# define M_PI_4     0.78539816339744830962
# define M_1_PI     0.31830988618379067154
# define M_2_PI     0.63661977236758134308
# define M_2_SQRTPI 1.12837916709551257390
#endif // M_PI

#ifndef atan2
double atan2(double y, double x)
{
  float dvp, dvn;
  if(x > 0.0)
  {
    dvp= 1.0;
    dvn= 0.0;
  } else
  {
    dvp= 0.0;
    dvn= 1.0;
  }

  float dhn = (y < 0) ? 1.0 : 0.0;
  float psi;
  if (y == 0.0)
    psi= M_PI_2 * (dvp + 3.0 * dvn);
  else if (x == 0.0)
    psi= M_PI * dhn;
  else
    psi= atan(x/y) + M_PI * dhn * dvp
       + (M_PI + M_PI * (y > 0.0)) * dvn;
  return psi * (180.0*M_1_PI);
}
#endif // atan2



/* --------------------------------------------------------------- *\
    some nifty tools from modernc++design.com
\* --------------------------------------------------------------- */

template<int> struct CompileTimeError;
template<> struct CompileTimeError<true> {};
#define STATIC_CHECK(expr, msg) \
    { CompileTimeError<((expr) != 0)> ERROR_##msg; (void)ERROR_##msg; }


template <int v>
struct Int2Type
{
  enum { value= v };
}; // struct Int2Type


template<typename T>
struct Traits
{
  T static zero() { return T(0); };
  T static one()  { return T(1); };
  T static inv()  { return T(-1); };
};



template<class T, int S>
struct Chunk
{
  T*        begin()       { return &val[0]; };
  const T*  begin() const { return &val[0]; };
  T*        end()         { return &val[S]; };
  const T*  end()   const { return &val[S]; };

  const T&  operator[](const unsigned int i) const { return val[i]; };
  T&        operator[](const unsigned int i)       { return val[i]; };

  static unsigned int size() { return S; };
  static unsigned int bytesize() { return sizeof(Chunk<T, S>); }

  mutable T val[S];
}; //  struct Chunk

#include <ak/defs.inl>

}; // namespace math

#endif // _DEFS_HPP_

---