blob: d04459d468a8d94601e53b2c92884bb55292f173 [file] [edit]
#ifndef _random_hpp_INCLUDED
#define _random_hpp_INCLUDED
#include <cassert>
#include <cstdint>
// Random number generator.
namespace CaDiCaL {
class Random {
uint64_t state;
void add (uint64_t a) {
if (!(state += a))
state = 1;
next ();
}
public:
// Without argument use a machine, process and time dependent seed.
//
Random ();
Random (uint64_t seed) : state (seed) {}
void operator= (uint64_t seed) { state = seed; }
Random (const Random &other) : state (other.seed ()) {}
void operator+= (uint64_t a) { add (a); }
uint64_t seed () const { return state; }
uint64_t next () {
state *= 6364136223846793005ul;
state += 1442695040888963407ul;
assert (state);
return state;
}
uint32_t generate () {
next ();
return static_cast<uint32_t> (state >> 32);
}
int generate_int () { return (int) generate (); }
bool generate_bool () { return generate () < 2147483648u; }
// Generate 'double' value in the range '[0,1]' excluding '1'.
//
double generate_double () { return generate () / 4294967295.0; }
// Generate 'int' value in the range '[l,r]'.
//
int pick_int (int l, int r) {
assert (l <= r);
const unsigned delta = 1 + r - (unsigned) l;
unsigned tmp = generate (), scaled;
if (delta) {
const double fraction = tmp / 4294967296.0;
scaled = delta * fraction;
} else
scaled = tmp;
const int res = scaled + l;
assert (l <= res);
assert (res <= r);
return res;
}
int pick_log (int l, int r) {
assert (l <= r);
const unsigned delta = 1 + r - (unsigned) l;
int log_delta = delta ? 0 : 32;
while (log_delta < 32 && (1u << log_delta) < delta)
log_delta++;
const int log_res = pick_int (0, log_delta);
unsigned tmp = generate ();
if (log_res < 32)
tmp &= (1u << log_res) - 1;
if (delta)
tmp %= delta;
const int res = l + tmp;
assert (l <= res), assert (res <= r);
return res;
}
int64_t pick_log64 (int64_t l, int64_t r) {
assert (l <= r);
const uint64_t delta = 1 + r - (unsigned) l;
int64_t log_delta = delta ? 0 : 64;
while (log_delta < 64 && ((uint64_t) 1u << log_delta) < delta)
log_delta++;
const int log_res = pick_int (0, log_delta);
unsigned tmp = generate ();
if (log_res < 64)
tmp &= (((uint64_t) 1) << log_res) - 1;
if (delta)
tmp %= delta;
const int64_t res = l + tmp;
assert (l <= res), assert (res <= r);
return res;
}
// Generate 'double' value in the range '[l,r]'.
//
double pick_double (double l, double r) {
assert (l <= r);
double res = (r - l) * generate_double ();
res += l;
assert (l <= res);
assert (res <= r);
return res;
}
};
} // namespace CaDiCaL
#endif