генерировать случайные двойные числа в 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; 
} 

Для получения более подробной информации см. Раздел «"Random number generation using C++ TR1"» Джона Д. Кука.

См. Также Stroustrup's "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 ... 

В случае ПЭО 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); 
} 

Если число бит для мантиссы или ГСЧА неизвестно должны быть получено в пределах функции соответствующих значений.

#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 бит для ИХ 754) на все платформы или нет. Возможно, было бы «умным» включить проверку, например, if (sizeof(unsigned long long)*8 > num_mant_bits) ..., если это не так.

Answer 5

Этот фрагмент находится прямо от The C++ Programming Language (4th Edition) от Stroustrup, §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"); 
}