Random

class Random

父：ObjectIncluded模块：Random :: Formatter

Random为Ruby的伪随机数生成器或PRNG提供了一个接口。PRNG产生逼近真随机性的确定性位序列。该序列可以用整数，浮点数或二进制字符串表示。

通过使用:: srand可以使用系统生成的或用户提供的种子值初始化生成器。

类方法#rand提供了Kernel＃rand的基本功能以及更好的浮点值处理。这些都是Random :: DEFAULT（Ruby系统PRNG）的接口。

:: new将创建一个独立于Random :: DEFAULT的状态的新PRNG，允许具有不同种子值或序列位置的多个生成器同时存在。随机对象可以编组，允许序列被保存和恢复。

PRNG目前作为修改后的Mersenne Twister实施，期限为2 ** 19937-1。

常量

默认

公共类方法

new(seed = Random.new_seed) → prng Show source

创建一个新的PRNG seed用于设置初始状态。如果seed省略，则使用:: new_seed初始化生成器。

有关使用种子值的更多信息，请参阅：srand。

static VALUE
random_init(int argc, VALUE *argv, VALUE obj)
{
    VALUE vseed;
    rb_random_t *rnd = get_rnd(obj

    if (rb_check_arity(argc, 0, 1) == 0) {
        rb_check_frozen(obj
        vseed = random_seed(
    }
    else {
        vseed = argv[0];
        rb_check_copyable(obj, vseed
        vseed = rb_to_int(vseed
    }
    rnd->seed = rand_init(&rnd->mt, vseed
    return obj;
}

new_seed → integer Show source

返回任意的种子值。当没有将种子值指定为参数时，这由:: new使用。

Random.new_seed  #=> 115032730400174366788466674494640623225

static VALUE
random_seed(void)
{
    VALUE v;
    uint32_t buf[DEFAULT_SEED_CNT+1];
    fill_random_seed(buf, DEFAULT_SEED_CNT
    v = make_seed_value(buf, DEFAULT_SEED_CNT
    explicit_bzero(buf, DEFAULT_SEED_LEN
    return v;
}

rand → float Show source

rand(max) → number

Alias of Random::DEFAULT.rand.

static VALUE
random_s_rand(int argc, VALUE *argv, VALUE obj)
{
    VALUE v = rand_random(argc, argv, Qnil, rand_start(&default_rand)
    check_random_number(v, argv
    return v;
}

raw_seed(size) → string Show source

使用平台提供的功能返回原始种子字符串。

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
    if (n == 0) return buf;
    if (fill_random_bytes(RSTRING_PTR(buf), n, FALSE)) return Qnil;
    return buf;
}

srand(number = Random.new_seed) → old_seed Show source

种子系统伪随机数生成器Random :: DEFAULT与number。之前的种子值被返回。

如果number省略，则使用操作系统提供的熵源（如果可用）（Unix系统上的/ dev / urandom或Windows上的RSA加密提供程序）对发生器进行种子处理，然后再与时间，进程标识和一个序列号。

srand可用于确保程序的不同运行之间可重复的伪随机数序列。通过将种子设置为已知值，可以在测试过程中确定程序的确定性。

srand 1234               # => 268519324636777531569100071560086917274
[ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]
[ rand(10), rand(1000) ] # => [4, 664]
srand 1234               # => 1234
[ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]

static VALUE
rb_f_srand(int argc, VALUE *argv, VALUE obj)
{
    VALUE seed, old;
    rb_random_t *r = &default_rand;

    if (rb_check_arity(argc, 0, 1) == 0) {
        seed = random_seed(
    }
    else {
        seed = rb_to_int(argv[0]
    }
    old = r->seed;
    r->seed = rand_init(&r->mt, seed

    return old;
}

公共实例方法

prng1 == prng2 → true or false Show source

如果两个生成器具有相同的内部状态，则返回true，否则返回false。等效发生器将返回相同的伪随机数序列。只有在使用相同种子进行初始化时，两个生成器才会具有相同的状态

Random.new == Random.new             # => false
Random.new(1234) == Random.new(1234) # => true

并具有相同的调用历史记录。

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

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 (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 rb_equal(r1->seed, r2->seed
}

bytes(size) → a_string Show source

返回包含size字节的随机二进制字符串。

random_string = Random.new.bytes(10) # => "\xD7:R\xAB?\x83\xCE\xFAkO"
random_string.size                   # => 10

static VALUE
random_bytes(VALUE obj, VALUE len)
{
    return genrand_bytes(get_rnd(obj), NUM2LONG(rb_to_int(len))
}

rand → float Show source

rand(max) → number

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.

prng = Random.new
prng.rand(100)       # => 42

何时max是浮点数，rand返回0.0到max0.0 之间的随机浮点数，包括0.0和不包括max。

prng.rand(1.5)       # => 1.4600282860034115

何时max是Range，rand返回一个随机数，其中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

范围的开始和结束值都必须对subtract（-）和add（+）方法作出响应，否则rand将引发ArgumentError。

static VALUE
random_rand(int argc, VALUE *argv, VALUE obj)
{
    VALUE v = rand_random(argc, argv, obj, get_rnd(obj)
    check_random_number(v, argv
    return v;
}

seed → integer Show source

返回用于初始化生成器的种子值。这可以用来在稍后时间初始化具有相同状态的另一个发生器，使其产生相同的数字序列。

prng1 = Random.new(1234)
prng1.seed       #=> 1234
prng1.rand(100)  #=> 47

prng2 = Random.new(prng1.seed)
prng2.rand(100)  #=> 47

static VALUE
random_get_seed(VALUE obj)
{
    return get_rnd(obj)->seed;
}