2000-05-01 05:42:38 -04:00
|
|
|
/**********************************************************************
|
1998-01-16 07:13:05 -05:00
|
|
|
|
|
|
|
random.c -
|
|
|
|
|
|
|
|
$Author$
|
|
|
|
created at: Fri Dec 24 16:39:21 JST 1993
|
|
|
|
|
* encoding.c: provide basic features for M17N.
* parse.y: encoding aware parsing.
* parse.y (pragma_encoding): encoding specification pragma.
* parse.y (rb_intern3): encoding specified symbols.
* string.c (rb_str_length): length based on characters.
for older behavior, bytesize method added.
* string.c (rb_str_index_m): index based on characters. rindex as
well.
* string.c (succ_char): encoding aware succeeding string.
* string.c (rb_str_reverse): reverse based on characters.
* string.c (rb_str_inspect): encoding aware string description.
* string.c (rb_str_upcase_bang): encoding aware case conversion.
downcase, capitalize, swapcase as well.
* string.c (rb_str_tr_bang): tr based on characters. delete,
squeeze, tr_s, count as well.
* string.c (rb_str_split_m): split based on characters.
* string.c (rb_str_each_line): encoding aware each_line.
* string.c (rb_str_each_char): added. iteration based on
characters.
* string.c (rb_str_strip_bang): encoding aware whitespace
stripping. lstrip, rstrip as well.
* string.c (rb_str_justify): encoding aware justifying (ljust,
rjust, center).
* string.c (str_encoding): get encoding attribute from a string.
* re.c (rb_reg_initialize): encoding aware regular expression
* sprintf.c (rb_str_format): formatting (i.e. length count) based
on characters.
* io.c (rb_io_getc): getc to return one-character string.
for older behavior, getbyte method added.
* ext/stringio/stringio.c (strio_getc): ditto.
* io.c (rb_io_ungetc): allow pushing arbitrary string at the
current reading point.
* ext/stringio/stringio.c (strio_ungetc): ditto.
* ext/strscan/strscan.c: encoding support.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@13261 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-08-24 23:29:39 -04:00
|
|
|
Copyright (C) 1993-2007 Yukihiro Matsumoto
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2000-05-01 05:42:38 -04:00
|
|
|
**********************************************************************/
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2009-02-22 09:23:33 -05:00
|
|
|
/*
|
2002-07-26 02:12:39 -04:00
|
|
|
This is based on trimmed version of MT19937. To get the original version,
|
2007-11-08 17:27:54 -05:00
|
|
|
contact <http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html>.
|
2002-07-26 02:12:39 -04:00
|
|
|
|
|
|
|
The original copyright notice follows.
|
|
|
|
|
|
|
|
A C-program for MT19937, with initialization improved 2002/2/10.
|
|
|
|
Coded by Takuji Nishimura and Makoto Matsumoto.
|
|
|
|
This is a faster version by taking Shawn Cokus's optimization,
|
|
|
|
Matthe Bellew's simplification, Isaku Wada's real version.
|
|
|
|
|
2008-08-16 22:43:20 -04:00
|
|
|
Before using, initialize the state by using init_genrand(mt, seed)
|
|
|
|
or init_by_array(mt, init_key, key_length).
|
2002-07-26 02:12:39 -04:00
|
|
|
|
|
|
|
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
|
2009-02-22 09:23:33 -05:00
|
|
|
All rights reserved.
|
2002-07-26 02:12:39 -04:00
|
|
|
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
|
|
modification, are permitted provided that the following conditions
|
|
|
|
are met:
|
|
|
|
|
|
|
|
1. Redistributions of source code must retain the above copyright
|
|
|
|
notice, this list of conditions and the following disclaimer.
|
|
|
|
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
notice, this list of conditions and the following disclaimer in the
|
|
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
|
2009-02-22 09:23:33 -05:00
|
|
|
3. The names of its contributors may not be used to endorse or promote
|
|
|
|
products derived from this software without specific prior written
|
2002-07-26 02:12:39 -04:00
|
|
|
permission.
|
|
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
|
|
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
|
|
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
|
|
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
|
|
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
|
|
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
|
|
|
|
Any feedback is very welcome.
|
|
|
|
http://www.math.keio.ac.jp/matumoto/emt.html
|
|
|
|
email: matumoto@math.keio.ac.jp
|
|
|
|
*/
|
|
|
|
|
2013-06-07 17:01:42 -04:00
|
|
|
#include "internal.h"
|
2010-03-28 20:21:20 -04:00
|
|
|
|
2009-07-10 01:44:08 -04:00
|
|
|
#include <limits.h>
|
2010-03-28 20:21:20 -04:00
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
#include <time.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#ifdef HAVE_FCNTL_H
|
|
|
|
#include <fcntl.h>
|
|
|
|
#endif
|
|
|
|
#include <math.h>
|
|
|
|
#include <errno.h>
|
2013-03-16 01:06:47 -04:00
|
|
|
#if defined(HAVE_SYS_TIME_H)
|
|
|
|
#include <sys/time.h>
|
|
|
|
#endif
|
2010-03-28 20:21:20 -04:00
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
# if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0400
|
|
|
|
# undef _WIN32_WINNT
|
|
|
|
# define _WIN32_WINNT 0x400
|
|
|
|
# undef __WINCRYPT_H__
|
|
|
|
# endif
|
|
|
|
#include <wincrypt.h>
|
2015-02-13 22:01:36 -05:00
|
|
|
#include "ruby_atomic.h"
|
2010-03-28 20:21:20 -04:00
|
|
|
#endif
|
|
|
|
|
2009-07-10 01:44:08 -04:00
|
|
|
typedef int int_must_be_32bit_at_least[sizeof(int) * CHAR_BIT < 32 ? -1 : 1];
|
|
|
|
|
2009-02-22 09:23:33 -05:00
|
|
|
/* Period parameters */
|
2002-07-26 02:12:39 -04:00
|
|
|
#define N 624
|
|
|
|
#define M 397
|
2009-07-10 01:44:08 -04:00
|
|
|
#define MATRIX_A 0x9908b0dfU /* constant vector a */
|
|
|
|
#define UMASK 0x80000000U /* most significant w-r bits */
|
|
|
|
#define LMASK 0x7fffffffU /* least significant r bits */
|
2002-07-26 02:12:39 -04:00
|
|
|
#define MIXBITS(u,v) ( ((u) & UMASK) | ((v) & LMASK) )
|
2010-12-24 23:08:22 -05:00
|
|
|
#define TWIST(u,v) ((MIXBITS((u),(v)) >> 1) ^ ((v)&1U ? MATRIX_A : 0U))
|
2009-07-10 01:44:08 -04:00
|
|
|
|
|
|
|
enum {MT_MAX_STATE = N};
|
2002-07-26 02:12:39 -04:00
|
|
|
|
2008-08-16 22:43:20 -04:00
|
|
|
struct MT {
|
2009-07-10 01:44:08 -04:00
|
|
|
/* assume int is enough to store 32bits */
|
|
|
|
unsigned int state[N]; /* the array for the state vector */
|
|
|
|
unsigned int *next;
|
2008-08-16 22:43:20 -04:00
|
|
|
int left;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define genrand_initialized(mt) ((mt)->next != 0)
|
|
|
|
#define uninit_genrand(mt) ((mt)->next = 0)
|
2002-07-26 02:12:39 -04:00
|
|
|
|
|
|
|
/* initializes state[N] with a seed */
|
|
|
|
static void
|
2009-07-10 01:44:08 -04:00
|
|
|
init_genrand(struct MT *mt, unsigned int s)
|
2002-07-26 02:12:39 -04:00
|
|
|
{
|
|
|
|
int j;
|
2009-07-10 01:44:08 -04:00
|
|
|
mt->state[0] = s & 0xffffffffU;
|
2002-07-26 02:12:39 -04:00
|
|
|
for (j=1; j<N; j++) {
|
2009-07-10 01:44:08 -04:00
|
|
|
mt->state[j] = (1812433253U * (mt->state[j-1] ^ (mt->state[j-1] >> 30)) + j);
|
2002-07-26 02:12:39 -04:00
|
|
|
/* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
|
|
|
|
/* In the previous versions, MSBs of the seed affect */
|
2009-07-16 02:00:35 -04:00
|
|
|
/* only MSBs of the array state[]. */
|
2002-07-26 02:12:39 -04:00
|
|
|
/* 2002/01/09 modified by Makoto Matsumoto */
|
2009-07-10 01:44:08 -04:00
|
|
|
mt->state[j] &= 0xffffffff; /* for >32 bit machines */
|
2002-07-26 02:12:39 -04:00
|
|
|
}
|
2008-08-16 22:43:20 -04:00
|
|
|
mt->left = 1;
|
2009-07-30 08:55:04 -04:00
|
|
|
mt->next = mt->state + N;
|
2002-07-26 02:12:39 -04:00
|
|
|
}
|
|
|
|
|
2005-01-04 12:38:39 -05:00
|
|
|
/* initialize by an array with array-length */
|
|
|
|
/* init_key is the array for initializing keys */
|
|
|
|
/* key_length is its length */
|
|
|
|
/* slight change for C++, 2004/2/26 */
|
|
|
|
static void
|
2009-07-10 01:44:08 -04:00
|
|
|
init_by_array(struct MT *mt, unsigned int init_key[], int key_length)
|
2005-01-04 12:38:39 -05:00
|
|
|
{
|
|
|
|
int i, j, k;
|
2009-07-10 01:44:08 -04:00
|
|
|
init_genrand(mt, 19650218U);
|
2005-01-04 12:38:39 -05:00
|
|
|
i=1; j=0;
|
|
|
|
k = (N>key_length ? N : key_length);
|
|
|
|
for (; k; k--) {
|
2009-07-10 01:44:08 -04:00
|
|
|
mt->state[i] = (mt->state[i] ^ ((mt->state[i-1] ^ (mt->state[i-1] >> 30)) * 1664525U))
|
2005-01-04 12:38:39 -05:00
|
|
|
+ init_key[j] + j; /* non linear */
|
2009-07-10 01:44:08 -04:00
|
|
|
mt->state[i] &= 0xffffffffU; /* for WORDSIZE > 32 machines */
|
2005-01-04 12:38:39 -05:00
|
|
|
i++; j++;
|
2008-08-16 22:43:20 -04:00
|
|
|
if (i>=N) { mt->state[0] = mt->state[N-1]; i=1; }
|
2005-01-04 12:38:39 -05:00
|
|
|
if (j>=key_length) j=0;
|
|
|
|
}
|
|
|
|
for (k=N-1; k; k--) {
|
2009-07-10 01:44:08 -04:00
|
|
|
mt->state[i] = (mt->state[i] ^ ((mt->state[i-1] ^ (mt->state[i-1] >> 30)) * 1566083941U))
|
2005-01-04 12:38:39 -05:00
|
|
|
- i; /* non linear */
|
2009-07-10 01:44:08 -04:00
|
|
|
mt->state[i] &= 0xffffffffU; /* for WORDSIZE > 32 machines */
|
2005-01-04 12:38:39 -05:00
|
|
|
i++;
|
2008-08-16 22:43:20 -04:00
|
|
|
if (i>=N) { mt->state[0] = mt->state[N-1]; i=1; }
|
2005-01-04 12:38:39 -05:00
|
|
|
}
|
|
|
|
|
2009-07-10 01:44:08 -04:00
|
|
|
mt->state[0] = 0x80000000U; /* MSB is 1; assuring non-zero initial array */
|
2005-01-04 12:38:39 -05:00
|
|
|
}
|
|
|
|
|
2002-07-26 02:12:39 -04:00
|
|
|
static void
|
2008-08-16 22:43:20 -04:00
|
|
|
next_state(struct MT *mt)
|
2002-07-26 02:12:39 -04:00
|
|
|
{
|
2009-07-10 01:44:08 -04:00
|
|
|
unsigned int *p = mt->state;
|
2002-07-26 02:12:39 -04:00
|
|
|
int j;
|
|
|
|
|
2008-08-16 22:43:20 -04:00
|
|
|
mt->left = N;
|
|
|
|
mt->next = mt->state;
|
2002-07-26 02:12:39 -04:00
|
|
|
|
2008-08-16 22:43:20 -04:00
|
|
|
for (j=N-M+1; --j; p++)
|
2002-07-26 02:12:39 -04:00
|
|
|
*p = p[M] ^ TWIST(p[0], p[1]);
|
|
|
|
|
2008-08-16 22:43:20 -04:00
|
|
|
for (j=M; --j; p++)
|
2002-07-26 02:12:39 -04:00
|
|
|
*p = p[M-N] ^ TWIST(p[0], p[1]);
|
|
|
|
|
2008-08-16 22:43:20 -04:00
|
|
|
*p = p[M-N] ^ TWIST(p[0], mt->state[0]);
|
2002-07-26 02:12:39 -04:00
|
|
|
}
|
|
|
|
|
2005-01-04 12:38:39 -05:00
|
|
|
/* generates a random number on [0,0xffffffff]-interval */
|
2009-07-10 01:44:08 -04:00
|
|
|
static unsigned int
|
2008-08-16 22:43:20 -04:00
|
|
|
genrand_int32(struct MT *mt)
|
2002-07-26 02:12:39 -04:00
|
|
|
{
|
2010-03-15 01:06:11 -04:00
|
|
|
/* mt must be initialized */
|
2009-07-10 01:44:08 -04:00
|
|
|
unsigned int y;
|
2002-07-26 02:12:39 -04:00
|
|
|
|
2008-08-16 22:43:20 -04:00
|
|
|
if (--mt->left <= 0) next_state(mt);
|
|
|
|
y = *mt->next++;
|
2002-07-26 02:12:39 -04:00
|
|
|
|
|
|
|
/* Tempering */
|
|
|
|
y ^= (y >> 11);
|
2009-07-10 01:44:08 -04:00
|
|
|
y ^= (y << 7) & 0x9d2c5680;
|
|
|
|
y ^= (y << 15) & 0xefc60000;
|
2002-07-26 02:12:39 -04:00
|
|
|
y ^= (y >> 18);
|
|
|
|
|
2005-01-04 12:38:39 -05:00
|
|
|
return y;
|
2002-07-26 02:12:39 -04:00
|
|
|
}
|
|
|
|
|
2005-01-04 12:38:39 -05:00
|
|
|
/* generates a random number on [0,1) with 53-bit resolution*/
|
2015-02-13 22:20:04 -05:00
|
|
|
static double int_pair_to_real_exclusive(uint32_t a, uint32_t b);
|
2007-12-24 03:19:28 -05:00
|
|
|
static double
|
2008-08-16 22:43:20 -04:00
|
|
|
genrand_real(struct MT *mt)
|
|
|
|
{
|
2010-03-15 01:06:11 -04:00
|
|
|
/* mt must be initialized */
|
2015-02-13 22:20:04 -05:00
|
|
|
unsigned int a = genrand_int32(mt), b = genrand_int32(mt);
|
|
|
|
return int_pair_to_real_exclusive(a, b);
|
|
|
|
}
|
|
|
|
|
|
|
|
static double
|
|
|
|
int_pair_to_real_exclusive(uint32_t a, uint32_t b)
|
|
|
|
{
|
|
|
|
a >>= 5;
|
|
|
|
b >>= 6;
|
2008-08-16 22:43:20 -04:00
|
|
|
return(a*67108864.0+b)*(1.0/9007199254740992.0);
|
|
|
|
}
|
2009-08-26 06:20:30 -04:00
|
|
|
|
|
|
|
/* generates a random number on [0,1] with 53-bit resolution*/
|
2013-06-07 20:50:40 -04:00
|
|
|
static double int_pair_to_real_inclusive(uint32_t a, uint32_t b);
|
2015-02-13 22:20:04 -05:00
|
|
|
#if 0
|
2009-08-26 06:20:30 -04:00
|
|
|
static double
|
|
|
|
genrand_real2(struct MT *mt)
|
|
|
|
{
|
2010-03-15 01:06:11 -04:00
|
|
|
/* mt must be initialized */
|
2013-06-07 20:50:40 -04:00
|
|
|
uint32_t a = genrand_int32(mt), b = genrand_int32(mt);
|
2009-08-26 06:20:30 -04:00
|
|
|
return int_pair_to_real_inclusive(a, b);
|
|
|
|
}
|
2015-02-13 22:20:04 -05:00
|
|
|
#endif
|
2009-08-26 06:20:30 -04:00
|
|
|
|
2005-01-04 12:38:39 -05:00
|
|
|
/* These real versions are due to Isaku Wada, 2002/01/09 added */
|
|
|
|
|
2002-07-26 02:56:30 -04:00
|
|
|
#undef N
|
|
|
|
#undef M
|
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
typedef struct {
|
|
|
|
VALUE seed;
|
|
|
|
struct MT mt;
|
|
|
|
} rb_random_t;
|
2008-08-16 22:43:20 -04:00
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
#define DEFAULT_SEED_CNT 4
|
2008-08-16 22:43:20 -04:00
|
|
|
|
2010-03-15 05:33:39 -04:00
|
|
|
static rb_random_t default_rand;
|
2008-08-16 22:43:20 -04:00
|
|
|
|
2010-03-14 23:26:29 -04:00
|
|
|
static VALUE rand_init(struct MT *mt, VALUE vseed);
|
|
|
|
static VALUE random_seed(void);
|
|
|
|
|
2010-08-25 18:30:03 -04:00
|
|
|
static rb_random_t *
|
|
|
|
rand_start(rb_random_t *r)
|
2010-03-14 23:26:29 -04:00
|
|
|
{
|
2010-03-15 01:06:11 -04:00
|
|
|
struct MT *mt = &r->mt;
|
|
|
|
if (!genrand_initialized(mt)) {
|
|
|
|
r->seed = rand_init(mt, random_seed());
|
|
|
|
}
|
2010-08-25 18:30:03 -04:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct MT *
|
|
|
|
default_mt(void)
|
|
|
|
{
|
|
|
|
return &rand_start(&default_rand)->mt;
|
2010-03-14 23:26:29 -04:00
|
|
|
}
|
|
|
|
|
2009-07-17 20:16:25 -04:00
|
|
|
unsigned int
|
2007-12-24 03:19:28 -05:00
|
|
|
rb_genrand_int32(void)
|
|
|
|
{
|
2010-03-15 01:06:11 -04:00
|
|
|
struct MT *mt = default_mt();
|
2010-03-14 23:26:29 -04:00
|
|
|
return genrand_int32(mt);
|
2007-12-24 03:19:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
rb_genrand_real(void)
|
|
|
|
{
|
2010-03-15 01:06:11 -04:00
|
|
|
struct MT *mt = default_mt();
|
2010-03-14 23:26:29 -04:00
|
|
|
return genrand_real(mt);
|
2007-12-24 03:19:28 -05:00
|
|
|
}
|
|
|
|
|
2009-07-10 01:44:08 -04:00
|
|
|
#define SIZEOF_INT32 (31/CHAR_BIT + 1)
|
|
|
|
|
2009-08-26 06:20:30 -04:00
|
|
|
static double
|
2013-06-07 20:50:40 -04:00
|
|
|
int_pair_to_real_inclusive(uint32_t a, uint32_t b)
|
2009-08-26 06:20:30 -04:00
|
|
|
{
|
2013-06-07 20:50:40 -04:00
|
|
|
VALUE x;
|
|
|
|
VALUE m;
|
|
|
|
uint32_t xary[2], mary[2];
|
2009-08-26 06:20:30 -04:00
|
|
|
double r;
|
|
|
|
|
2013-06-07 20:50:40 -04:00
|
|
|
/* (a << 32) | b */
|
|
|
|
xary[0] = a;
|
|
|
|
xary[1] = b;
|
2013-06-11 17:39:55 -04:00
|
|
|
x = rb_integer_unpack(xary, 2, sizeof(uint32_t), 0,
|
2013-06-08 02:00:04 -04:00
|
|
|
INTEGER_PACK_MSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER|
|
|
|
|
INTEGER_PACK_FORCE_BIGNUM);
|
2013-06-07 20:50:40 -04:00
|
|
|
|
|
|
|
/* (1 << 53) | 1 */
|
|
|
|
mary[0] = 0x00200000;
|
|
|
|
mary[1] = 0x00000001;
|
2013-06-11 17:39:55 -04:00
|
|
|
m = rb_integer_unpack(mary, 2, sizeof(uint32_t), 0,
|
2013-06-08 02:00:04 -04:00
|
|
|
INTEGER_PACK_MSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER|
|
|
|
|
INTEGER_PACK_FORCE_BIGNUM);
|
2013-06-07 20:50:40 -04:00
|
|
|
|
2013-06-08 02:00:04 -04:00
|
|
|
x = rb_big_mul(x, m);
|
2009-08-26 06:20:30 -04:00
|
|
|
if (FIXNUM_P(x)) {
|
|
|
|
#if CHAR_BIT * SIZEOF_LONG > 64
|
|
|
|
r = (double)(FIX2ULONG(x) >> 64);
|
|
|
|
#else
|
|
|
|
return 0.0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
else {
|
2013-06-07 22:18:14 -04:00
|
|
|
uint32_t uary[4];
|
2013-06-10 06:37:39 -04:00
|
|
|
rb_integer_pack(x, uary, numberof(uary), sizeof(uint32_t), 0,
|
2013-06-07 22:18:14 -04:00
|
|
|
INTEGER_PACK_MSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
|
|
|
|
/* r = x >> 64 */
|
|
|
|
r = (double)uary[0] * (0x10000 * (double)0x10000) + (double)uary[1];
|
2009-08-26 06:20:30 -04:00
|
|
|
}
|
|
|
|
return ldexp(r, -53);
|
|
|
|
}
|
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
VALUE rb_cRandom;
|
|
|
|
#define id_minus '-'
|
|
|
|
#define id_plus '+'
|
2010-08-23 18:07:39 -04:00
|
|
|
static ID id_rand, id_bytes;
|
2009-07-16 02:00:35 -04:00
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static void
|
|
|
|
random_mark(void *ptr)
|
|
|
|
{
|
|
|
|
rb_gc_mark(((rb_random_t *)ptr)->seed);
|
|
|
|
}
|
|
|
|
|
2010-08-03 08:16:06 -04:00
|
|
|
static void
|
|
|
|
random_free(void *ptr)
|
|
|
|
{
|
|
|
|
if (ptr != &default_rand)
|
|
|
|
xfree(ptr);
|
|
|
|
}
|
2009-07-16 02:00:35 -04:00
|
|
|
|
|
|
|
static size_t
|
2009-09-08 22:11:35 -04:00
|
|
|
random_memsize(const void *ptr)
|
2009-07-16 02:00:35 -04:00
|
|
|
{
|
|
|
|
return ptr ? sizeof(rb_random_t) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const rb_data_type_t random_data_type = {
|
|
|
|
"random",
|
2010-07-18 03:31:54 -04:00
|
|
|
{
|
|
|
|
random_mark,
|
|
|
|
random_free,
|
|
|
|
random_memsize,
|
|
|
|
},
|
2014-12-01 01:38:04 -05:00
|
|
|
0, 0, RUBY_TYPED_FREE_IMMEDIATELY
|
2009-07-16 02:00:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
static rb_random_t *
|
|
|
|
get_rnd(VALUE obj)
|
|
|
|
{
|
|
|
|
rb_random_t *ptr;
|
|
|
|
TypedData_Get_Struct(obj, rb_random_t, &random_data_type, ptr);
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
2010-08-23 18:07:39 -04:00
|
|
|
static rb_random_t *
|
|
|
|
try_get_rnd(VALUE obj)
|
|
|
|
{
|
2010-08-25 18:30:03 -04:00
|
|
|
if (obj == rb_cRandom) {
|
|
|
|
return rand_start(&default_rand);
|
|
|
|
}
|
2010-08-23 18:07:39 -04:00
|
|
|
if (!rb_typeddata_is_kind_of(obj, &random_data_type)) return NULL;
|
|
|
|
return DATA_PTR(obj);
|
|
|
|
}
|
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
random_alloc(VALUE klass)
|
|
|
|
{
|
|
|
|
rb_random_t *rnd;
|
2010-03-15 05:33:39 -04:00
|
|
|
VALUE obj = TypedData_Make_Struct(klass, rb_random_t, &random_data_type, rnd);
|
2009-07-16 02:00:35 -04:00
|
|
|
rnd->seed = INT2FIX(0);
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2005-01-04 12:38:39 -05:00
|
|
|
static VALUE
|
2008-08-16 22:43:20 -04:00
|
|
|
rand_init(struct MT *mt, VALUE vseed)
|
2000-01-08 00:00:25 -05:00
|
|
|
{
|
2005-01-04 12:38:39 -05:00
|
|
|
volatile VALUE seed;
|
2013-06-08 02:46:45 -04:00
|
|
|
uint32_t buf0[SIZEOF_LONG / SIZEOF_INT32 * 4], *buf = buf0;
|
|
|
|
size_t len;
|
|
|
|
int sign;
|
2000-01-08 00:00:25 -05:00
|
|
|
|
2005-01-04 12:38:39 -05:00
|
|
|
seed = rb_to_int(vseed);
|
2013-06-08 02:46:45 -04:00
|
|
|
|
2013-06-09 03:53:20 -04:00
|
|
|
len = rb_absint_numwords(seed, 32, NULL);
|
2013-06-08 02:46:45 -04:00
|
|
|
if (len > numberof(buf0))
|
|
|
|
buf = ALLOC_N(unsigned int, len);
|
2013-06-10 06:37:39 -04:00
|
|
|
sign = rb_integer_pack(seed, buf, len, sizeof(uint32_t), 0,
|
2013-06-08 02:46:45 -04:00
|
|
|
INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
|
|
|
|
if (sign < 0)
|
|
|
|
sign = -sign;
|
|
|
|
if (len == 0) {
|
|
|
|
buf[0] = 0;
|
|
|
|
len = 1;
|
2005-01-04 12:38:39 -05:00
|
|
|
}
|
|
|
|
if (len <= 1) {
|
2008-08-16 22:43:20 -04:00
|
|
|
init_genrand(mt, buf[0]);
|
2005-01-04 12:38:39 -05:00
|
|
|
}
|
|
|
|
else {
|
2013-06-08 02:46:45 -04:00
|
|
|
if (sign != 2 && buf[len-1] == 1) /* remove leading-zero-guard */
|
2005-01-04 12:38:39 -05:00
|
|
|
len--;
|
2013-06-08 03:01:19 -04:00
|
|
|
init_by_array(mt, buf, (int)len);
|
2005-01-04 12:38:39 -05:00
|
|
|
}
|
2009-07-11 13:24:46 -04:00
|
|
|
if (buf != buf0) xfree(buf);
|
2008-08-16 22:43:20 -04:00
|
|
|
return seed;
|
2000-01-08 00:00:25 -05:00
|
|
|
}
|
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
/*
|
2011-10-05 19:54:33 -04:00
|
|
|
* call-seq:
|
2012-04-18 20:35:32 -04:00
|
|
|
* Random.new(seed = Random.new_seed) -> prng
|
2009-07-16 02:00:35 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Creates a new PRNG using +seed+ to set the initial state. If +seed+ is
|
|
|
|
* omitted, the generator is initialized with Random.new_seed.
|
2009-07-16 02:00:35 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* See Random.srand for more information on the use of seed values.
|
2009-07-16 02:00:35 -04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
random_init(int argc, VALUE *argv, VALUE obj)
|
|
|
|
{
|
|
|
|
VALUE vseed;
|
|
|
|
rb_random_t *rnd = get_rnd(obj);
|
|
|
|
|
|
|
|
if (argc == 0) {
|
2012-06-22 00:36:54 -04:00
|
|
|
rb_check_frozen(obj);
|
2009-07-16 02:00:35 -04:00
|
|
|
vseed = random_seed();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
rb_scan_args(argc, argv, "01", &vseed);
|
2012-06-22 00:36:54 -04:00
|
|
|
rb_check_copyable(obj, vseed);
|
2009-07-16 02:00:35 -04:00
|
|
|
}
|
|
|
|
rnd->seed = rand_init(&rnd->mt, vseed);
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2013-06-08 03:40:03 -04:00
|
|
|
#define DEFAULT_SEED_LEN (DEFAULT_SEED_CNT * (int)sizeof(int32_t))
|
2008-06-19 22:46:17 -04:00
|
|
|
|
2009-07-17 00:58:38 -04:00
|
|
|
#if defined(S_ISCHR) && !defined(DOSISH)
|
|
|
|
# define USE_DEV_URANDOM 1
|
|
|
|
#else
|
|
|
|
# define USE_DEV_URANDOM 0
|
|
|
|
#endif
|
|
|
|
|
2015-02-13 22:01:36 -05:00
|
|
|
#if defined(_WIN32)
|
2008-06-19 22:46:17 -04:00
|
|
|
static void
|
2015-02-13 22:01:36 -05:00
|
|
|
release_crypt(void *p)
|
2002-07-26 02:12:39 -04:00
|
|
|
{
|
2015-02-13 22:01:36 -05:00
|
|
|
HCRYPTPROV prov = (HCRYPTPROV)ATOMIC_PTR_EXCHANGE(*(HCRYPTPROV *)p, INVALID_HANDLE_VALUE);
|
|
|
|
if (prov && prov != (HCRYPTPROV)INVALID_HANDLE_VALUE) {
|
|
|
|
CryptReleaseContext(prov, 0);
|
|
|
|
}
|
|
|
|
}
|
2009-03-11 16:14:51 -04:00
|
|
|
#endif
|
2005-01-05 06:31:41 -05:00
|
|
|
|
2015-02-13 22:01:36 -05:00
|
|
|
static int
|
|
|
|
fill_random_bytes(void *seed, size_t size)
|
|
|
|
{
|
2009-07-17 00:58:38 -04:00
|
|
|
#if USE_DEV_URANDOM
|
2015-02-13 22:01:36 -05:00
|
|
|
int fd = rb_cloexec_open("/dev/urandom",
|
|
|
|
# ifdef O_NONBLOCK
|
|
|
|
O_NONBLOCK|
|
|
|
|
# endif
|
|
|
|
# ifdef O_NOCTTY
|
|
|
|
O_NOCTTY|
|
|
|
|
# endif
|
|
|
|
O_RDONLY, 0);
|
|
|
|
struct stat statbuf;
|
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
if (fd < 0) return -1;
|
|
|
|
rb_update_max_fd(fd);
|
|
|
|
if (fstat(fd, &statbuf) == 0 && S_ISCHR(statbuf.st_mode)) {
|
|
|
|
ret = read(fd, seed, size);
|
2005-01-02 21:41:03 -05:00
|
|
|
}
|
2015-02-13 22:01:36 -05:00
|
|
|
close(fd);
|
|
|
|
if (ret < 0 || (size_t)ret < size) return -1;
|
2009-07-17 20:07:07 -04:00
|
|
|
#elif defined(_WIN32)
|
2015-02-13 22:01:36 -05:00
|
|
|
static HCRYPTPROV perm_prov;
|
|
|
|
HCRYPTPROV prov = perm_prov, old_prov;
|
|
|
|
if (!prov) {
|
|
|
|
if (!CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
|
|
|
|
prov = (HCRYPTPROV)INVALID_HANDLE_VALUE;
|
|
|
|
}
|
2015-03-18 21:31:03 -04:00
|
|
|
old_prov = (HCRYPTPROV)ATOMIC_PTR_CAS(perm_prov, 0, prov);
|
2015-06-25 02:32:23 -04:00
|
|
|
if (LIKELY(!old_prov)) { /* no other threads acquried */
|
|
|
|
if (prov != (HCRYPTPROV)INVALID_HANDLE_VALUE) {
|
2015-03-18 21:31:03 -04:00
|
|
|
rb_gc_register_mark_object(Data_Wrap_Struct(0, 0, release_crypt, &perm_prov));
|
2015-02-13 22:01:36 -05:00
|
|
|
}
|
2015-06-25 02:32:23 -04:00
|
|
|
}
|
|
|
|
else { /* another thread acquried */
|
|
|
|
if (prov != (HCRYPTPROV)INVALID_HANDLE_VALUE) {
|
2015-02-13 22:01:36 -05:00
|
|
|
CryptReleaseContext(prov, 0);
|
|
|
|
}
|
2015-06-25 02:32:23 -04:00
|
|
|
prov = old_prov;
|
2015-02-13 22:01:36 -05:00
|
|
|
}
|
2009-07-17 20:07:07 -04:00
|
|
|
}
|
2015-02-13 22:01:36 -05:00
|
|
|
if (prov == (HCRYPTPROV)INVALID_HANDLE_VALUE) return -1;
|
|
|
|
CryptGenRandom(prov, size, seed);
|
2005-01-03 00:13:18 -05:00
|
|
|
#endif
|
2015-02-13 22:01:36 -05:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
fill_random_seed(uint32_t seed[DEFAULT_SEED_CNT])
|
|
|
|
{
|
|
|
|
static int n = 0;
|
|
|
|
struct timeval tv;
|
|
|
|
|
|
|
|
memset(seed, 0, DEFAULT_SEED_LEN);
|
|
|
|
|
|
|
|
fill_random_bytes(seed, sizeof(*seed));
|
2005-01-02 21:41:03 -05:00
|
|
|
|
2005-01-05 06:31:41 -05:00
|
|
|
gettimeofday(&tv, 0);
|
|
|
|
seed[0] ^= tv.tv_usec;
|
2014-07-09 10:51:26 -04:00
|
|
|
seed[1] ^= (uint32_t)tv.tv_sec;
|
2009-07-10 01:44:08 -04:00
|
|
|
#if SIZEOF_TIME_T > SIZEOF_INT
|
2014-07-09 10:51:26 -04:00
|
|
|
seed[0] ^= (uint32_t)((time_t)tv.tv_sec >> SIZEOF_INT * CHAR_BIT);
|
2009-07-10 01:44:08 -04:00
|
|
|
#endif
|
2005-01-05 06:31:41 -05:00
|
|
|
seed[2] ^= getpid() ^ (n++ << 16);
|
2014-07-09 10:51:26 -04:00
|
|
|
seed[3] ^= (uint32_t)(VALUE)&seed;
|
2009-07-10 01:44:08 -04:00
|
|
|
#if SIZEOF_VOIDP > SIZEOF_INT
|
2014-07-09 10:51:26 -04:00
|
|
|
seed[2] ^= (uint32_t)((VALUE)&seed >> SIZEOF_INT * CHAR_BIT);
|
2009-07-10 01:44:08 -04:00
|
|
|
#endif
|
2008-06-19 22:46:17 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2013-06-08 03:40:03 -04:00
|
|
|
make_seed_value(const uint32_t *ptr)
|
2008-06-19 22:46:17 -04:00
|
|
|
{
|
2013-06-08 03:40:03 -04:00
|
|
|
VALUE seed;
|
|
|
|
size_t len;
|
2013-10-02 08:41:08 -04:00
|
|
|
uint32_t buf[DEFAULT_SEED_CNT+1];
|
2008-06-19 22:46:17 -04:00
|
|
|
|
2013-06-08 03:40:03 -04:00
|
|
|
if (ptr[DEFAULT_SEED_CNT-1] <= 1) {
|
|
|
|
/* set leading-zero-guard */
|
|
|
|
MEMCPY(buf, ptr, uint32_t, DEFAULT_SEED_CNT);
|
|
|
|
buf[DEFAULT_SEED_CNT] = 1;
|
|
|
|
ptr = buf;
|
|
|
|
len = DEFAULT_SEED_CNT+1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
len = DEFAULT_SEED_CNT;
|
|
|
|
}
|
2005-01-05 06:31:41 -05:00
|
|
|
|
2013-06-11 17:39:55 -04:00
|
|
|
seed = rb_integer_unpack(ptr, len, sizeof(uint32_t), 0,
|
2013-06-08 03:40:03 -04:00
|
|
|
INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
|
2005-01-04 12:38:39 -05:00
|
|
|
|
2013-06-08 03:40:03 -04:00
|
|
|
return seed;
|
2002-07-26 02:12:39 -04:00
|
|
|
}
|
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
/*
|
2010-03-03 10:14:21 -05:00
|
|
|
* call-seq: Random.new_seed -> integer
|
2009-07-16 02:00:35 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Returns an arbitrary seed value. This is used by Random.new
|
|
|
|
* when no seed value is specified as an argument.
|
|
|
|
*
|
|
|
|
* Random.new_seed #=> 115032730400174366788466674494640623225
|
2009-07-16 02:00:35 -04:00
|
|
|
*/
|
2008-06-19 22:46:17 -04:00
|
|
|
static VALUE
|
|
|
|
random_seed(void)
|
|
|
|
{
|
2013-06-08 03:40:03 -04:00
|
|
|
uint32_t buf[DEFAULT_SEED_CNT];
|
2008-06-19 22:46:17 -04:00
|
|
|
fill_random_seed(buf);
|
|
|
|
return make_seed_value(buf);
|
|
|
|
}
|
|
|
|
|
2015-02-13 22:01:36 -05:00
|
|
|
/*
|
|
|
|
* call-seq: Random.raw_seed(size) -> string
|
|
|
|
*
|
|
|
|
* Returns a raw seed string, using platform providing features.
|
|
|
|
*
|
|
|
|
* Random.raw_seed(8) #=> "\x78\x41\xBA\xAF\x7D\xEA\xD8\xEA"
|
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
random_raw_seed(VALUE self, VALUE size)
|
|
|
|
{
|
|
|
|
long n = NUM2ULONG(size);
|
|
|
|
VALUE buf = rb_str_new(0, n);
|
2015-03-04 18:44:59 -05:00
|
|
|
if (n == 0) return buf;
|
2015-02-13 22:01:36 -05:00
|
|
|
if (fill_random_bytes(RSTRING_PTR(buf), n)) return Qnil;
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
/*
|
|
|
|
* call-seq: prng.seed -> integer
|
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Returns the seed value used to initialize the generator. This may be used to
|
|
|
|
* initialize another generator with the same state at a later time, causing it
|
|
|
|
* to produce the same sequence of numbers.
|
|
|
|
*
|
|
|
|
* prng1 = Random.new(1234)
|
|
|
|
* prng1.seed #=> 1234
|
|
|
|
* prng1.rand(100) #=> 47
|
|
|
|
*
|
|
|
|
* prng2 = Random.new(prng1.seed)
|
|
|
|
* prng2.rand(100) #=> 47
|
2009-07-16 02:00:35 -04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
random_get_seed(VALUE obj)
|
|
|
|
{
|
|
|
|
return get_rnd(obj)->seed;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
random_copy(VALUE obj, VALUE orig)
|
|
|
|
{
|
2012-06-05 07:13:18 -04:00
|
|
|
rb_random_t *rnd1, *rnd2;
|
|
|
|
struct MT *mt;
|
|
|
|
|
|
|
|
if (!OBJ_INIT_COPY(obj, orig)) return obj;
|
|
|
|
|
|
|
|
rnd1 = get_rnd(obj);
|
|
|
|
rnd2 = get_rnd(orig);
|
|
|
|
mt = &rnd1->mt;
|
2009-07-16 02:00:35 -04:00
|
|
|
|
|
|
|
*rnd1 = *rnd2;
|
|
|
|
mt->next = mt->state + numberof(mt->state) - mt->left + 1;
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
mt_state(const struct MT *mt)
|
|
|
|
{
|
2013-06-11 17:39:55 -04:00
|
|
|
return rb_integer_unpack(mt->state, numberof(mt->state),
|
2013-06-07 17:01:42 -04:00
|
|
|
sizeof(*mt->state), 0,
|
|
|
|
INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
|
2009-07-16 02:00:35 -04:00
|
|
|
}
|
|
|
|
|
2009-07-22 19:52:20 -04:00
|
|
|
/* :nodoc: */
|
2009-07-16 02:00:35 -04:00
|
|
|
static VALUE
|
|
|
|
random_state(VALUE obj)
|
|
|
|
{
|
|
|
|
rb_random_t *rnd = get_rnd(obj);
|
|
|
|
return mt_state(&rnd->mt);
|
|
|
|
}
|
|
|
|
|
2009-07-22 19:52:20 -04:00
|
|
|
/* :nodoc: */
|
2009-07-16 02:00:35 -04:00
|
|
|
static VALUE
|
|
|
|
random_s_state(VALUE klass)
|
|
|
|
{
|
2010-03-15 05:33:39 -04:00
|
|
|
return mt_state(&default_rand.mt);
|
2009-07-16 02:00:35 -04:00
|
|
|
}
|
|
|
|
|
2009-07-22 19:52:20 -04:00
|
|
|
/* :nodoc: */
|
2009-07-16 02:00:35 -04:00
|
|
|
static VALUE
|
|
|
|
random_left(VALUE obj)
|
|
|
|
{
|
|
|
|
rb_random_t *rnd = get_rnd(obj);
|
|
|
|
return INT2FIX(rnd->mt.left);
|
|
|
|
}
|
|
|
|
|
2009-07-22 19:52:20 -04:00
|
|
|
/* :nodoc: */
|
2009-07-16 02:00:35 -04:00
|
|
|
static VALUE
|
|
|
|
random_s_left(VALUE klass)
|
|
|
|
{
|
2010-03-15 05:33:39 -04:00
|
|
|
return INT2FIX(default_rand.mt.left);
|
2009-07-16 02:00:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
random_dump(VALUE obj)
|
|
|
|
{
|
|
|
|
rb_random_t *rnd = get_rnd(obj);
|
|
|
|
VALUE dump = rb_ary_new2(3);
|
|
|
|
|
|
|
|
rb_ary_push(dump, mt_state(&rnd->mt));
|
|
|
|
rb_ary_push(dump, INT2FIX(rnd->mt.left));
|
|
|
|
rb_ary_push(dump, rnd->seed);
|
|
|
|
|
|
|
|
return dump;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* :nodoc: */
|
|
|
|
static VALUE
|
|
|
|
random_load(VALUE obj, VALUE dump)
|
|
|
|
{
|
|
|
|
rb_random_t *rnd = get_rnd(obj);
|
|
|
|
struct MT *mt = &rnd->mt;
|
|
|
|
VALUE state, left = INT2FIX(1), seed = INT2FIX(0);
|
2013-08-07 00:20:56 -04:00
|
|
|
const VALUE *ary;
|
2009-07-16 02:00:35 -04:00
|
|
|
unsigned long x;
|
|
|
|
|
2012-06-22 00:36:54 -04:00
|
|
|
rb_check_copyable(obj, dump);
|
2009-07-16 02:00:35 -04:00
|
|
|
Check_Type(dump, T_ARRAY);
|
* include/ruby/ruby.h: rename RARRAY_RAWPTR() to RARRAY_CONST_PTR().
RARRAY_RAWPTR(ary) returns (const VALUE *) type pointer and
usecase of this macro is not acquire raw pointer, but acquire
read-only pointer. So we rename to better name.
RSTRUCT_RAWPTR() is also renamed to RSTRUCT_CONST_PTR()
(I expect that nobody use it).
* array.c, compile.c, cont.c, enumerator.c, gc.c, proc.c, random.c,
string.c, struct.c, thread.c, vm_eval.c, vm_insnhelper.c:
catch up this change.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@43043 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-09-25 04:24:34 -04:00
|
|
|
ary = RARRAY_CONST_PTR(dump);
|
2009-07-16 02:00:35 -04:00
|
|
|
switch (RARRAY_LEN(dump)) {
|
|
|
|
case 3:
|
|
|
|
seed = ary[2];
|
|
|
|
case 2:
|
|
|
|
left = ary[1];
|
|
|
|
case 1:
|
|
|
|
state = ary[0];
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
rb_raise(rb_eArgError, "wrong dump data");
|
|
|
|
}
|
2013-06-10 06:37:39 -04:00
|
|
|
rb_integer_pack(state, mt->state, numberof(mt->state),
|
2013-06-07 19:12:55 -04:00
|
|
|
sizeof(*mt->state), 0,
|
|
|
|
INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
|
2009-07-16 02:00:35 -04:00
|
|
|
x = NUM2ULONG(left);
|
|
|
|
if (x > numberof(mt->state)) {
|
|
|
|
rb_raise(rb_eArgError, "wrong value");
|
|
|
|
}
|
|
|
|
mt->left = (unsigned int)x;
|
|
|
|
mt->next = mt->state + numberof(mt->state) - x + 1;
|
|
|
|
rnd->seed = rb_to_int(seed);
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
2003-12-28 15:47:56 -05:00
|
|
|
/*
|
2011-10-05 19:54:33 -04:00
|
|
|
* call-seq:
|
2012-04-18 20:35:32 -04:00
|
|
|
* srand(number = Random.new_seed) -> old_seed
|
2011-10-05 19:54:33 -04:00
|
|
|
*
|
|
|
|
* Seeds the system pseudo-random number generator, Random::DEFAULT, with
|
|
|
|
* +number+. The previous seed value is returned.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* If +number+ is omitted, seeds the generator using a source of entropy
|
|
|
|
* provided by the operating system, if available (/dev/urandom on Unix systems
|
|
|
|
* or the RSA cryptographic provider on Windows), which is then combined with
|
|
|
|
* the time, the process id, and a sequence number.
|
|
|
|
*
|
|
|
|
* srand may be used to ensure repeatable sequences of pseudo-random numbers
|
|
|
|
* between different runs of the program. By setting the seed to a known value,
|
|
|
|
* programs can be made deterministic during testing.
|
|
|
|
*
|
|
|
|
* srand 1234 # => 268519324636777531569100071560086917274
|
|
|
|
* [ rand, rand ] # => [0.1915194503788923, 0.6221087710398319]
|
|
|
|
* [ rand(10), rand(1000) ] # => [4, 664]
|
|
|
|
* srand 1234 # => 1234
|
|
|
|
* [ rand, rand ] # => [0.1915194503788923, 0.6221087710398319]
|
2003-12-28 15:47:56 -05:00
|
|
|
*/
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_f_srand(int argc, VALUE *argv, VALUE obj)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2005-01-04 12:38:39 -05:00
|
|
|
VALUE seed, old;
|
2010-03-15 05:33:39 -04:00
|
|
|
rb_random_t *r = &default_rand;
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2008-03-05 00:22:17 -05:00
|
|
|
if (argc == 0) {
|
2002-07-26 02:12:39 -04:00
|
|
|
seed = random_seed();
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
2008-03-05 00:22:17 -05:00
|
|
|
else {
|
|
|
|
rb_scan_args(argc, argv, "01", &seed);
|
|
|
|
}
|
2010-03-15 05:33:39 -04:00
|
|
|
old = r->seed;
|
|
|
|
r->seed = rand_init(&r->mt, seed);
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2005-01-04 12:38:39 -05:00
|
|
|
return old;
|
|
|
|
}
|
|
|
|
|
2009-02-22 09:23:33 -05:00
|
|
|
static unsigned long
|
2005-01-04 12:38:39 -05:00
|
|
|
make_mask(unsigned long x)
|
|
|
|
{
|
|
|
|
x = x | x >> 1;
|
|
|
|
x = x | x >> 2;
|
|
|
|
x = x | x >> 4;
|
|
|
|
x = x | x >> 8;
|
|
|
|
x = x | x >> 16;
|
|
|
|
#if 4 < SIZEOF_LONG
|
|
|
|
x = x | x >> 32;
|
|
|
|
#endif
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long
|
2008-08-16 22:43:20 -04:00
|
|
|
limited_rand(struct MT *mt, unsigned long limit)
|
2005-01-04 12:38:39 -05:00
|
|
|
{
|
2010-03-15 01:06:11 -04:00
|
|
|
/* mt must be initialized */
|
2005-01-04 12:38:39 -05:00
|
|
|
int i;
|
2009-08-26 10:58:44 -04:00
|
|
|
unsigned long val, mask;
|
2005-01-04 12:38:39 -05:00
|
|
|
|
2009-08-26 10:58:44 -04:00
|
|
|
if (!limit) return 0;
|
|
|
|
mask = make_mask(limit);
|
2005-01-04 12:38:39 -05:00
|
|
|
retry:
|
|
|
|
val = 0;
|
2009-07-16 02:00:35 -04:00
|
|
|
for (i = SIZEOF_LONG/SIZEOF_INT32-1; 0 <= i; i--) {
|
2009-07-10 13:37:52 -04:00
|
|
|
if ((mask >> (i * 32)) & 0xffffffff) {
|
|
|
|
val |= (unsigned long)genrand_int32(mt) << (i * 32);
|
2005-01-04 12:38:39 -05:00
|
|
|
val &= mask;
|
|
|
|
if (limit < val)
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2013-06-08 06:05:37 -04:00
|
|
|
limited_big_rand(struct MT *mt, VALUE limit)
|
2005-01-04 12:38:39 -05:00
|
|
|
{
|
2010-03-15 01:06:11 -04:00
|
|
|
/* mt must be initialized */
|
2013-06-08 06:05:37 -04:00
|
|
|
|
2013-06-08 06:33:05 -04:00
|
|
|
uint32_t mask;
|
2013-06-08 06:05:37 -04:00
|
|
|
long i;
|
2009-07-10 01:44:08 -04:00
|
|
|
int boundary;
|
2005-01-04 12:38:39 -05:00
|
|
|
|
2013-06-08 06:05:37 -04:00
|
|
|
size_t len;
|
|
|
|
uint32_t *tmp, *lim_array, *rnd_array;
|
|
|
|
VALUE vtmp;
|
|
|
|
VALUE val;
|
|
|
|
|
2013-06-09 03:53:20 -04:00
|
|
|
len = rb_absint_numwords(limit, 32, NULL);
|
2013-06-08 06:05:37 -04:00
|
|
|
tmp = ALLOCV_N(uint32_t, vtmp, len*2);
|
|
|
|
lim_array = tmp;
|
|
|
|
rnd_array = tmp + len;
|
2013-06-10 06:37:39 -04:00
|
|
|
rb_integer_pack(limit, lim_array, len, sizeof(uint32_t), 0,
|
2013-06-08 06:05:37 -04:00
|
|
|
INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
|
|
|
|
|
2005-01-04 12:38:39 -05:00
|
|
|
retry:
|
|
|
|
mask = 0;
|
|
|
|
boundary = 1;
|
|
|
|
for (i = len-1; 0 <= i; i--) {
|
2013-06-08 06:33:05 -04:00
|
|
|
uint32_t rnd;
|
|
|
|
uint32_t lim = lim_array[i];
|
|
|
|
mask = mask ? 0xffffffff : (uint32_t)make_mask(lim);
|
2005-01-04 12:38:39 -05:00
|
|
|
if (mask) {
|
2008-08-16 22:43:20 -04:00
|
|
|
rnd = genrand_int32(mt) & mask;
|
2005-01-04 12:38:39 -05:00
|
|
|
if (boundary) {
|
|
|
|
if (lim < rnd)
|
|
|
|
goto retry;
|
|
|
|
if (rnd < lim)
|
|
|
|
boundary = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
rnd = 0;
|
|
|
|
}
|
2013-06-08 06:05:37 -04:00
|
|
|
rnd_array[i] = rnd;
|
2005-01-04 12:38:39 -05:00
|
|
|
}
|
2013-06-11 17:39:55 -04:00
|
|
|
val = rb_integer_unpack(rnd_array, len, sizeof(uint32_t), 0,
|
2013-06-08 06:05:37 -04:00
|
|
|
INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
|
|
|
|
ALLOCV_END(vtmp);
|
|
|
|
|
|
|
|
return val;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2010-09-10 01:44:54 -04:00
|
|
|
/*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Returns random unsigned long value in [0, +limit+].
|
2010-09-10 01:44:54 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Note that +limit+ is included, and the range of the argument and the
|
2010-09-10 01:44:54 -04:00
|
|
|
* return value depends on environments.
|
|
|
|
*/
|
2008-12-13 22:59:02 -05:00
|
|
|
unsigned long
|
2010-09-10 01:44:54 -04:00
|
|
|
rb_genrand_ulong_limited(unsigned long limit)
|
2008-12-13 22:59:02 -05:00
|
|
|
{
|
2010-09-10 01:44:54 -04:00
|
|
|
return limited_rand(default_mt(), limit);
|
2008-12-13 22:59:02 -05:00
|
|
|
}
|
|
|
|
|
2015-02-13 22:20:04 -05:00
|
|
|
static unsigned int
|
|
|
|
random_int32(VALUE obj, rb_random_t *rnd)
|
2009-07-17 20:16:25 -04:00
|
|
|
{
|
2010-08-23 18:07:39 -04:00
|
|
|
if (!rnd) {
|
2010-08-25 18:30:03 -04:00
|
|
|
#if SIZEOF_LONG * CHAR_BIT > 32
|
2012-06-19 17:49:52 -04:00
|
|
|
VALUE lim = ULONG2NUM(0x100000000UL);
|
2010-08-25 18:30:03 -04:00
|
|
|
#elif defined HAVE_LONG_LONG
|
|
|
|
VALUE lim = ULL2NUM((LONG_LONG)0xffffffff+1);
|
|
|
|
#else
|
|
|
|
VALUE lim = rb_big_plus(ULONG2NUM(0xffffffff), INT2FIX(1));
|
|
|
|
#endif
|
2010-08-26 03:41:55 -04:00
|
|
|
return (unsigned int)NUM2ULONG(rb_funcall2(obj, id_rand, 1, &lim));
|
2010-08-23 18:07:39 -04:00
|
|
|
}
|
2009-07-17 20:16:25 -04:00
|
|
|
return genrand_int32(&rnd->mt);
|
|
|
|
}
|
|
|
|
|
2015-02-13 22:20:04 -05:00
|
|
|
unsigned int
|
|
|
|
rb_random_int32(VALUE obj)
|
|
|
|
{
|
|
|
|
return random_int32(obj, try_get_rnd(obj));
|
|
|
|
}
|
|
|
|
|
|
|
|
static double
|
|
|
|
random_real(VALUE obj, rb_random_t *rnd, int excl)
|
|
|
|
{
|
|
|
|
uint32_t a = random_int32(obj, rnd);
|
|
|
|
uint32_t b = random_int32(obj, rnd);
|
|
|
|
if (excl) {
|
|
|
|
return int_pair_to_real_exclusive(a, b);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return int_pair_to_real_inclusive(a, b);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-17 20:16:25 -04:00
|
|
|
double
|
|
|
|
rb_random_real(VALUE obj)
|
|
|
|
{
|
2010-08-23 18:07:39 -04:00
|
|
|
rb_random_t *rnd = try_get_rnd(obj);
|
|
|
|
if (!rnd) {
|
|
|
|
VALUE v = rb_funcall2(obj, id_rand, 0, 0);
|
2010-08-25 18:30:03 -04:00
|
|
|
double d = NUM2DBL(v);
|
2012-07-20 04:20:56 -04:00
|
|
|
if (d < 0.0) {
|
|
|
|
rb_raise(rb_eRangeError, "random number too small %g", d);
|
|
|
|
}
|
|
|
|
else if (d >= 1.0) {
|
2010-08-25 18:30:03 -04:00
|
|
|
rb_raise(rb_eRangeError, "random number too big %g", d);
|
|
|
|
}
|
|
|
|
return d;
|
2010-08-23 18:07:39 -04:00
|
|
|
}
|
2009-07-17 20:16:25 -04:00
|
|
|
return genrand_real(&rnd->mt);
|
|
|
|
}
|
|
|
|
|
2013-02-24 01:33:49 -05:00
|
|
|
static inline VALUE
|
|
|
|
ulong_to_num_plus_1(unsigned long n)
|
|
|
|
{
|
|
|
|
#if HAVE_LONG_LONG
|
|
|
|
return ULL2NUM((LONG_LONG)n+1);
|
|
|
|
#else
|
|
|
|
if (n >= ULONG_MAX) {
|
|
|
|
return rb_big_plus(ULONG2NUM(n), INT2FIX(1));
|
|
|
|
}
|
|
|
|
return ULONG2NUM(n+1);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-02-13 22:20:04 -05:00
|
|
|
static unsigned long
|
|
|
|
random_ulong_limited(VALUE obj, rb_random_t *rnd, unsigned long limit)
|
2012-10-09 04:59:03 -04:00
|
|
|
{
|
|
|
|
if (!rnd) {
|
2013-02-21 22:46:47 -05:00
|
|
|
extern int rb_num_negative_p(VALUE);
|
2013-02-24 01:33:49 -05:00
|
|
|
VALUE lim = ulong_to_num_plus_1(limit);
|
2013-08-13 09:13:02 -04:00
|
|
|
VALUE v = rb_to_int(rb_funcall2(obj, id_rand, 1, &lim));
|
2012-10-09 04:59:03 -04:00
|
|
|
unsigned long r = NUM2ULONG(v);
|
2013-02-21 22:46:47 -05:00
|
|
|
if (rb_num_negative_p(v)) {
|
|
|
|
rb_raise(rb_eRangeError, "random number too small %ld", r);
|
|
|
|
}
|
2012-10-09 04:59:03 -04:00
|
|
|
if (r > limit) {
|
|
|
|
rb_raise(rb_eRangeError, "random number too big %ld", r);
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
return limited_rand(&rnd->mt, limit);
|
|
|
|
}
|
|
|
|
|
2015-02-13 22:20:04 -05:00
|
|
|
static VALUE
|
|
|
|
random_ulong_limited_big(VALUE obj, rb_random_t *rnd, VALUE vmax)
|
|
|
|
{
|
|
|
|
if (!rnd) {
|
|
|
|
extern int rb_num_negative_p(VALUE);
|
|
|
|
VALUE lim = rb_big_plus(vmax, INT2FIX(1));
|
|
|
|
VALUE v = rb_to_int(rb_funcall2(obj, id_rand, 1, &lim));
|
|
|
|
if (rb_num_negative_p(v)) {
|
|
|
|
rb_raise(rb_eRangeError, "random number too small %"PRIsVALUE, v);
|
|
|
|
}
|
|
|
|
if (FIX2LONG(rb_big_cmp(vmax, v)) < 0) {
|
|
|
|
rb_raise(rb_eRangeError, "random number too big %"PRIsVALUE, v);
|
|
|
|
}
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
return limited_big_rand(&rnd->mt, vmax);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long
|
|
|
|
rb_random_ulong_limited(VALUE obj, unsigned long limit)
|
|
|
|
{
|
|
|
|
return random_ulong_limited(obj, try_get_rnd(obj), limit);
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE genrand_bytes(rb_random_t *rnd, long n);
|
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
/*
|
2011-06-27 11:42:37 -04:00
|
|
|
* call-seq: prng.bytes(size) -> a_string
|
2009-07-16 02:00:35 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Returns a random binary string containing +size+ bytes.
|
|
|
|
*
|
|
|
|
* random_string = Random.new.bytes(10) # => "\xD7:R\xAB?\x83\xCE\xFAkO"
|
|
|
|
* random_string.size # => 10
|
2009-07-16 02:00:35 -04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
random_bytes(VALUE obj, VALUE len)
|
2009-07-17 20:16:25 -04:00
|
|
|
{
|
2015-02-13 22:20:04 -05:00
|
|
|
return genrand_bytes(get_rnd(obj), NUM2LONG(rb_to_int(len)));
|
2009-07-17 20:16:25 -04:00
|
|
|
}
|
|
|
|
|
2015-02-13 22:20:04 -05:00
|
|
|
static VALUE
|
|
|
|
genrand_bytes(rb_random_t *rnd, long n)
|
2009-07-16 02:00:35 -04:00
|
|
|
{
|
2010-08-23 18:07:39 -04:00
|
|
|
VALUE bytes;
|
|
|
|
char *ptr;
|
2009-07-16 02:00:35 -04:00
|
|
|
unsigned int r, i;
|
|
|
|
|
2010-08-23 18:07:39 -04:00
|
|
|
bytes = rb_str_new(0, n);
|
|
|
|
ptr = RSTRING_PTR(bytes);
|
2009-07-16 02:00:35 -04:00
|
|
|
for (; n >= SIZEOF_INT32; n -= SIZEOF_INT32) {
|
|
|
|
r = genrand_int32(&rnd->mt);
|
|
|
|
i = SIZEOF_INT32;
|
|
|
|
do {
|
|
|
|
*ptr++ = (char)r;
|
|
|
|
r >>= CHAR_BIT;
|
|
|
|
} while (--i);
|
|
|
|
}
|
|
|
|
if (n > 0) {
|
|
|
|
r = genrand_int32(&rnd->mt);
|
|
|
|
do {
|
|
|
|
*ptr++ = (char)r;
|
|
|
|
r >>= CHAR_BIT;
|
|
|
|
} while (--n);
|
|
|
|
}
|
|
|
|
return bytes;
|
|
|
|
}
|
|
|
|
|
2015-02-13 22:20:04 -05:00
|
|
|
VALUE
|
|
|
|
rb_random_bytes(VALUE obj, long n)
|
|
|
|
{
|
|
|
|
rb_random_t *rnd = try_get_rnd(obj);
|
|
|
|
if (!rnd) {
|
|
|
|
VALUE len = LONG2NUM(n);
|
|
|
|
return rb_funcall2(obj, id_bytes, 1, &len);
|
|
|
|
}
|
|
|
|
return genrand_bytes(rnd, n);
|
|
|
|
}
|
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
static VALUE
|
2010-11-19 22:04:59 -05:00
|
|
|
range_values(VALUE vmax, VALUE *begp, VALUE *endp, int *exclp)
|
2009-07-16 02:00:35 -04:00
|
|
|
{
|
2009-08-26 06:20:30 -04:00
|
|
|
VALUE end, r;
|
2009-07-16 02:00:35 -04:00
|
|
|
|
2009-08-26 06:20:30 -04:00
|
|
|
if (!rb_range_values(vmax, begp, &end, exclp)) return Qfalse;
|
2010-11-19 22:04:59 -05:00
|
|
|
if (endp) *endp = end;
|
2009-07-16 02:00:35 -04:00
|
|
|
if (!rb_respond_to(end, id_minus)) return Qfalse;
|
|
|
|
r = rb_funcall2(end, id_minus, 1, begp);
|
|
|
|
if (NIL_P(r)) return Qfalse;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2015-02-13 22:20:04 -05:00
|
|
|
rand_int(VALUE obj, rb_random_t *rnd, VALUE vmax, int restrictive)
|
2009-07-16 02:00:35 -04:00
|
|
|
{
|
2010-03-15 01:06:11 -04:00
|
|
|
/* mt must be initialized */
|
2009-08-02 01:20:51 -04:00
|
|
|
unsigned long r;
|
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
if (FIXNUM_P(vmax)) {
|
2015-02-13 22:20:04 -05:00
|
|
|
long max = FIX2LONG(vmax);
|
2009-07-16 02:00:35 -04:00
|
|
|
if (!max) return Qnil;
|
2009-08-26 06:20:30 -04:00
|
|
|
if (max < 0) {
|
|
|
|
if (restrictive) return Qnil;
|
|
|
|
max = -max;
|
|
|
|
}
|
2015-02-13 22:20:04 -05:00
|
|
|
r = random_ulong_limited(obj, rnd, (unsigned long)max - 1);
|
2009-07-16 02:00:35 -04:00
|
|
|
return ULONG2NUM(r);
|
|
|
|
}
|
|
|
|
else {
|
2009-08-02 01:20:51 -04:00
|
|
|
VALUE ret;
|
2009-07-16 02:00:35 -04:00
|
|
|
if (rb_bigzero_p(vmax)) return Qnil;
|
2014-02-15 16:17:34 -05:00
|
|
|
if (!BIGNUM_SIGN(vmax)) {
|
2009-08-26 06:20:30 -04:00
|
|
|
if (restrictive) return Qnil;
|
2013-06-11 18:33:01 -04:00
|
|
|
vmax = rb_big_uminus(vmax);
|
2009-07-16 02:00:35 -04:00
|
|
|
}
|
2009-08-02 01:20:51 -04:00
|
|
|
vmax = rb_big_minus(vmax, INT2FIX(1));
|
|
|
|
if (FIXNUM_P(vmax)) {
|
2015-02-13 22:20:04 -05:00
|
|
|
long max = FIX2LONG(vmax);
|
2009-08-02 01:20:51 -04:00
|
|
|
if (max == -1) return Qnil;
|
2015-02-13 22:20:04 -05:00
|
|
|
r = random_ulong_limited(obj, rnd, max);
|
2009-08-02 01:20:51 -04:00
|
|
|
return LONG2NUM(r);
|
2009-07-16 02:00:35 -04:00
|
|
|
}
|
2015-02-13 22:20:04 -05:00
|
|
|
ret = random_ulong_limited_big(obj, rnd, vmax);
|
2009-08-02 01:20:51 -04:00
|
|
|
RB_GC_GUARD(vmax);
|
|
|
|
return ret;
|
2009-07-16 02:00:35 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-13 22:20:04 -05:00
|
|
|
NORETURN(static void domain_error(void));
|
|
|
|
static void
|
|
|
|
domain_error(void)
|
|
|
|
{
|
|
|
|
VALUE error = INT2FIX(EDOM);
|
|
|
|
rb_exc_raise(rb_class_new_instance(1, &error, rb_eSystemCallError));
|
|
|
|
}
|
|
|
|
|
2015-02-13 23:11:26 -05:00
|
|
|
NORETURN(static void invalid_argument(VALUE));
|
|
|
|
static void
|
|
|
|
invalid_argument(VALUE arg0)
|
|
|
|
{
|
|
|
|
rb_raise(rb_eArgError, "invalid argument - %"PRIsVALUE, arg0);
|
|
|
|
}
|
|
|
|
|
2015-02-14 00:40:10 -05:00
|
|
|
static VALUE
|
|
|
|
check_random_number(VALUE v, const VALUE *argv)
|
|
|
|
{
|
|
|
|
switch (v) {
|
|
|
|
case Qfalse:
|
|
|
|
(void)NUM2LONG(argv[0]);
|
|
|
|
break;
|
|
|
|
case Qnil:
|
|
|
|
invalid_argument(argv[0]);
|
|
|
|
}
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2009-08-26 06:20:30 -04:00
|
|
|
static inline double
|
|
|
|
float_value(VALUE v)
|
|
|
|
{
|
|
|
|
double x = RFLOAT_VALUE(v);
|
|
|
|
if (isinf(x) || isnan(x)) {
|
2015-02-13 22:20:04 -05:00
|
|
|
domain_error();
|
2009-08-26 06:20:30 -04:00
|
|
|
}
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
2011-04-24 18:27:39 -04:00
|
|
|
static inline VALUE
|
2015-02-13 22:20:04 -05:00
|
|
|
rand_range(VALUE obj, rb_random_t* rnd, VALUE range)
|
2011-04-24 18:27:39 -04:00
|
|
|
{
|
|
|
|
VALUE beg = Qundef, end = Qundef, vmax, v;
|
|
|
|
int excl = 0;
|
|
|
|
|
|
|
|
if ((v = vmax = range_values(range, &beg, &end, &excl)) == Qfalse)
|
|
|
|
return Qfalse;
|
2011-09-29 07:07:45 -04:00
|
|
|
if (!RB_TYPE_P(vmax, T_FLOAT) && (v = rb_check_to_integer(vmax, "to_int"), !NIL_P(v))) {
|
2011-04-24 18:27:39 -04:00
|
|
|
long max;
|
|
|
|
vmax = v;
|
|
|
|
v = Qnil;
|
|
|
|
if (FIXNUM_P(vmax)) {
|
|
|
|
fixnum:
|
|
|
|
if ((max = FIX2LONG(vmax) - excl) >= 0) {
|
2015-02-13 22:20:04 -05:00
|
|
|
unsigned long r = random_ulong_limited(obj, rnd, (unsigned long)max);
|
2011-04-24 18:27:39 -04:00
|
|
|
v = ULONG2NUM(r);
|
|
|
|
}
|
|
|
|
}
|
2014-02-15 16:17:34 -05:00
|
|
|
else if (BUILTIN_TYPE(vmax) == T_BIGNUM && BIGNUM_SIGN(vmax) && !rb_bigzero_p(vmax)) {
|
2011-04-24 18:27:39 -04:00
|
|
|
vmax = excl ? rb_big_minus(vmax, INT2FIX(1)) : rb_big_norm(vmax);
|
|
|
|
if (FIXNUM_P(vmax)) {
|
|
|
|
excl = 0;
|
|
|
|
goto fixnum;
|
|
|
|
}
|
2015-02-13 22:20:04 -05:00
|
|
|
v = random_ulong_limited_big(obj, rnd, vmax);
|
2011-04-24 18:27:39 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (v = rb_check_to_float(vmax), !NIL_P(v)) {
|
|
|
|
int scale = 1;
|
|
|
|
double max = RFLOAT_VALUE(v), mid = 0.5, r;
|
|
|
|
if (isinf(max)) {
|
|
|
|
double min = float_value(rb_to_float(beg)) / 2.0;
|
|
|
|
max = float_value(rb_to_float(end)) / 2.0;
|
|
|
|
scale = 2;
|
|
|
|
mid = max + min;
|
|
|
|
max -= min;
|
|
|
|
}
|
2015-02-13 22:20:04 -05:00
|
|
|
else if (isnan(max)) {
|
|
|
|
domain_error();
|
2011-04-24 18:27:39 -04:00
|
|
|
}
|
|
|
|
v = Qnil;
|
|
|
|
if (max > 0.0) {
|
2015-02-13 22:20:04 -05:00
|
|
|
r = random_real(obj, rnd, excl);
|
2011-04-24 18:27:39 -04:00
|
|
|
if (scale > 1) {
|
|
|
|
return rb_float_new(+(+(+(r - 0.5) * max) * scale) + mid);
|
|
|
|
}
|
|
|
|
v = rb_float_new(r * max);
|
|
|
|
}
|
|
|
|
else if (max == 0.0 && !excl) {
|
|
|
|
v = rb_float_new(0.0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (FIXNUM_P(beg) && FIXNUM_P(v)) {
|
|
|
|
long x = FIX2LONG(beg) + FIX2LONG(v);
|
|
|
|
return LONG2NUM(x);
|
|
|
|
}
|
|
|
|
switch (TYPE(v)) {
|
|
|
|
case T_NIL:
|
|
|
|
break;
|
|
|
|
case T_BIGNUM:
|
|
|
|
return rb_big_plus(v, beg);
|
|
|
|
case T_FLOAT: {
|
|
|
|
VALUE f = rb_check_to_float(beg);
|
|
|
|
if (!NIL_P(f)) {
|
2012-08-23 03:22:40 -04:00
|
|
|
return DBL2NUM(RFLOAT_VALUE(v) + RFLOAT_VALUE(f));
|
2011-04-24 18:27:39 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return rb_funcall2(beg, id_plus, 1, &v);
|
|
|
|
}
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2015-02-13 22:20:04 -05:00
|
|
|
static VALUE rand_random(int argc, VALUE *argv, VALUE obj, rb_random_t *rnd);
|
2012-03-11 18:04:13 -04:00
|
|
|
|
2009-07-16 02:00:35 -04:00
|
|
|
/*
|
2009-08-26 06:20:30 -04:00
|
|
|
* call-seq:
|
2011-10-05 19:54:33 -04:00
|
|
|
* prng.rand -> float
|
|
|
|
* prng.rand(max) -> number
|
2009-07-16 02:00:35 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* When +max+ is an Integer, +rand+ returns a random integer greater than
|
|
|
|
* or equal to zero and less than +max+. Unlike Kernel.rand, when +max+
|
|
|
|
* is a negative integer or zero, +rand+ raises an ArgumentError.
|
2009-07-16 02:00:35 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* prng = Random.new
|
|
|
|
* prng.rand(100) # => 42
|
2009-08-26 06:20:30 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* When +max+ is a Float, +rand+ returns a random floating point number
|
|
|
|
* between 0.0 and +max+, including 0.0 and excluding +max+.
|
2009-07-16 02:00:35 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* prng.rand(1.5) # => 1.4600282860034115
|
2009-07-16 02:00:35 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* When +max+ is a Range, +rand+ returns a random number where
|
|
|
|
* range.member?(number) == true.
|
|
|
|
*
|
|
|
|
* prng.rand(5..9) # => one of [5, 6, 7, 8, 9]
|
|
|
|
* prng.rand(5...9) # => one of [5, 6, 7, 8]
|
|
|
|
* prng.rand(5.0..9.0) # => between 5.0 and 9.0, including 9.0
|
|
|
|
* prng.rand(5.0...9.0) # => between 5.0 and 9.0, excluding 9.0
|
|
|
|
*
|
|
|
|
* Both the beginning and ending values of the range must respond to subtract
|
|
|
|
* (<tt>-</tt>) and add (<tt>+</tt>)methods, or rand will raise an
|
|
|
|
* ArgumentError.
|
2009-07-16 02:00:35 -04:00
|
|
|
*/
|
|
|
|
static VALUE
|
2009-08-26 06:20:30 -04:00
|
|
|
random_rand(int argc, VALUE *argv, VALUE obj)
|
2009-07-16 02:00:35 -04:00
|
|
|
{
|
2015-02-13 23:11:26 -05:00
|
|
|
VALUE v = rand_random(argc, argv, obj, get_rnd(obj));
|
2015-02-14 00:40:10 -05:00
|
|
|
check_random_number(v, argv);
|
2015-02-13 23:11:26 -05:00
|
|
|
return v;
|
2012-03-11 18:04:13 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static VALUE
|
2015-02-13 22:20:04 -05:00
|
|
|
rand_random(int argc, VALUE *argv, VALUE obj, rb_random_t *rnd)
|
2012-03-11 18:04:13 -04:00
|
|
|
{
|
2011-04-25 03:56:42 -04:00
|
|
|
VALUE vmax, v;
|
2015-02-13 22:20:04 -05:00
|
|
|
double max = 0.0;
|
2009-07-16 02:00:35 -04:00
|
|
|
|
2009-08-26 06:20:30 -04:00
|
|
|
if (argc == 0) {
|
2015-02-13 22:20:04 -05:00
|
|
|
goto float_rand;
|
2009-08-26 06:20:30 -04:00
|
|
|
}
|
2012-03-14 17:10:34 -04:00
|
|
|
else {
|
|
|
|
rb_check_arity(argc, 0, 1);
|
2009-08-26 06:20:30 -04:00
|
|
|
}
|
|
|
|
vmax = argv[0];
|
|
|
|
if (NIL_P(vmax)) {
|
2010-04-02 21:51:26 -04:00
|
|
|
v = Qnil;
|
2009-08-26 06:20:30 -04:00
|
|
|
}
|
2011-09-29 07:07:45 -04:00
|
|
|
else if (!RB_TYPE_P(vmax, T_FLOAT) && (v = rb_check_to_integer(vmax, "to_int"), !NIL_P(v))) {
|
2015-02-13 22:20:04 -05:00
|
|
|
v = rand_int(obj, rnd, v, 1);
|
2009-08-26 06:20:30 -04:00
|
|
|
}
|
|
|
|
else if (v = rb_check_to_float(vmax), !NIL_P(v)) {
|
2015-02-13 22:20:04 -05:00
|
|
|
max = float_value(v);
|
|
|
|
if (max < 0.0) {
|
2009-08-26 06:20:30 -04:00
|
|
|
v = Qnil;
|
2015-02-13 22:20:04 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
uint32_t a, b;
|
|
|
|
double r;
|
|
|
|
|
|
|
|
float_rand:
|
|
|
|
a = random_int32(obj, rnd);
|
|
|
|
b = random_int32(obj, rnd);
|
|
|
|
r = int_pair_to_real_exclusive(a, b);
|
|
|
|
if (max > 0.0) r *= max;;
|
|
|
|
v = rb_float_new(r);
|
|
|
|
}
|
2009-08-26 06:20:30 -04:00
|
|
|
}
|
2015-02-13 22:20:04 -05:00
|
|
|
else if ((v = rand_range(obj, rnd, vmax)) != Qfalse) {
|
2011-04-24 18:27:39 -04:00
|
|
|
/* nothing to do */
|
2009-07-16 02:00:35 -04:00
|
|
|
}
|
2009-08-26 06:20:30 -04:00
|
|
|
else {
|
2015-02-14 00:40:10 -05:00
|
|
|
return Qfalse;
|
2009-08-26 06:20:30 -04:00
|
|
|
}
|
2011-04-24 18:27:39 -04:00
|
|
|
return v;
|
2009-07-16 02:00:35 -04:00
|
|
|
}
|
|
|
|
|
2015-02-13 22:20:04 -05:00
|
|
|
static VALUE
|
|
|
|
rand_random_number(int argc, VALUE *argv, VALUE obj)
|
|
|
|
{
|
2015-02-13 23:11:26 -05:00
|
|
|
rb_random_t *rnd = try_get_rnd(obj);
|
|
|
|
VALUE v = rand_random(argc, argv, obj, rnd);
|
|
|
|
if (NIL_P(v)) v = rand_random(0, 0, obj, rnd);
|
2015-02-14 00:40:10 -05:00
|
|
|
else if (!v) invalid_argument(argv[0]);
|
2015-02-13 23:11:26 -05:00
|
|
|
return v;
|
2015-02-13 22:20:04 -05:00
|
|
|
}
|
|
|
|
|
2009-07-17 00:56:12 -04:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2011-10-05 19:54:33 -04:00
|
|
|
* prng1 == prng2 -> true or false
|
|
|
|
*
|
|
|
|
* Returns true if the two generators have the same internal state, otherwise
|
|
|
|
* false. Equivalent generators will return the same sequence of
|
|
|
|
* pseudo-random numbers. Two generators will generally have the same state
|
|
|
|
* only if they were initialized with the same seed
|
2009-07-17 00:56:12 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Random.new == Random.new # => false
|
|
|
|
* Random.new(1234) == Random.new(1234) # => true
|
|
|
|
*
|
|
|
|
* and have the same invocation history.
|
|
|
|
*
|
|
|
|
* prng1 = Random.new(1234)
|
|
|
|
* prng2 = Random.new(1234)
|
|
|
|
* prng1 == prng2 # => true
|
|
|
|
*
|
|
|
|
* prng1.rand # => 0.1915194503788923
|
|
|
|
* prng1 == prng2 # => false
|
|
|
|
*
|
|
|
|
* prng2.rand # => 0.1915194503788923
|
|
|
|
* prng1 == prng2 # => true
|
2009-07-17 00:56:12 -04:00
|
|
|
*/
|
|
|
|
static VALUE
|
|
|
|
random_equal(VALUE self, VALUE other)
|
|
|
|
{
|
|
|
|
rb_random_t *r1, *r2;
|
|
|
|
if (rb_obj_class(self) != rb_obj_class(other)) return Qfalse;
|
|
|
|
r1 = get_rnd(self);
|
|
|
|
r2 = get_rnd(other);
|
|
|
|
if (!RTEST(rb_funcall2(r1->seed, rb_intern("=="), 1, &r2->seed))) return Qfalse;
|
|
|
|
if (memcmp(r1->mt.state, r2->mt.state, sizeof(r1->mt.state))) return Qfalse;
|
|
|
|
if ((r1->mt.next - r1->mt.state) != (r2->mt.next - r2->mt.state)) return Qfalse;
|
|
|
|
if (r1->mt.left != r2->mt.left) return Qfalse;
|
|
|
|
return Qtrue;
|
|
|
|
}
|
|
|
|
|
2003-12-28 15:47:56 -05:00
|
|
|
/*
|
2011-10-05 19:54:33 -04:00
|
|
|
* call-seq:
|
|
|
|
* rand(max=0) -> number
|
|
|
|
*
|
|
|
|
* If called without an argument, or if <tt>max.to_i.abs == 0</tt>, rand
|
|
|
|
* returns a pseudo-random floating point number between 0.0 and 1.0,
|
|
|
|
* including 0.0 and excluding 1.0.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* rand #=> 0.2725926052826416
|
2011-04-24 19:25:11 -04:00
|
|
|
*
|
2013-02-02 20:25:57 -05:00
|
|
|
* When +max.abs+ is greater than or equal to 1, +rand+ returns a pseudo-random
|
|
|
|
* integer greater than or equal to 0 and less than +max.to_i.abs+.
|
2011-04-24 19:25:11 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* rand(100) #=> 12
|
2011-04-24 19:25:11 -04:00
|
|
|
*
|
2013-02-02 20:25:57 -05:00
|
|
|
* When +max+ is a Range, +rand+ returns a random number where
|
|
|
|
* range.member?(number) == true.
|
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Negative or floating point values for +max+ are allowed, but may give
|
|
|
|
* surprising results.
|
2011-04-24 19:25:11 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* rand(-100) # => 87
|
|
|
|
* rand(-0.5) # => 0.8130921818028143
|
|
|
|
* rand(1.9) # equivalent to rand(1), which is always 0
|
2011-04-24 19:25:11 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Kernel.srand may be used to ensure that sequences of random numbers are
|
|
|
|
* reproducible between different runs of a program.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* See also Random.rand.
|
2003-12-28 15:47:56 -05:00
|
|
|
*/
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
static VALUE
|
* array.c: moved to ANSI function style from K&R function style.
(used protoize on windows, so still K&R remains on #ifdef part of
other platforms. And `foo _((boo))' stuff is still there)
[ruby-dev:26975]
* bignum.c, class.c, compar.c, dir.c, dln.c, dmyext.c, enum.c,
enumerator.c, error.c, eval.c, file.c, gc.c, hash.c, inits.c,
io.c, main.c, marshal.c, math.c, numeric.c, object.c, pack.c,
prec.c, process.c, random.c, range.c, re.c, regcomp.c, regenc.c,
regerror.c, regexec.c, regparse.c, regparse.h, ruby.c, signal.c,
sprintf.c, st.c, string.c, struct.c, time.c, util.h, variable.c,
version.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9126 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2005-09-12 06:44:21 -04:00
|
|
|
rb_f_rand(int argc, VALUE *argv, VALUE obj)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2011-04-24 18:27:39 -04:00
|
|
|
VALUE v, vmax, r;
|
2015-02-13 22:20:04 -05:00
|
|
|
rb_random_t *rnd = rand_start(&default_rand);
|
1998-01-16 07:13:05 -05:00
|
|
|
|
2008-12-29 08:29:12 -05:00
|
|
|
if (argc == 0) goto zero_arg;
|
|
|
|
rb_scan_args(argc, argv, "01", &vmax);
|
|
|
|
if (NIL_P(vmax)) goto zero_arg;
|
2015-02-13 22:20:04 -05:00
|
|
|
if ((v = rand_range(Qnil, rnd, vmax)) != Qfalse) {
|
2011-04-24 18:27:39 -04:00
|
|
|
return v;
|
|
|
|
}
|
2008-12-29 08:29:12 -05:00
|
|
|
vmax = rb_to_int(vmax);
|
2015-02-13 22:20:04 -05:00
|
|
|
if (vmax == INT2FIX(0) || NIL_P(r = rand_int(Qnil, rnd, vmax, 0))) {
|
2008-12-29 08:29:12 -05:00
|
|
|
zero_arg:
|
2015-02-13 22:20:04 -05:00
|
|
|
return DBL2NUM(genrand_real(&rnd->mt));
|
1999-01-19 23:59:39 -05:00
|
|
|
}
|
2009-07-16 02:00:35 -04:00
|
|
|
return r;
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|
|
|
|
|
2011-04-24 19:25:11 -04:00
|
|
|
/*
|
2011-10-05 19:54:33 -04:00
|
|
|
* call-seq:
|
|
|
|
* Random.rand -> float
|
|
|
|
* Random.rand(max) -> number
|
2011-04-24 19:25:11 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Alias of Random::DEFAULT.rand.
|
2011-04-24 19:25:11 -04:00
|
|
|
*/
|
|
|
|
|
2011-04-24 18:27:39 -04:00
|
|
|
static VALUE
|
|
|
|
random_s_rand(int argc, VALUE *argv, VALUE obj)
|
|
|
|
{
|
2015-02-13 23:11:26 -05:00
|
|
|
VALUE v = rand_random(argc, argv, Qnil, rand_start(&default_rand));
|
2015-02-14 00:40:10 -05:00
|
|
|
check_random_number(v, argv);
|
2015-02-13 23:11:26 -05:00
|
|
|
return v;
|
2011-04-24 18:27:39 -04:00
|
|
|
}
|
|
|
|
|
2012-11-09 02:12:00 -05:00
|
|
|
#define SIP_HASH_STREAMING 0
|
|
|
|
#define sip_hash24 ruby_sip_hash24
|
2012-11-09 09:05:11 -05:00
|
|
|
#if !defined _WIN32 && !defined BYTE_ORDER
|
|
|
|
# ifdef WORDS_BIGENDIAN
|
|
|
|
# define BYTE_ORDER BIG_ENDIAN
|
|
|
|
# else
|
|
|
|
# define BYTE_ORDER LITTLE_ENDIAN
|
|
|
|
# endif
|
|
|
|
# ifndef LITTLE_ENDIAN
|
|
|
|
# define LITTLE_ENDIAN 1234
|
|
|
|
# endif
|
|
|
|
# ifndef BIG_ENDIAN
|
|
|
|
# define BIG_ENDIAN 4321
|
|
|
|
# endif
|
|
|
|
#endif
|
2012-11-09 02:12:00 -05:00
|
|
|
#include "siphash.c"
|
|
|
|
|
2009-11-03 18:50:51 -05:00
|
|
|
static st_index_t hashseed;
|
2012-11-09 02:12:00 -05:00
|
|
|
static union {
|
|
|
|
uint8_t key[16];
|
|
|
|
uint32_t u32[(16 * sizeof(uint8_t) - 1) / sizeof(uint32_t)];
|
|
|
|
} sipseed;
|
2009-11-03 18:50:51 -05:00
|
|
|
|
2010-03-15 05:33:39 -04:00
|
|
|
static VALUE
|
2013-06-08 03:40:03 -04:00
|
|
|
init_randomseed(struct MT *mt, uint32_t initial[DEFAULT_SEED_CNT])
|
2010-03-15 05:33:39 -04:00
|
|
|
{
|
|
|
|
VALUE seed;
|
|
|
|
fill_random_seed(initial);
|
|
|
|
init_by_array(mt, initial, DEFAULT_SEED_CNT);
|
|
|
|
seed = make_seed_value(initial);
|
|
|
|
memset(initial, 0, DEFAULT_SEED_LEN);
|
|
|
|
return seed;
|
|
|
|
}
|
|
|
|
|
2008-06-19 22:46:17 -04:00
|
|
|
void
|
|
|
|
Init_RandomSeed(void)
|
|
|
|
{
|
2010-03-15 05:33:39 -04:00
|
|
|
rb_random_t *r = &default_rand;
|
2013-06-08 03:40:03 -04:00
|
|
|
uint32_t initial[DEFAULT_SEED_CNT];
|
2010-03-15 05:33:39 -04:00
|
|
|
struct MT *mt = &r->mt;
|
|
|
|
VALUE seed = init_randomseed(mt, initial);
|
2012-11-09 02:12:00 -05:00
|
|
|
int i;
|
2009-11-03 18:50:51 -05:00
|
|
|
|
|
|
|
hashseed = genrand_int32(mt);
|
|
|
|
#if SIZEOF_ST_INDEX_T*CHAR_BIT > 4*8
|
|
|
|
hashseed <<= 32;
|
|
|
|
hashseed |= genrand_int32(mt);
|
|
|
|
#endif
|
|
|
|
#if SIZEOF_ST_INDEX_T*CHAR_BIT > 8*8
|
|
|
|
hashseed <<= 32;
|
|
|
|
hashseed |= genrand_int32(mt);
|
|
|
|
#endif
|
|
|
|
#if SIZEOF_ST_INDEX_T*CHAR_BIT > 12*8
|
|
|
|
hashseed <<= 32;
|
|
|
|
hashseed |= genrand_int32(mt);
|
|
|
|
#endif
|
2010-03-15 05:33:39 -04:00
|
|
|
|
2012-11-09 02:12:00 -05:00
|
|
|
for (i = 0; i < numberof(sipseed.u32); ++i)
|
|
|
|
sipseed.u32[i] = genrand_int32(mt);
|
|
|
|
|
2010-03-15 05:33:39 -04:00
|
|
|
rb_global_variable(&r->seed);
|
|
|
|
r->seed = seed;
|
2009-11-03 18:50:51 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
st_index_t
|
|
|
|
rb_hash_start(st_index_t h)
|
|
|
|
{
|
|
|
|
return st_hash_start(hashseed + h);
|
2008-06-19 22:46:17 -04:00
|
|
|
}
|
|
|
|
|
2012-11-09 02:12:00 -05:00
|
|
|
st_index_t
|
|
|
|
rb_memhash(const void *ptr, long len)
|
|
|
|
{
|
|
|
|
sip_uint64_t h = sip_hash24(sipseed.key, ptr, len);
|
|
|
|
#ifdef HAVE_UINT64_T
|
|
|
|
return (st_index_t)h;
|
|
|
|
#else
|
|
|
|
return (st_index_t)(h.u32[0] ^ h.u32[1]);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-06-19 23:29:19 -04:00
|
|
|
static void
|
2008-06-19 22:46:17 -04:00
|
|
|
Init_RandomSeed2(void)
|
|
|
|
{
|
2010-03-15 05:33:39 -04:00
|
|
|
VALUE seed = default_rand.seed;
|
|
|
|
|
|
|
|
if (RB_TYPE_P(seed, T_BIGNUM)) {
|
* include/ruby/ruby.h: constify RBasic::klass and add
RBASIC_CLASS(obj) macro which returns a class of `obj'.
This change is a part of RGENGC branch [ruby-trunk - Feature #8339].
* object.c: add new function rb_obj_reveal().
This function reveal interal (hidden) object by rb_obj_hide().
Note that do not change class before and after hiding.
Only permitted example is:
klass = RBASIC_CLASS(obj);
rb_obj_hide(obj);
....
rb_obj_reveal(obj, klass);
TODO: API design. rb_obj_reveal() should be replaced with others.
TODO: modify constified variables using cast may be harmful for
compiler's analysis and optimizaton.
Any idea to prohibt inserting RBasic::klass directly?
If rename RBasic::klass and force to use RBASIC_CLASS(obj),
then all codes such as `RBASIC(obj)->klass' will be
compilation error. Is it acceptable? (We have similar
experience at Ruby 1.9,
for example "RARRAY(ary)->ptr" to "RARRAY_PTR(ary)".
* internal.h: add some macros.
* RBASIC_CLEAR_CLASS(obj) clear RBasic::klass to make it internal
object.
* RBASIC_SET_CLASS(obj, cls) set RBasic::klass.
* RBASIC_SET_CLASS_RAW(obj, cls) same as RBASIC_SET_CLASS
without write barrier (planned).
* RCLASS_SET_SUPER(a, b) set super class of a.
* array.c, class.c, compile.c, encoding.c, enum.c, error.c, eval.c,
file.c, gc.c, hash.c, io.c, iseq.c, marshal.c, object.c,
parse.y, proc.c, process.c, random.c, ruby.c, sprintf.c,
string.c, thread.c, transcode.c, vm.c, vm_eval.c, win32/file.c:
Use above macros and functions to access RBasic::klass.
* ext/coverage/coverage.c, ext/readline/readline.c,
ext/socket/ancdata.c, ext/socket/init.c,
* ext/zlib/zlib.c: ditto.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@40691 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2013-05-13 06:49:11 -04:00
|
|
|
rb_obj_reveal(seed, rb_cBignum);
|
2010-03-15 05:33:39 -04:00
|
|
|
}
|
2008-06-19 22:46:17 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
rb_reset_random_seed(void)
|
|
|
|
{
|
2010-03-15 05:33:39 -04:00
|
|
|
rb_random_t *r = &default_rand;
|
|
|
|
uninit_genrand(&r->mt);
|
|
|
|
r->seed = INT2FIX(0);
|
2008-06-19 22:46:17 -04:00
|
|
|
}
|
|
|
|
|
2011-10-04 16:48:34 -04:00
|
|
|
/*
|
2011-10-05 19:54:33 -04:00
|
|
|
* Document-class: Random
|
|
|
|
*
|
|
|
|
* Random provides an interface to Ruby's pseudo-random number generator, or
|
|
|
|
* PRNG. The PRNG produces a deterministic sequence of bits which approximate
|
|
|
|
* true randomness. The sequence may be represented by integers, floats, or
|
|
|
|
* binary strings.
|
|
|
|
*
|
|
|
|
* The generator may be initialized with either a system-generated or
|
|
|
|
* user-supplied seed value by using Random.srand.
|
|
|
|
*
|
|
|
|
* The class method Random.rand provides the base functionality of Kernel.rand
|
|
|
|
* along with better handling of floating point values. These are both
|
|
|
|
* interfaces to Random::DEFAULT, the Ruby system PRNG.
|
|
|
|
*
|
|
|
|
* Random.new will create a new PRNG with a state independent of
|
|
|
|
* Random::DEFAULT, allowing multiple generators with different seed values or
|
|
|
|
* sequence positions to exist simultaneously. Random objects can be
|
|
|
|
* marshaled, allowing sequences to be saved and resumed.
|
2011-10-04 16:48:34 -04:00
|
|
|
*
|
2011-10-05 19:54:33 -04:00
|
|
|
* PRNGs are currently implemented as a modified Mersenne Twister with a period
|
|
|
|
* of 2**19937-1.
|
2011-10-04 16:48:34 -04:00
|
|
|
*/
|
|
|
|
|
1998-01-16 07:13:05 -05:00
|
|
|
void
|
2014-07-02 23:38:10 -04:00
|
|
|
InitVM_Random(void)
|
1998-01-16 07:13:05 -05:00
|
|
|
{
|
2008-06-19 22:46:17 -04:00
|
|
|
Init_RandomSeed2();
|
1999-01-19 23:59:39 -05:00
|
|
|
rb_define_global_function("srand", rb_f_srand, -1);
|
2000-07-04 00:17:26 -04:00
|
|
|
rb_define_global_function("rand", rb_f_rand, -1);
|
2009-07-16 02:00:35 -04:00
|
|
|
|
|
|
|
rb_cRandom = rb_define_class("Random", rb_cObject);
|
|
|
|
rb_define_alloc_func(rb_cRandom, random_alloc);
|
|
|
|
rb_define_method(rb_cRandom, "initialize", random_init, -1);
|
2009-08-26 06:20:30 -04:00
|
|
|
rb_define_method(rb_cRandom, "rand", random_rand, -1);
|
2009-07-16 02:00:35 -04:00
|
|
|
rb_define_method(rb_cRandom, "bytes", random_bytes, 1);
|
|
|
|
rb_define_method(rb_cRandom, "seed", random_get_seed, 0);
|
|
|
|
rb_define_method(rb_cRandom, "initialize_copy", random_copy, 1);
|
2012-12-03 05:10:14 -05:00
|
|
|
rb_define_private_method(rb_cRandom, "marshal_dump", random_dump, 0);
|
|
|
|
rb_define_private_method(rb_cRandom, "marshal_load", random_load, 1);
|
2009-07-22 19:52:20 -04:00
|
|
|
rb_define_private_method(rb_cRandom, "state", random_state, 0);
|
|
|
|
rb_define_private_method(rb_cRandom, "left", random_left, 0);
|
2009-07-17 00:56:12 -04:00
|
|
|
rb_define_method(rb_cRandom, "==", random_equal, 1);
|
2011-04-24 18:27:39 -04:00
|
|
|
|
2012-03-11 18:04:13 -04:00
|
|
|
{
|
|
|
|
VALUE rand_default = TypedData_Wrap_Struct(rb_cRandom, &random_data_type, &default_rand);
|
|
|
|
rb_gc_register_mark_object(rand_default);
|
2013-05-12 21:07:50 -04:00
|
|
|
/* Direct access to Ruby's Pseudorandom number generator (PRNG). */
|
2012-03-11 18:04:13 -04:00
|
|
|
rb_define_const(rb_cRandom, "DEFAULT", rand_default);
|
|
|
|
}
|
2009-07-16 02:00:35 -04:00
|
|
|
|
|
|
|
rb_define_singleton_method(rb_cRandom, "srand", rb_f_srand, -1);
|
2011-04-24 18:27:39 -04:00
|
|
|
rb_define_singleton_method(rb_cRandom, "rand", random_s_rand, -1);
|
2009-07-16 02:00:35 -04:00
|
|
|
rb_define_singleton_method(rb_cRandom, "new_seed", random_seed, 0);
|
2015-02-13 22:01:36 -05:00
|
|
|
rb_define_singleton_method(rb_cRandom, "raw_seed", random_raw_seed, 1);
|
2009-07-22 19:52:20 -04:00
|
|
|
rb_define_private_method(CLASS_OF(rb_cRandom), "state", random_s_state, 0);
|
|
|
|
rb_define_private_method(CLASS_OF(rb_cRandom), "left", random_s_left, 0);
|
2015-02-13 22:20:04 -05:00
|
|
|
|
|
|
|
{
|
|
|
|
VALUE m = rb_define_module_under(rb_cRandom, "Formatter");
|
|
|
|
rb_include_module(rb_cRandom, m);
|
|
|
|
rb_define_method(m, "random_number", rand_random_number, -1);
|
|
|
|
}
|
2014-07-02 23:38:10 -04:00
|
|
|
}
|
2010-08-23 18:07:39 -04:00
|
|
|
|
2014-07-02 23:38:10 -04:00
|
|
|
#undef rb_intern
|
|
|
|
void
|
|
|
|
Init_Random(void)
|
|
|
|
{
|
2010-08-23 18:07:39 -04:00
|
|
|
id_rand = rb_intern("rand");
|
|
|
|
id_bytes = rb_intern("bytes");
|
2014-07-02 23:38:10 -04:00
|
|
|
|
|
|
|
InitVM(Random);
|
1998-01-16 07:13:05 -05:00
|
|
|
}
|