FM / detail

/usr/include/boost/random/detail

Name	Size	Mode	Actions
auto_link.hpp	959	0644	edit dl rm
config.hpp	538	0644	edit dl rm
const_mod.hpp	5566	0644	edit dl rm
disable_warnings.hpp	823	0644	edit dl rm
enable_warnings.hpp	552	0644	edit dl rm
generator_bits.hpp	874	0644	edit dl rm
generator_seed_seq.hpp	861	0644	edit dl rm
gray_coded_qrng.hpp	4662	0644	edit dl rm
integer_log2.hpp	2181	0644	edit dl rm
int_float_pair.hpp	4178	0644	edit dl rm
iterator_mixin.hpp	1303	0644	edit dl rm
large_arithmetic.hpp	3615	0644	edit dl rm
niederreiter_base2_table.hpp	36285	0644	edit dl rm
operators.hpp	3673	0644	edit dl rm
polynomial.hpp	13305	0644	edit dl rm
ptr_helper.hpp	1534	0644	edit dl rm
qrng_base.hpp	8659	0644	edit dl rm
seed.hpp	5020	0644	edit dl rm
seed_impl.hpp	14283	0644	edit dl rm
signed_unsigned_tools.hpp	2535	0644	edit dl rm
sobol_table.hpp	234013	0644	edit dl rm
uniform_int_float.hpp	2123	0644	edit dl rm
vector_io.hpp	1792	0644	edit dl rm

Edit: /usr/include/boost/random/detail/int_float_pair.hpp (4178B)

#ifndef BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP
#define BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP

#include <utility>
#include <boost/integer.hpp>
#include <boost/integer/integer_mask.hpp>
#include <boost/type_traits/make_unsigned.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/random/uniform_01.hpp>
#include <boost/random/uniform_int_distribution.hpp>
#include <boost/random/detail/signed_unsigned_tools.hpp>
#include <boost/random/detail/integer_log2.hpp>
#include <boost/mpl/bool.hpp>

