在C++中生成随机双数

Question

如何在C++中的两个双精度值之间生成随机数，这些数字应该看起来像xxxxx，yyyyy。

Answer 1

下面是如何

double fRand(double fMin, double fMax) 
{ 
    double f = (double)rand()/RAND_MAX; 
    return fMin + f * (fMax - fMin); 
} 

记住调用srand（）函数，每个程序启动时正确的种子。

Answer 2

是这样的：

#include <iostream> 
#include <time.h> 

using namespace std; 

int main() 
{ 
    const long max_rand = 1000000L; 
    double x1 = 12.33, x2 = 34.123, x; 

    srandom(time(NULL)); 

    x = x1 + (x2 - x1) * (random() % max_rand)/max_rand; 

    cout << x1 << " <= " << x << " <= " << x2 << endl; 

    return 0; 
} 

Answer 3

这种解决方案需要C++ 11（或TR1）。

#include <random> 

int main() 
{ 
    double lower_bound = 0; 
    double upper_bound = 10000; 
    std::uniform_real_distribution<double> unif(lower_bound,upper_bound); 
    std::default_random_engine re; 
    double a_random_double = unif(re); 

    return 0; 
} 

欲了解更多详情，请参阅约翰D.库克的"Random number generation using C++ TR1"。

另请参见Stroustrup的"Random number generation"。

Answer 4

如果准确性是一个问题，那么您可以通过随机化重要比特来创建具有更精细分级的随机数。我们假设我们想要在0.0到1000.0之间加倍。

在MSVC（12/Win32）上RAND_MAX例如是32767。

如果使用普通rand()/RAND_MAX方案的差距会那么大

1.0/32767.0 * (1000.0 - 0.0) = 0.0305 ... 

在IEE的情况下，754个变量（53显著位）和53位随机尽可能小的随机化空白，为0〜 1000的问题将是

2^-53 * (1000.0 - 0.0) = 1.110e-13 

因此显着降低。

不利的一面是需要4个rand（）调用才能获得随机化的整数（假设是15位的RNG）。

double random_range (double const range_min, double const range_max) 
{ 
    static unsigned long long const mant_mask53(9007199254740991); 
    static double const i_to_d53(1.0/9007199254740992.0); 
    unsigned long long const r((unsigned long long(rand()) | (unsigned long long(rand()) << 15) | (unsigned long long(rand()) << 30) | (unsigned long long(rand()) << 45)) & mant_mask53); 
    return range_min + i_to_d53*double(r)*(range_max-range_min); 
} 

如果尾数或RNG的比特数是未知的各自的值需要在函数内获得。

#include <limits> 
using namespace std; 
double random_range_p (double const range_min, double const range_max) 
{ 
    static unsigned long long const num_mant_bits(numeric_limits<double>::digits), ll_one(1), 
    mant_limit(ll_one << num_mant_bits); 
    static double const i_to_d(1.0/double(mant_limit)); 
    static size_t num_rand_calls, rng_bits; 
    if (num_rand_calls == 0 || rng_bits == 0) 
    { 
    size_t const rand_max(RAND_MAX), one(1); 
    while (rand_max > (one << rng_bits)) 
    { 
     ++rng_bits; 
    } 
    num_rand_calls = size_t(ceil(double(num_mant_bits)/double(rng_bits))); 
    } 
    unsigned long long r(0); 
    for (size_t i=0; i<num_rand_calls; ++i) 
    { 
    r |= (unsigned long long(rand()) << (i*rng_bits)); 
    } 
    r = r & (mant_limit-ll_one); 
    return range_min + i_to_d*double(r)*(range_max-range_min); 
} 

注：我不知道位无符号很长很长（64位）的数量是否比双尾数位的所有平台上或没有编号（53位的IEE 754）更大。 如果不是这种情况，那么包括像if (sizeof(unsigned long long)*8 > num_mant_bits) ...这样的检查可能是“聪明的”。

Answer 5

这段代码直接来自Stroustrup的The C++ Programming Language (4th Edition)，§40。7;它需要C++ 11：

#include <functional> 
#include <random> 

class Rand_double 
{ 
public: 
    Rand_double(double low, double high) 
    :r(std::bind(std::uniform_real_distribution<>(low,high),std::default_random_engine())){} 

    double operator()(){ return r(); } 

private: 
    std::function<double()> r; 
}; 

#include <iostream>  
int main() { 
    // create the random number generator: 
    Rand_double rd{0,0.5}; 

    // print 10 random number between 0 and 0.5 
    for (int i=0;i<10;++i){ 
     std::cout << rd() << ' '; 
    } 
    return 0; 
} 

Answer 6

这应该是高性能，线程安全的，并足够灵活的多种用途：

#include <random> 
#include <iostream> 

template<typename Numeric, typename Generator = std::mt19937> 
Numeric random(Numeric from, Numeric to) 
{ 
    thread_local static Generator gen(std::random_device{}()); 

    using dist_type = typename std::conditional 
    < 
     std::is_integral<Numeric>::value 
     , std::uniform_int_distribution<Numeric> 
     , std::uniform_real_distribution<Numeric> 
    >::type; 

    thread_local static dist_type dist; 

    return dist(gen, typename dist_type::param_type{from, to}); 
} 

int main(int, char*[]) 
{ 
    for(auto i = 0U; i < 20; ++i) 
     std::cout << random<double>(0.0, 0.3) << '\n'; 
} 

Answer 7

• 这是C++

#include "stdafx.h" 
#include "iostream" 
#include "ctime" 

using namespace std; 

double getRandom(double min, double max) 
{ 
    double before = rand() % (int)max + (int)min; 
    double after = (double)rand()/RAND_MAX; 
    double result = before + after; 
    if (result < min || result > max) { 
     result = getRandom(min, max); 
    } 
    return result; 
} 

int main() 
{ 
    srand (time(NULL)); 
    for (int i = 0; i < 100; i++) { 
     double number = getRandom(-1.57079632679, 1.57079632679); 
     cout << number << endl; 
    } 
    system("pause"); 
}