uniform.hpp

/*
Copyright 2010-2011, D. E. Shaw Research.
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

* Redistributions of source code must retain the above copyright
  notice, this list of conditions, and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright
  notice, this list of conditions, and the following disclaimer in the
  documentation and/or other materials provided with the distribution.

* Neither the name of D. E. Shaw Research nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef __r123_uniform_dot_hpp
#define __r123_uniform_dot_hpp

#include <Random123/features/compilerfeatures.h>
#include <limits>
#include <cstdint>
#include <cstddef>
#if RANDOM_ITERATOR_R123_USE_CXX11_TYPE_TRAITS
#include <type_traits>
#endif
#if __cplusplus >= 201103L
#include <array>
#endif

namespace random_iterator_r123 {
#if RANDOM_ITERATOR_R123_USE_CXX11_TYPE_TRAITS
  using std::make_signed;
  using std::make_unsigned;
#else
  // Sigh... We could try to find another <type_traits>, e.g., from
  // boost or TR1.  Or we can do it ourselves in the r123 namespace.
  // It's not clear which will cause less headache...
  template <typename T>
  struct make_signed {};
  template <typename T>
  struct make_unsigned {};
#define RANDOM_ITERATOR_R123_MK_SIGNED_UNSIGNED(ST, UT) \
  template <>                                           \
  struct make_signed<ST> {                              \
    typedef ST type;                                    \
  };                                                    \
  template <>                                           \
  struct make_signed<UT> {                              \
    typedef ST type;                                    \
  };                                                    \
  template <>                                           \
  struct make_unsigned<ST> {                            \
    typedef UT type;                                    \
  };                                                    \
  template <>                                           \
  struct make_unsigned<UT> {                            \
    typedef UT type;                                    \
  }

  RANDOM_ITERATOR_R123_MK_SIGNED_UNSIGNED(int8_t, uint8_t);
  RANDOM_ITERATOR_R123_MK_SIGNED_UNSIGNED(int16_t, uint16_t);
  RANDOM_ITERATOR_R123_MK_SIGNED_UNSIGNED(int32_t, uint32_t);
  RANDOM_ITERATOR_R123_MK_SIGNED_UNSIGNED(int64_t, uint64_t);
#if RANDOM_ITERATOR_R123_USE_GNU_UINT128
  RANDOM_ITERATOR_R123_MK_SIGNED_UNSIGNED(__int128_t, __uint128_t);
#endif
#undef RANDOM_ITERATOR_R123_MK_SIGNED_UNSIGNED
#endif

#if defined(__CUDACC__) || defined(_LIBCPP_HAS_NO_CONSTEXPR)
  // Amazing! cuda thinks numeric_limits::max() is a __host__ function, so
  // we can't use it in a device function.
  //
  // The LIBCPP_HAS_NO_CONSTEXP test catches situations where the libc++
  // library thinks that the compiler doesn't support constexpr, but we
  // think it does.  As a consequence, the library declares
  // numeric_limits::max without constexpr.  This workaround should only
  // affect a narrow range of compiler/library pairings.
  //
  // In both cases, we find max() by computing ~(unsigned)0 right-shifted
  // by is_signed.
  template <typename T>
  RANDOM_ITERATOR_R123_CONSTEXPR RANDOM_ITERATOR_R123_STATIC_INLINE
      RANDOM_ITERATOR_R123_CUDA_DEVICE T
      maxTvalue() {
    typedef typename make_unsigned<T>::type uT;
    return (~uT(0)) >> std::numeric_limits<T>::is_signed;
  }
#else
  template <typename T>
  RANDOM_ITERATOR_R123_CONSTEXPR RANDOM_ITERATOR_R123_STATIC_INLINE T maxTvalue() {
    return std::numeric_limits<T>::max();
  }
#endif


  template <typename Ftype, typename Itype>
  RANDOM_ITERATOR_R123_CUDA_DEVICE RANDOM_ITERATOR_R123_STATIC_INLINE Ftype
  u01(Itype in) {
    typedef typename make_unsigned<Itype>::type Utype;
    RANDOM_ITERATOR_R123_CONSTEXPR Ftype factor =
        Ftype(1.) / (maxTvalue<Utype>() + Ftype(1.));
    RANDOM_ITERATOR_R123_CONSTEXPR Ftype halffactor = Ftype(0.5) * factor;
#if RANDOM_ITERATOR_R123_UNIFORM_FLOAT_STORE
    volatile Ftype x = Utype(in) * factor;
    return x + halffactor;
#else
    return Utype(in) * factor + halffactor;
#endif
  }


  template <typename Ftype, typename Itype>
  RANDOM_ITERATOR_R123_CUDA_DEVICE RANDOM_ITERATOR_R123_STATIC_INLINE Ftype
  uneg11(Itype in) {
    typedef typename make_signed<Itype>::type Stype;
    RANDOM_ITERATOR_R123_CONSTEXPR Ftype factor =
        Ftype(1.) / (maxTvalue<Stype>() + Ftype(1.));
    RANDOM_ITERATOR_R123_CONSTEXPR Ftype halffactor = Ftype(0.5) * factor;
#if RANDOM_ITERATOR_R123_UNIFORM_FLOAT_STORE
    volatile Ftype x = Stype(in) * factor;
    return x + halffactor;
#else
    return Stype(in) * factor + halffactor;
#endif
  }


  template <typename Ftype, typename Itype>
  RANDOM_ITERATOR_R123_CUDA_DEVICE RANDOM_ITERATOR_R123_STATIC_INLINE Ftype
  u01fixedpt(Itype in) {
    typedef typename make_unsigned<Itype>::type Utype;
    RANDOM_ITERATOR_R123_CONSTEXPR int excess =
        std::numeric_limits<Utype>::digits - std::numeric_limits<Ftype>::digits;
    if (excess >= 0) {
      RANDOM_ITERATOR_R123_CONSTEXPR int ex_nowarn = (excess >= 0) ? excess : 0;
      RANDOM_ITERATOR_R123_CONSTEXPR Ftype factor =
          Ftype(1.) / (Ftype(1.) + ((maxTvalue<Utype>() >> ex_nowarn)));
      return (1 | (Utype(in) >> ex_nowarn)) * factor;
    } else
      return u01<Ftype>(in);
  }

#if RANDOM_ITERATOR_R123_USE_CXX11_STD_ARRAY


  template <typename Ftype, typename CollType>
  static inline std::array<Ftype, CollType::static_size> u01all(CollType in) {
    std::array<Ftype, CollType::static_size> ret;
    size_t i = 0;
    for (auto e : in) { ret[i++] = u01<Ftype>(e); }
    return ret;
  }


  template <typename Ftype, typename CollType>
  static inline std::array<Ftype, CollType::static_size> uneg11all(CollType in) {
    std::array<Ftype, CollType::static_size> ret;
    size_t i = 0;
    for (auto e : in) { ret[i++] = uneg11<Ftype>(e); }
    return ret;
  }


  template <typename Ftype, typename CollType>
  static inline std::array<Ftype, CollType::static_size> u01fixedptall(CollType in) {
    std::array<Ftype, CollType::static_size> ret;
    size_t i = 0;
    for (auto e : in) { ret[i++] = u01fixedpt<Ftype>(e); }
    return ret;
  }
#endif // __cplusplus >= 201103L

} // namespace random_iterator_r123

#endif