namespace boost {
namespace random {
namespace detail {

template<class Engine>
inline typename boost::make_unsigned<typename Engine::result_type>::type
generate_one_digit(Engine& eng, std::size_t bits)
{
    typedef typename Engine::result_type base_result;
    typedef typename boost::make_unsigned<base_result>::type base_unsigned;
    
    base_unsigned range =
        detail::subtract<base_result>()((eng.max)(), (eng.min)());
    base_unsigned y0_mask = (base_unsigned(2) << (bits - 1)) - 1;
    base_unsigned y0 = (range + 1) & ~y0_mask;
    base_unsigned u;
    do {
        u = detail::subtract<base_result>()(eng(), (eng.min)());
    } while(y0 != 0 && u > base_unsigned(y0 - 1));
    return u & y0_mask;
}

template<class RealType, std::size_t w, class Engine>
std::pair<RealType, int> generate_int_float_pair(Engine& eng, boost::mpl::true_)
{
    typedef typename Engine::result_type base_result;
    typedef typename boost::make_unsigned<base_result>::type base_unsigned;
    
    base_unsigned range =
        detail::subtract<base_result>()((eng.max)(), (eng.min)());
    
    std::size_t m =
        (range == (std::numeric_limits<base_unsigned>::max)()) ?
            std::numeric_limits<base_unsigned>::digits :
            detail::integer_log2(range + 1);
            
    int bucket = 0;
    // process as many full digits as possible into the int part
    for(std::size_t i = 0; i < w/m; ++i) {
        base_unsigned u = generate_one_digit(eng, m);
        bucket = (bucket << m) | u;
    }
    RealType r;

const std::size_t digits = std::numeric_limits<RealType>::digits;
    {
        base_unsigned u = generate_one_digit(eng, m);
        base_unsigned mask = (base_unsigned(1) << (w%m)) - 1;
        bucket = (bucket << (w%m)) | (mask & u);
        const RealType mult = RealType(1)/RealType(base_unsigned(1) << (m - w%m));
        // zero out unused bits
        if (m - w%m > digits) {
            u &= ~(base_unsigned(1) << (m - digits));
        }
        r = RealType(u >> (w%m)) * mult;
    }
    for(std::size_t i = m - w%m; i + m < digits; ++i) {
        base_unsigned u = generate_one_digit(eng, m);
        r += u;
        r *= RealType(0.5)/RealType(base_unsigned(1) << (m - 1));
    }
    if (m - w%m < digits)
    {
        const std::size_t remaining = (digits - m + w%m) % m;
        base_unsigned u = generate_one_digit(eng, m);
        r += u & ((base_unsigned(2) << (remaining - 1)) - 1);
        const RealType mult = RealType(0.5)/RealType(base_unsigned(1) << (remaining - 1));
        r *= mult;
    }
    return std::make_pair(r, bucket);
}

template<class RealType, std::size_t w, class Engine>
inline std::pair<RealType, int> generate_int_float_pair(Engine& eng, boost::mpl::false_)
{
    int bucket = uniform_int_distribution<>(0, (1 << w) - 1)(eng);
    RealType r = uniform_01<RealType>()(eng);
    return std::make_pair(r, bucket);
}

template<class RealType, std::size_t w, class Engine>
inline std::pair<RealType, int> generate_int_float_pair(Engine& eng)
{
    typedef typename Engine::result_type base_result;
    return generate_int_float_pair<RealType, w>(eng,
        boost::is_integral<base_result>());
}

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

#endif // BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP

/* boost random/detail/int_float_pair.hpp header file * * Copyright Jens Maurer 2000-2001 * Copyright Steven Watanabe 2010-2011 * 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. * * $Id$ * */ #ifndef BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP #define BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP #include #include #include #include #include #include #include #include #include #include namespace boost { namespace random { namespace detail { template inline typename boost::make_unsigned::type generate_one_digit(Engine& eng, std::size_t bits) { typedef typename Engine::result_type base_result; typedef typename boost::make_unsigned::type base_unsigned; base_unsigned range = detail::subtract()((eng.max)(), (eng.min)()); base_unsigned y0_mask = (base_unsigned(2) << (bits - 1)) - 1; base_unsigned y0 = (range + 1) & ~y0_mask; base_unsigned u; do { u = detail::subtract()(eng(), (eng.min)()); } while(y0 != 0 && u > base_unsigned(y0 - 1)); return u & y0_mask; } template std::pair generate_int_float_pair(Engine& eng, boost::mpl::true_) { typedef typename Engine::result_type base_result; typedef typename boost::make_unsigned::type base_unsigned; base_unsigned range = detail::subtract()((eng.max)(), (eng.min)()); std::size_t m = (range == (std::numeric_limits::max)()) ? std::numeric_limits::digits : detail::integer_log2(range + 1); int bucket = 0; // process as many full digits as possible into the int part for(std::size_t i = 0; i < w/m; ++i) { base_unsigned u = generate_one_digit(eng, m); bucket = (bucket << m) | u; } RealType r; const std::size_t digits = std::numeric_limits::digits; { base_unsigned u = generate_one_digit(eng, m); base_unsigned mask = (base_unsigned(1) << (w%m)) - 1; bucket = (bucket << (w%m)) | (mask & u); const RealType mult = RealType(1)/RealType(base_unsigned(1) << (m - w%m)); // zero out unused bits if (m - w%m > digits) { u &= ~(base_unsigned(1) << (m - digits)); } r = RealType(u >> (w%m)) * mult; } for(std::size_t i = m - w%m; i + m < digits; ++i) { base_unsigned u = generate_one_digit(eng, m); r += u; r *= RealType(0.5)/RealType(base_unsigned(1) << (m - 1)); } if (m - w%m < digits) { const std::size_t remaining = (digits - m + w%m) % m; base_unsigned u = generate_one_digit(eng, m); r += u & ((base_unsigned(2) << (remaining - 1)) - 1); const RealType mult = RealType(0.5)/RealType(base_unsigned(1) << (remaining - 1)); r *= mult; } return std::make_pair(r, bucket); } template inline std::pair generate_int_float_pair(Engine& eng, boost::mpl::false_) { int bucket = uniform_int_distribution<>(0, (1 << w) - 1)(eng); RealType r = uniform_01()(eng); return std::make_pair(r, bucket); } template inline std::pair generate_int_float_pair(Engine& eng) { typedef typename Engine::result_type base_result; return generate_int_float_pair(eng, boost::is_integral()); } } // namespace detail } // namespace random } // namespace boost #endif // BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP