generare numeri doppi casuali in c ++

Come generare numeri casuali tra due doppi in c ++, questi numeri dovrebbero apparire come xxxxx, yyyyy.

Ecco come

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

Ricordarsi di chiamare srand () con un seed appropriato ogni volta che si avvia il programma.

[Modifica] Questa risposta è obsoleta poiché C ++ ha la sua libreria casuale nativa non basata su C (vedi risposta di Alessandro Jacopsons), ma questo vale anche per C

Questa soluzione richiede C ++ 11 (o TR1).

 #include  int main() { double lower_bound = 0; double upper_bound = 10000; std::uniform_real_distribution unif(lower_bound,upper_bound); std::default_random_engine re; double a_random_double = unif(re); return 0; } 

Per maggiori dettagli vedi “Generazione di numeri casuali di John D. Cook usando C ++ TR1” .

Vedi anche “Generazione di numeri casuali” di Stroustrup.

Se l’accuratezza è un problema qui puoi creare numeri casuali con una graduazione più fine, randomizzando i bit significativi. Supponiamo di voler avere un doppio tra 0.0 e 1000.0.

Su MSVC (12 / Win32) RAND_MAX è 32767 per esempio.

Se usi lo schema common rand()/RAND_MAX , i tuoi spazi saranno grandi come

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

In caso di doppia variabile IEE 754 (53 bit significativi) e randomizzazione a 53 bit, il divario di randomizzazione più piccolo ansible per il problema da 0 a 1000 sarà

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

e quindi significativamente più bassi.

Lo svantaggio è che saranno necessarie le chiamate a 4 rand () per ottenere il numero integrale randomizzato (assumendo un RNG a 15 bit).

 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); } 

Se il numero di bit per la mantissa o l'RNG è sconosciuto, è necessario ottenere i rispettivi valori all'interno della funzione.

 #include  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::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 

Nota: non so se il numero di bit per unsigned long long (64 bit) sia maggiore del numero di bit a doppia mantissa (53 bit per IEE 754) su tutte le piattaforms o meno. Probabilmente sarebbe "intelligente" includere un controllo come if (sizeof(unsigned long long)*8 > num_mant_bits) ... se questo non è il caso.

Questo frammento è tratto direttamente da The C ++ Programming Language (4a edizione) di Stroustrup, §40.7; richiede C ++ 11:

 #include  #include  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 r; }; #include  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; } 

Questo dovrebbe essere performante, thread-safe e abbastanza flessibile per molti usi:

 #include  #include  template Numeric random(Numeric from, Numeric to) { thread_local static Generator gen(std::random_device{}()); using dist_type = typename std::conditional < std::is_integral::value , std::uniform_int_distribution , std::uniform_real_distribution >::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(0.0, 0.3) << '\n'; } 

qualcosa come questo:

 #include  #include  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; } 
  • Questo è per 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"); }