69 #include <sys/types.h> 76 #if defined(HAVE_SYS_TIME_H) 82 #elif defined HAVE_SYS_SYSCALL_H 83 #include <sys/syscall.h> 97 #define MATRIX_A 0x9908b0dfU 98 #define UMASK 0x80000000U 99 #define LMASK 0x7fffffffU 100 #define MIXBITS(u,v) ( ((u) & UMASK) | ((v) & LMASK) ) 101 #define TWIST(u,v) ((MIXBITS((u),(v)) >> 1) ^ ((v)&1U ? MATRIX_A : 0U)) 112 #define genrand_initialized(mt) ((mt)->next != 0) 113 #define uninit_genrand(mt) ((mt)->next = 0) 120 mt->
state[0] = s & 0xffffffff
U;
121 for (j=1; j<
N; j++) {
122 mt->
state[j] = (1812433253U * (mt->
state[j-1] ^ (mt->
state[j-1] >> 30)) + j);
127 mt->
state[j] &= 0xffffffff;
143 k = (
N>key_length ?
N : key_length);
147 mt->
state[i] &= 0xffffffff
U;
150 if (j>=key_length) j=0;
152 for (k=
N-1; k; k--) {
155 mt->
state[i] &= 0xffffffff
U;
160 mt->
state[0] = 0x80000000
U;
172 for (j=
N-
M+1; --j; p++)
173 *p = p[
M] ^
TWIST(p[0], p[1]);
176 *p = p[
M-
N] ^
TWIST(p[0], p[1]);
193 y ^= (y << 7) & 0x9d2c5680;
194 y ^= (y << 15) & 0xefc60000;
215 return(a*67108864.0+b)*(1.0/9007199254740992.0);
222 genrand_real2(
struct MT *mt)
240 #define DEFAULT_SEED_CNT 4 250 struct MT *mt = &r->
mt;
277 #define SIZEOF_INT32 (31/CHAR_BIT + 1) 284 enum {dig_u = dig-32, dig_r64 = 64-dig, bmask = ~(~0u<<(dig_r64))};
285 #if defined HAVE_UINT128_T 286 const uint128_t m = ((uint128_t)1 << dig) | 1;
287 uint128_t x = ((uint128_t)a << 32) | b;
288 r = (double)(
uint64_t)((x * m) >> 64);
289 #elif defined HAVE_UINT64_T && !(defined _MSC_VER && _MSC_VER <= 1200) 291 (((
uint64_t)b + (a >> dig_u)) >> dig_r64);
295 b = (b >> dig_r64) + (((a >> dig_u) + (b & bmask)) >> dig_r64);
296 r = (double)a * (1 << dig_u) + b;
298 return ldexp(r, -dig);
316 if (ptr != &default_rand)
386 if (sign != 2 && buf[len-1] == 1)
391 if (buf != buf0)
xfree(buf);
423 #define DEFAULT_SEED_LEN (DEFAULT_SEED_CNT * (int)sizeof(int32_t)) 425 #if defined(S_ISCHR) && !defined(DOSISH) 426 # define USE_DEV_URANDOM 1 428 # define USE_DEV_URANDOM 0 451 if (fd < 0)
return -1;
453 if (
fstat(fd, &statbuf) == 0 &&
S_ISCHR(statbuf.st_mode)) {
454 ret = read(fd, seed, size);
457 if (ret < 0 || (
size_t)ret < size)
return -1;
461 # define fill_random_bytes_urandom(seed, size) -1 465 #elif defined(HAVE_ARC4RANDOM_BUF) 469 arc4random_buf(buf, size);
472 #elif defined(_WIN32) 474 release_crypt(
void *p)
477 if (prov && prov != (HCRYPTPROV)INVALID_HANDLE_VALUE) {
478 CryptReleaseContext(prov, 0);
485 static HCRYPTPROV perm_prov;
486 HCRYPTPROV prov = perm_prov, old_prov;
488 if (!CryptAcquireContext(&prov,
NULL,
NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
489 prov = (HCRYPTPROV)INVALID_HANDLE_VALUE;
493 if (prov != (HCRYPTPROV)INVALID_HANDLE_VALUE) {
498 if (prov != (HCRYPTPROV)INVALID_HANDLE_VALUE) {
499 CryptReleaseContext(prov, 0);
504 if (prov == (HCRYPTPROV)INVALID_HANDLE_VALUE)
return -1;
508 #elif defined __linux__ && defined SYS_getrandom 509 #include <linux/random.h> 511 # ifndef GRND_NONBLOCK 512 # define GRND_NONBLOCK 0x0001 523 flags = GRND_NONBLOCK;
525 ret = syscall(SYS_getrandom,
seed,
size, flags);
526 if (
errno == ENOSYS) {
530 if ((
size_t)ret ==
size)
return 0;
535 # define fill_random_bytes_syscall(seed, size, need_secure) -1 542 if (ret == 0)
return ret;
551 size_t len = cnt *
sizeof(*seed);
553 memset(seed, 0, len);
560 #
if SIZEOF_TIME_T > SIZEOF_INT
563 seed[2] ^= getpid() ^ (n++ << 16);
565 #if SIZEOF_VOIDP > SIZEOF_INT 575 if (ptr[len-1] <= 1) {
617 if (n == 0)
return buf;
664 sizeof(*mt->
state), 0,
717 struct MT *mt = &rnd->
mt;
737 sizeof(*mt->
state), 0,
743 mt->
left = (
unsigned int)x;
809 unsigned long val, mask;
811 if (!limit)
return 0;
815 if (0xffffffff < limit) {
820 if ((mask >> (i * 32)) & 0xffffffff) {
833 }
while (limit < val);
847 uint32_t *tmp, *lim_array, *rnd_array;
854 rnd_array = tmp +
len;
861 for (i = len-1; 0 <= i; i--) {
927 return (
unsigned int)x;
977 return ULL2NUM((LONG_LONG)n+1);
979 if (n >= ULONG_MAX) {
989 if (!limit)
return 0;
992 const int n = w > 32 ?
sizeof(
unsigned long) :
sizeof(
uint32_t);
993 const unsigned long mask = ~(~0UL << w);
994 const unsigned long full =
995 (size_t)n >=
sizeof(
unsigned long) ? ~0UL :
997 unsigned long val, bits = 0, rest = 0;
1009 }
while (limit < val);
1049 rnd_array[0] &= mask;
1050 for (i = 0; i <
len; ++i) {
1051 if (lim_array[i] < rnd_array[i])
1053 if (rnd_array[i] < lim_array[i])
1122 if (endp) *endp = end;
1137 if (!max)
return Qnil;
1139 if (restrictive)
return Qnil;
1149 if (restrictive)
return Qnil;
1155 if (max == -1)
return Qnil;
1193 static inline double 1217 if ((max =
FIX2LONG(vmax) - excl) >= 0) {
1241 else if (
isnan(max)) {
1248 return rb_float_new(+(+(+(r - 0.5) * max) * scale) + mid);
1252 else if (max == 0.0 && !excl) {
1340 if (max > 0.0) r *=
max;
1433 if (v !=
Qfalse)
return v;
1437 if (!
NIL_P(v))
return v;
1459 #define SIP_HASH_STREAMING 0 1460 #define sip_hash24 ruby_sip_hash24 1461 #if !defined _WIN32 && !defined BYTE_ORDER 1462 # ifdef WORDS_BIGENDIAN 1463 # define BYTE_ORDER BIG_ENDIAN 1465 # define BYTE_ORDER LITTLE_ENDIAN 1467 # ifndef LITTLE_ENDIAN 1468 # define LITTLE_ENDIAN 1234 1471 # define BIG_ENDIAN 4321 1505 #ifdef HAVE_UINT64_T 1550 struct MT *mt = &r->
mt;
int rb_bigzero_p(VALUE x)
static VALUE random_bytes(VALUE obj, VALUE len)
static unsigned int nlz_long(unsigned long x)
static rb_random_t default_rand
int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
int gettimeofday(struct timeval *, struct timezone *)
#define RUBY_TYPED_FREE_IMMEDIATELY
static VALUE random_s_state(VALUE klass)
void rb_update_max_fd(int fd)
static unsigned long make_mask(unsigned long x)
#define INTEGER_PACK_LSWORD_FIRST
static double random_real(VALUE obj, rb_random_t *rnd, int excl)
static int max(int a, int b)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
static VALUE rand_random_number(int argc, VALUE *argv, VALUE obj)
static void domain_error(void)
#define type_roomof(x, y)
VALUE rb_random_bytes(VALUE obj, long n)
int rb_cloexec_open(const char *pathname, int flags, mode_t mode)
static VALUE rand_random(int argc, VALUE *argv, VALUE obj, rb_random_t *rnd)
#define ATOMIC_PTR_CAS(var, oldval, val)
static VALUE random_copy(VALUE obj, VALUE orig)
#define TypedData_Wrap_Struct(klass, data_type, sval)
#define OBJ_INIT_COPY(obj, orig)
#define TypedData_Get_Struct(obj, type, data_type, sval)
VALUE rb_big_plus(VALUE x, VALUE y)
static VALUE random_raw_seed(VALUE self, VALUE size)
static VALUE random_rand(int argc, VALUE *argv, VALUE obj)
static VALUE random_left(VALUE obj)
uint32_t u32[type_roomof(seed_keys_t, uint32_t)]
void rb_define_private_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
static VALUE limited_big_rand(struct MT *mt, VALUE limit)
static VALUE random_seed(void)
int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
VALUE rb_ary_push(VALUE ary, VALUE item)
static void invalid_argument(VALUE arg0)
static rb_random_t * rand_start(rb_random_t *r)
static void random_mark(void *ptr)
static int fill_random_bytes(void *seed, size_t size, int need_secure)
static VALUE random_equal(VALUE self, VALUE other)
#define INTEGER_PACK_NATIVE_BYTE_ORDER
st_index_t st_hash_start(st_index_t h)
void rb_raise(VALUE exc, const char *fmt,...)
static unsigned int genrand_int32(struct MT *mt)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
void rb_include_module(VALUE klass, VALUE module)
VALUE rb_check_to_float(VALUE)
void rb_gc_mark(VALUE ptr)
static void init_by_array(struct MT *mt, const uint32_t init_key[], int key_length)
#define ATOMIC_PTR_EXCHANGE(var, val)
void rb_define_global_function(const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a global function.
static void random_free(void *ptr)
static void init_seed(struct MT *mt)
static VALUE random_s_left(VALUE klass)
RUBY_EXTERN void explicit_bzero(void *b, size_t len)
#define fill_random_bytes_syscall(seed, size, need_secure)
#define Data_Wrap_Struct(klass, mark, free, sval)
void rb_exc_raise(VALUE mesg)
#define RB_TYPE_P(obj, type)
static size_t random_memsize(const void *ptr)
static void next_state(struct MT *mt)
#define ATOMIC_SET(var, val)
unsigned long long uint64_t
static VALUE rand_range(VALUE obj, rb_random_t *rnd, VALUE range)
RUBY_EXTERN VALUE rb_cObject
static VALUE mt_state(const struct MT *mt)
static VALUE random_init(int argc, VALUE *argv, VALUE obj)
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
int rb_num_negative_p(VALUE)
static VALUE rand_int(VALUE obj, rb_random_t *rnd, VALUE vmax, int restrictive)
static VALUE rb_f_srand(int argc, VALUE *argv, VALUE obj)
unsigned int rb_genrand_int32(void)
unsigned int rb_random_int32(VALUE obj)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
void rb_define_const(VALUE, const char *, VALUE)
rb_atomic_t cnt[RUBY_NSIG]
static const rb_data_type_t random_data_type
void Init_RandomSeedCore(void)
#define ALLOCV_N(type, v, n)
#define range(low, item, hi)
void rb_gc_register_mark_object(VALUE obj)
#define genrand_initialized(mt)
RUBY_EXTERN int isinf(double)
#define uninit_genrand(mt)
VALUE rb_class_new_instance(int, const VALUE *, VALUE)
VALUE rb_integer_unpack(const void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
static VALUE range_values(VALUE vmax, VALUE *begp, VALUE *endp, int *exclp)
st_index_t rb_memhash(const void *ptr, long len)
int int_must_be_32bit_at_least[sizeof(int) *CHAR_BIT< 32 ? -1 :1]
VALUE rb_big_minus(VALUE x, VALUE y)
VALUE rb_funcallv_public(VALUE, ID, int, const VALUE *)
Calls a method.
#define RARRAY_CONST_PTR(a)
static VALUE random_load(VALUE obj, VALUE dump)
void rb_reset_random_seed(void)
static void fill_random_seed(uint32_t *seed, size_t cnt)
VALUE rb_eSystemCallError
static unsigned int random_int32(rb_random_t *rnd)
unsigned char buf[MIME_BUF_SIZE]
#define INTEGER_PACK_MSWORD_FIRST
void rb_check_copyable(VALUE obj, VALUE orig)
int memcmp(const void *s1, const void *s2, size_t len)
unsigned long rb_genrand_ulong_limited(unsigned long limit)
static VALUE random_dump(VALUE obj)
int rb_respond_to(VALUE, ID)
register unsigned int len
VALUE rb_define_module_under(VALUE outer, const char *name)
static double int_pair_to_real_exclusive(uint32_t a, uint32_t b)
static double genrand_real(struct MT *mt)
VALUE rb_check_to_int(VALUE)
static VALUE obj_random_bytes(VALUE obj, void *p, long n)
VALUE rb_equal(VALUE, VALUE)
VALUE rb_big_uminus(VALUE x)
static double float_value(VALUE v)
static VALUE random_alloc(VALUE klass)
double rb_genrand_real(void)
static VALUE init_randomseed(struct MT *mt)
static VALUE genrand_bytes(rb_random_t *rnd, long n)
VALUE rb_big_norm(VALUE x)
static VALUE rb_f_rand(int argc, VALUE *argv, VALUE obj)
static VALUE make_seed_value(uint32_t *ptr, size_t len)
#define fill_random_bytes_urandom(seed, size)
static VALUE rand_init(struct MT *mt, VALUE vseed)
static rb_random_t * get_rnd(VALUE obj)
static unsigned long limited_rand(struct MT *mt, unsigned long limit)
NORETURN(static void domain_error(void))
static VALUE Init_Random_default(void)
static VALUE random_ulong_limited_big(VALUE obj, rb_random_t *rnd, VALUE vmax)
#define TypedData_Make_Struct(klass, type, data_type, sval)
size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret)
static VALUE random_s_rand(int argc, VALUE *argv, VALUE obj)
static void init_genrand(struct MT *mt, unsigned int s)
static VALUE check_random_number(VALUE v, const VALUE *argv)
#define rb_check_frozen(obj)
static struct MT * default_mt(void)
static VALUE ulong_to_num_plus_1(unsigned long n)
static VALUE random_get_seed(VALUE obj)
double rb_random_real(VALUE obj)
static rb_random_t * try_get_rnd(VALUE obj)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
static unsigned long random_ulong_limited(VALUE obj, rb_random_t *rnd, unsigned long limit)
static VALUE random_state(VALUE obj)
static double int_pair_to_real_inclusive(uint32_t a, uint32_t b)
st_index_t rb_hash_start(st_index_t h)
unsigned long rb_random_ulong_limited(VALUE obj, unsigned long limit)
VALUE rb_obj_class(VALUE)
VALUE rb_str_new(const char *, long)