int64x64-128.h

Go to the documentation of this file.

#include "ns3/core-config.h"
#if !defined(INT64X64_128_H) && defined (INT64X64_USE_128) && !defined(PYTHON_SCAN)
#define INT64X64_128_H

#include <stdint.h>
#include <cmath>  // pow

#if defined(HAVE___UINT128_T) && !defined(HAVE_UINT128_T)
typedef __uint128_t uint128_t;
typedef __int128_t int128_t;
#endif


namespace ns3 {

class int64x64_t
{
  static const uint128_t   HP128_MASK_HI_BIT = (((int128_t)1)<<127);
  static const uint64_t    HP_MASK_LO = 0xffffffffffffffffULL;
  static const uint64_t    HP_MASK_HI = ~HP_MASK_LO;
#define HP_MAX_64    (std::pow (2.0L, 64))

public:
  enum impl_type {
    int128_impl,  
    cairo_impl,   
    ld_impl,      
  };

  static const enum impl_type implementation = int128_impl;

  inline int64x64_t ()
    : _v (0)  {}
  inline int64x64_t (const double value)
  {
    const int64x64_t tmp ((long double)value);
    _v = tmp._v;
  }
  inline int64x64_t (const long double value)
  {
    const bool negative = value < 0;
    const long double v = negative ? -value : value;

    long double fhi;
    long double flo = std::modf (v, &fhi);
    // Add 0.5 to round, which improves the last count
    // This breaks these tests:
    //   TestSuite devices-mesh-dot11s-regression
    //   TestSuite devices-mesh-flame-regression
    //   TestSuite routing-aodv-regression
    //   TestSuite routing-olsr-regression
    // Setting round = 0; breaks:
    //   TestSuite int64x64
    const long double round = 0.5;
    flo = flo * HP_MAX_64 + round;
    int128_t hi = fhi;
    const uint64_t lo = flo;
    if (flo >= HP_MAX_64)
      {
    // conversion to uint64 rolled over
    ++hi;
      }
    _v = hi << 64;
    _v |= lo;
    _v = negative ? -_v : _v;
  }
  inline int64x64_t (const int v)
    : _v (v)
  {
    _v <<= 64;
  }
  inline int64x64_t (const long int v)
    : _v (v) 
  {
    _v <<= 64;
  }
  inline int64x64_t (const long long int v)
    : _v (v) 
  {
    _v <<= 64;
  }
  inline int64x64_t (const unsigned int v)
    : _v (v)
  {
    _v <<= 64;
  }
  inline int64x64_t (const unsigned long int v)
    : _v (v) 
  {
    _v <<= 64;
  }
  inline int64x64_t (const unsigned long long int v)
    : _v (v) 
  {
    _v <<= 64;
  }
  explicit inline int64x64_t (const int64_t hi, const uint64_t lo)
  {
    _v = (int128_t)hi << 64;
    _v |= lo;
  }

  inline int64x64_t (const int64x64_t & o)
    : _v (o._v) {}
  inline int64x64_t & operator = (const int64x64_t & o)
  {
    _v = o._v;
    return *this;
  }

  inline double GetDouble (void) const
  {
    const bool negative = _v < 0;
    const uint128_t value = negative ? -_v : _v;
    const long double fhi = value >> 64;
    const long double flo = (value & HP_MASK_LO) / HP_MAX_64;
    long double retval = fhi;
    retval += flo;
    retval = negative ? -retval : retval;
    return retval;
  }
  inline int64_t GetHigh (void) const
  {
    const int128_t retval = _v >> 64;
    return retval;
  }
  inline uint64_t GetLow (void) const
  {
    const uint128_t retval = _v & HP_MASK_LO;
    return retval;
  }

  void MulByInvert (const int64x64_t & o);

  static int64x64_t Invert (const uint64_t v);

private:
  friend bool         operator == (const int64x64_t & lhs, const int64x64_t & rhs);

  friend bool         operator <  (const int64x64_t & lhs, const int64x64_t & rhs);
  friend bool         operator >  (const int64x64_t & lhs, const int64x64_t & rhs);
  
  friend int64x64_t & operator += (      int64x64_t & lhs, const int64x64_t & rhs);
  friend int64x64_t & operator -= (      int64x64_t & lhs, const int64x64_t & rhs);
  friend int64x64_t & operator *= (      int64x64_t & lhs, const int64x64_t & rhs);
  friend int64x64_t & operator /= (      int64x64_t & lhs, const int64x64_t & rhs);

  friend int64x64_t   operator -  (const int64x64_t & lhs);
  friend int64x64_t   operator !  (const int64x64_t & lhs);

  void Mul (const int64x64_t & o);
  void Div (const int64x64_t & o);
  static uint128_t Umul         (const uint128_t a, const uint128_t b);
  static uint128_t Udiv         (const uint128_t a, const uint128_t b);
  static uint128_t UmulByInvert (const uint128_t a, const uint128_t b);

  inline int64x64_t (const int128_t v)
    : _v (v) {}

  int128_t _v;  

};  // class int64x64_t


inline bool operator == (const int64x64_t & lhs, const int64x64_t & rhs)
{
  return lhs._v == rhs._v;
}
inline bool operator < (const int64x64_t & lhs, const int64x64_t & rhs)
{
  return lhs._v < rhs._v;
}
inline bool operator > (const int64x64_t & lhs, const int64x64_t & rhs)
{
  return lhs._v > rhs._v;
}

inline int64x64_t & operator += (int64x64_t & lhs, const int64x64_t & rhs)
{
  lhs._v += rhs._v;
  return lhs;
}
inline int64x64_t & operator -= (int64x64_t & lhs, const int64x64_t & rhs)
{
  lhs._v -= rhs._v;
  return lhs;
}
inline int64x64_t & operator *= (int64x64_t & lhs, const int64x64_t & rhs)
{
  lhs.Mul (rhs);
  return lhs;
}
inline int64x64_t & operator /= (int64x64_t & lhs, const int64x64_t & rhs)
{
  lhs.Div (rhs);
  return lhs;
}

inline int64x64_t operator + (const int64x64_t & lhs)
{
  return lhs;
}
inline int64x64_t operator - (const int64x64_t & lhs)
{
  return int64x64_t (-lhs._v);
}
inline int64x64_t operator ! (const int64x64_t & lhs)
{
  return int64x64_t (!lhs._v);
}


} // namespace ns3

#endif /* INT64X64_128_H */