def test_uniform_double(self):
rs = Generator(self.bit_generator(*self.data1['seed']))
assert_array_equal(uniform_from_dsfmt(self.data1['data']),
rs.random(1000))
rs = Generator(self.bit_generator(*self.data2['seed']))
assert_equal(uniform_from_dsfmt(self.data2['data']), rs.random(1000))
def test_reset_state_uint32(self):
rg = Generator(self.bit_generator(*self.seed))
rg.integers(0, 2**24, 120, dtype=np.uint32)
state = rg.bit_generator.state
n1 = rg.integers(0, 2**24, 10, dtype=np.uint32)
rg2 = Generator(self.bit_generator())
rg2.bit_generator.state = state
n2 = rg2.integers(0, 2**24, 10, dtype=np.uint32)
assert_array_equal(n1, n2)
def test_reset_state_float(self):
rg = Generator(self.bit_generator(*self.seed))
rg.random(dtype='float32')
state = rg.bit_generator.state
n1 = rg.random(size=10, dtype='float32')
rg2 = Generator(self.bit_generator())
rg2.bit_generator.state = state
n2 = rg2.random(size=10, dtype='float32')
assert_((n1 == n2).all())
def test_reset_state_float(self):
rg = Generator(self.bit_generator(*self.seed, mode="legacy"))
rg.random(dtype="float32")
state = rg.bit_generator.state
n1 = rg.random(size=10, dtype="float32")
rg2 = Generator(self.bit_generator(mode="sequence"))
rg2.bit_generator.state = state
n2 = rg2.random(size=10, dtype="float32")
assert_((n1 == n2).all())
def test_reset_state_gauss(self):
rg = Generator(self.bit_generator(*self.seed))
rg.standard_normal()
state = rg.bit_generator.state
n1 = rg.standard_normal(size=10)
rg2 = Generator(self.bit_generator())
rg2.bit_generator.state = state
n2 = rg2.standard_normal(size=10)
assert_array_equal(n1, n2)
def test_uniform_float(self):
rg = Generator(self.bit_generator(12345))
warmup(rg)
state = rg.bit_generator.state
r1 = rg.random(11, dtype=np.float32)
rg2 = Generator(self.bit_generator())
warmup(rg2)
rg2.bit_generator.state = state
r2 = rg2.random(11, dtype=np.float32)
assert_array_equal(r1, r2)
assert_equal(r1.dtype, np.float32)
assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
def test_normal_zig_floats(self):
rg = Generator(self.bit_generator())
warmup(rg)
state = rg.bit_generator.state
r1 = rg.standard_normal(11, dtype=np.float32)
rg2 = Generator(self.bit_generator())
warmup(rg2)
rg2.bit_generator.state = state
r2 = rg2.standard_normal(11, dtype=np.float32)
assert_array_equal(r1, r2)
assert_equal(r1.dtype, np.float32)
assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
def test_uniform_float(self):
rs = Generator(self.bit_generator(*self.data1['seed']))
vals = uniform32_from_uint(self.data1['data'], self.bits)
uniforms = rs.random(len(vals), dtype=np.float32)
assert_allclose(uniforms, vals)
assert_equal(uniforms.dtype, np.float32)
rs = Generator(self.bit_generator(*self.data2['seed']))
vals = uniform32_from_uint(self.data2['data'], self.bits)
uniforms = rs.random(len(vals), dtype=np.float32)
assert_allclose(uniforms, vals)
assert_equal(uniforms.dtype, np.float32)
def test_pickle(self):
import pickle
bit_generator = self.bit_generator(*self.data1['seed'])
bit_generator_pkl = pickle.dumps(bit_generator)
reloaded = pickle.loads(bit_generator_pkl)
orig_gen = Generator(bit_generator)
reloaded_gen = Generator(reloaded)
assert_array_equal(orig_gen.standard_normal(1000),
reloaded_gen.standard_normal(1000))
assert bit_generator is not reloaded
assert_state_equal(reloaded.state, bit_generator.state)
def test_gamma_floats(self):
rg = Generator(self.bit_generator(mode="sequence"))
warmup(rg)
state = rg.bit_generator.state
r1 = rg.standard_gamma(4.0, 11, dtype=np.float32)
rg2 = Generator(self.bit_generator(mode="legacy"))
warmup(rg2)
rg2.bit_generator.state = state
r2 = rg2.standard_gamma(4.0, 11, dtype=np.float32)
assert_array_equal(r1, r2)
assert_equal(r1.dtype, np.float32)
assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
def test_array(self):
s = Generator(MT19937(range(10), mode="legacy"))
assert_equal(s.integers(1000), 468)
s = np.random.RandomState(range(10))
assert_equal(s.randint(1000), 468)
s = Generator(MT19937(np.arange(10), mode="legacy"))
assert_equal(s.integers(1000), 468)
s = Generator(MT19937([0], mode="legacy"))
assert_equal(s.integers(1000), 973)
s = Generator(MT19937([4294967295], mode="legacy"))
assert_equal(s.integers(1000), 265)
def prob():
base = Generator(PCG64())
return ([0.5],
[0.5, (6, 5, 4, 3)],
[0.3],
[base.random((20, 2, 2))],
[base.random(3)])
def positive_param():
base = Generator(PCG64())
return [
base.chisquare(10),
base.chisquare(10, (5, 1, 3)),
base.chisquare(10, (6, 5, 4, 3)),
]
def integers():
dtypes = [
np.int8,
np.int16,
np.int32,
np.int64,
np.uint8,
np.uint16,
np.uint32,
np.uint64,
]
base = Generator(PCG64())
shape = tuple(base.integers(5, 10, size=2))
configs = []
for dt in dtypes:
s1 = np.ones(shape, dtype=dt)
s2 = np.ones((1, ) + shape, dtype=dt)
lo = np.iinfo(dt).min
hi = np.iinfo(dt).max
configs.extend([
(0, np.iinfo(dt).max, None, dt),
(lo, hi // 2, None, dt),
(lo, hi, (10, 2), dt),
(lo // 2 * s1, hi // 2 * s2, None, dt),
])
return configs
def test_seed_out_of_range_array(self):
# GH #82
rs = Generator(self.bit_generator(*self.data1['seed']))
assert_raises(ValueError, rs.bit_generator.seed, [2**(self.bits + 1)])
assert_raises(ValueError, rs.bit_generator.seed, [-1])
assert_raises(TypeError, rs.bit_generator.seed,
[2**(2 * self.bits + 1)])
def test_seed_out_of_range(self):
# GH #82
rs = Generator(self.bit_generator(*self.data1['seed']))
assert_raises(ValueError, rs.bit_generator.seed, 2**(self.bits + 1))
assert_raises(ValueError, rs.bit_generator.seed, -1)
assert_raises(ValueError, rs.bit_generator.seed,
2**(2 * self.bits + 1))
def int_prob():
base = Generator(PCG64())
return ([100, 0.5],
[100, 0.5, (6, 5, 4, 3)],
[base.integers(10, 100, size=(10, 2)), 0.3],
[10, base.random((20, 2, 2))],
[base.integers(10, 100, size=(5, 4, 3)), base.random(3)])
def test_scalar(self):
s = Generator(MT19937(0, mode="legacy"))
assert_equal(s.integers(1000), 684)
s1 = np.random.RandomState(0)
assert_equal(s1.randint(1000), 684)
assert_equal(s1.randint(1000), s.integers(1000))
s = Generator(MT19937(4294967295, mode="legacy"))
assert_equal(s.integers(1000), 419)
s1 = np.random.RandomState(4294967295)
assert_equal(s1.randint(1000), 419)
assert_equal(s1.randint(1000), s.integers(1000))
self.rg.bit_generator.seed(4294967295)
self.nprs.seed(4294967295)
self._is_state_common()
def setup_class(cls):
cls.bit_generator = PCG32
cls.advance = 2**48 + 2**21 + 2**16 + 2**5 + 1
cls.seed = [2**48 + 2**21 + 2**16 + 2**5 + 1, 2**21 + 2**16 + 2**5 + 1]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = None
cls._extra_setup()
def setup_class(cls):
cls.bit_generator = Xoshiro512StarStar
cls.advance = None
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
def setup_class(cls):
cls.bit_generator = DSFMT
cls.advance = None
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls._extra_setup()
cls.seed_vector_bits = 32
def test_init(self):
rg = Generator(self.bit_generator())
state = rg.bit_generator.state
rg.standard_normal(1)
rg.standard_normal(1)
rg.bit_generator.state = state
new_state = rg.bit_generator.state
assert_(comp_state(state, new_state))
def setup_class(cls):
cls.bit_generator = ThreeFry
cls.advance = 2**63 + 2**31 + 2**15 + 1
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
def setup_class(cls):
cls.np = numpy.random
cls.bit_generator = MT19937
cls.seed = [2**21 + 2**16 + 2**5 + 1]
cls.rg = Generator(cls.bit_generator(*cls.seed, mode="legacy"))
cls.rs = RandomState(cls.bit_generator(*cls.seed, mode="legacy"))
cls.nprs = cls.np.RandomState(*cls.seed)
cls.initial_state = cls.rg.bit_generator.state
cls._set_common_state()
def setup_class(cls):
# Overridden in test classes. Place holder to silence IDE noise
cls.bit_generator = Xoshiro256StarStar
cls.advance = None
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
def setup_class(cls):
cls.bit_generator = ThreeFry32
cls.advance = 2**63 + 2**31 + 2**15 + 1
cls.seed = [2**21 + 2**16 + 2**5 + 1]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
cls.seed_error = ValueError
def setup_class(cls):
cls.bit_generator = MT19937
cls.advance = None
cls.seed = [2**21 + 2**16 + 2**5 + 1]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 32
cls._extra_setup()
cls.seed_error = ValueError
def setup_class(cls):
super(TestHC128, cls).setup_class()
cls.bit_generator = HC128
cls.seed = [2**231 + 2**21 + 2**16 + 2**5 + 1]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
cls.seed_error = ValueError
def setup_class(cls):
super(TestXorshift1024, cls).setup_class()
cls.bit_generator = Xorshift1024
cls.advance = None
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
def setup_class(cls):
super(TestJSF32, cls).setup_class()
cls.bit_generator = partial(JSF, size=32, seed_size=3)
cls.advance = None
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
