uniform.hpp

Go to the documentation of this file.

/*
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>
#if R123_USE_CXX11_TYPE_TRAITS
#include <type_traits>
#endif
#if __cplusplus >= 201103L
#include <array>
#endif
 
namespace r123 {
#if 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 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;                                                                                                             \
    }
 
R123_MK_SIGNED_UNSIGNED(int8_t, uint8_t);
R123_MK_SIGNED_UNSIGNED(int16_t, uint16_t);
R123_MK_SIGNED_UNSIGNED(int32_t, uint32_t);
R123_MK_SIGNED_UNSIGNED(int64_t, uint64_t);
#if R123_USE_GNU_UINT128
R123_MK_SIGNED_UNSIGNED(__int128_t, __uint128_t);
#endif
#undef 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>
R123_CONSTEXPR R123_STATIC_INLINE 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>
R123_CONSTEXPR R123_STATIC_INLINE T maxTvalue() {
    return std::numeric_limits<T>::max();
}
#endif
 
template<typename Ftype, typename Itype>
R123_CUDA_DEVICE R123_STATIC_INLINE Ftype u01(Itype in) {
    typedef typename make_unsigned<Itype>::type Utype;
    R123_CONSTEXPR Ftype factor = Ftype(1.) / (Ftype(maxTvalue<Utype>()) + Ftype(1.));
    R123_CONSTEXPR Ftype halffactor = Ftype(0.5) * factor;
#if 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>
R123_CUDA_DEVICE R123_STATIC_INLINE Ftype uneg11(Itype in) {
    typedef typename make_signed<Itype>::type Stype;
    R123_CONSTEXPR Ftype factor = Ftype(1.) / (Ftype(maxTvalue<Stype>()) + Ftype(1.));
    R123_CONSTEXPR Ftype halffactor = Ftype(0.5) * factor;
#if 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>
R123_CUDA_DEVICE R123_STATIC_INLINE Ftype u01fixedpt(Itype in) {
    typedef typename make_unsigned<Itype>::type Utype;
    R123_CONSTEXPR int excess = std::numeric_limits<Utype>::digits - std::numeric_limits<Ftype>::digits;
    if(excess >= 0) {
        R123_CONSTEXPR int ex_nowarn = (excess >= 0) ? excess : 0;
        R123_CONSTEXPR Ftype factor = Ftype(1.) / (Ftype(1.) + Ftype((maxTvalue<Utype>() >> ex_nowarn)));
        return (1 | (Utype(in) >> ex_nowarn)) * factor;
    } else
        return u01<Ftype>(in);
}
 
#if 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;
    auto p = ret.begin();
    for(auto e : in) {
        *p++ = 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;
    auto p = ret.begin();
    for(auto e : in) {
        *p++ = 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;
    auto p = ret.begin();
    for(auto e : in) {
        *p++ = u01fixedpt<Ftype>(e);
    }
    return ret;
}
#endif // __cplusplus >= 201103L
 
} // namespace r123
 
#endif