/* boost random/detail/signed_unsigned_tools.hpp header file
 *
 * Copyright Jens Maurer 2006
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 *
 * See http://www.boost.org for most recent version including documentation.
 */

#ifndef BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS
#define BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS

#include <boost/limits.hpp>
#include <boost/config.hpp>

namespace boost {
namespace random {
namespace detail {

/*
 * Given an (integral) type T, returns the type "unsigned T".
 * (type_traits appears to be lacking the feature)
 */

template<class T>
struct make_unsigned { };

template<>
struct make_unsigned<char>
{
  typedef unsigned char type;
};

template<>
struct make_unsigned<signed char>
{
  typedef unsigned char type;
};

template<>
struct make_unsigned<unsigned char>
{
  typedef unsigned char type;
};

template<>
struct make_unsigned<short>
{
  typedef unsigned short type;
};

template<>
struct make_unsigned<unsigned short>
{
  typedef unsigned short type;
};

template<>
struct make_unsigned<int>
{
  typedef unsigned int type;
};

template<>
struct make_unsigned<unsigned int>
{
  typedef unsigned int type;
};

template<>
struct make_unsigned<long>
{
  typedef unsigned long type;
};

template<>
struct make_unsigned<unsigned long>
{
  typedef unsigned long type;
};

#ifdef BOOST_HAS_LONG_LONG
template<>
struct make_unsigned<long long>
{
  typedef unsigned long long type;
};

template<>
struct make_unsigned<unsigned long long>
{
  typedef unsigned long long type;
};
#endif


/*
 * Compute x - y, we know that x >= y, return an unsigned value.
 */

template<class T, bool sgn = std::numeric_limits<T>::is_signed>
struct subtract { };

template<class T>
struct subtract<T, /* signed */ false>
{
  typedef T result_type;
  result_type operator()(T x, T y) { return x - y; }
};

template<class T>
struct subtract<T, /* signed */ true>
{
  typedef typename make_unsigned<T>::type result_type;
  result_type operator()(T x, T y)
  {
    if (y >= 0)   // because x >= y, it follows that x >= 0, too
      return result_type(x) - result_type(y);
    if (x >= 0)   // y < 0
      // avoid the nasty two's complement case for y == min()
      return result_type(x) + result_type(-(y+1)) + 1;
    // both x and y are negative: no signed overflow
    return result_type(x - y);
  }
};

/*
 * Compute x + y, x is unsigned, result fits in type of "y".
 */

template<class T1, class T2, bool sgn = std::numeric_limits<T2>::is_signed>
struct add { };

template<class T1, class T2>
struct add<T1, T2, /* signed */ false>
{
  typedef T2 result_type;
  result_type operator()(T1 x, T2 y) { return x + y; }
};

template<class T1, class T2>
struct add<T1, T2, /* signed */ true>
{
  typedef T2 result_type;
  result_type operator()(T1 x, T2 y)
  {
    if (y >= 0)
      return x + y;
    // y < 0
    if (x >= T1(-(y+1)))  // result >= 0 after subtraction
      // avoid the nasty two's complement edge case for y == min()
      return T2(x - T1(-(y+1)) - 1);
    // abs(x) < abs(y), thus T2 able to represent x
    return T2(x) + y;
  }
};

} // namespace detail
} // namespace random
} // namespace boost

#endif // BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS