ENH: use SeedSequence to generate entropy for seeding

1 files changed, 52 insertions, 105 deletions

diff --git a/numpy/random/tests/test_direct.py b/numpy/random/tests/test_direct.py
index 0bdfabded..70a731861 100644
--- a/numpy/random/tests/test_direct.py
+++ b/numpy/random/tests/test_direct.py
@@ -6,7 +6,13 @@ from numpy.testing import (assert_equal, assert_allclose, assert_array_equal,
                            assert_raises)
 import pytest
 
+<<<<<<< HEAD
 from numpy.random import (Generator, MT19937, PCG64, Philox, RandomState)
+=======
+from numpy.random import (Generator, MT19937, PCG64,
+                          Philox, Xoshiro256, Xoshiro512, RandomState,
+                          SeedSequence)
+>>>>>>> ENH: use SeedSequence to generate entropy for seeding
 from numpy.random.common import interface
 
 try:
@@ -116,6 +122,24 @@ def gauss_from_uint(x, n, bits):
 
     return gauss[:n]
 
+def test_seedsequence():
+    from numpy.random.bit_generator import (ISeedSequence,
+                                            ISpawnableSeedSequence,
+                                            SeedlessSeedSequence)
+
+    s1 = SeedSequence(range(10), spawn_key=(1, 2), pool_size=6)
+    s1.spawn(10)
+    s2 = SeedSequence(**s1.state)
+    assert_equal(s1.state, s2.state)
+    assert_equal(s1.n_children_spawned, s2.n_children_spawned)
+
+    # The interfaces cannot be instantiated themselves.
+    assert_raises(TypeError, ISeedSequence)
+    assert_raises(TypeError, ISpawnableSeedSequence)
+    dummy = SeedlessSeedSequence()
+    assert_raises(NotImplementedError, dummy.generate_state, 10)
+    assert len(dummy.spawn(10)) == 10
+
 
 class Base(object):
     dtype = np.uint64
@@ -127,8 +151,8 @@ class Base(object):
         cls.bits = 64
         cls.dtype = np.uint64
         cls.seed_error_type = TypeError
-        cls.invalid_seed_types = []
-        cls.invalid_seed_values = []
+        cls.invalid_init_types = []
+        cls.invalid_init_values = []
 
     @classmethod
     def _read_csv(cls, filename):
@@ -199,39 +223,6 @@ class Base(object):
         assert_allclose(uniforms, vals)
         assert_equal(uniforms.dtype, np.float32)
 
-    def test_seed_float(self):
-        # GH #82
-        rs = Generator(self.bit_generator(*self.data1['seed']))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed, np.pi)
-        assert_raises(self.seed_error_type, rs.bit_generator.seed, -np.pi)
-
-    def test_seed_float_array(self):
-        # GH #82
-        rs = Generator(self.bit_generator(*self.data1['seed']))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed,
-                      np.array([np.pi]))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed,
-                      np.array([-np.pi]))
-        assert_raises(ValueError, rs.bit_generator.seed,
-                      np.array([np.pi, -np.pi]))
-        assert_raises(TypeError, rs.bit_generator.seed, np.array([0, np.pi]))
-        assert_raises(TypeError, rs.bit_generator.seed, [np.pi])
-        assert_raises(TypeError, rs.bit_generator.seed, [0, np.pi])
-
-    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 ** (2 * self.bits + 1))
-        assert_raises(ValueError, rs.bit_generator.seed, -1)
-
-    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 ** (2 * self.bits + 1)])
-        assert_raises(ValueError, rs.bit_generator.seed, [-1])
-
     def test_repr(self):
         rs = Generator(self.bit_generator(*self.data1['seed']))
         assert 'Generator' in repr(rs)
@@ -256,6 +247,10 @@ class Base(object):
         assert bit_generator is not reloaded
         assert_state_equal(reloaded_state, state)
 
+        ss = SeedSequence(100)
+        aa = pickle.loads(pickle.dumps(ss))
+        assert_equal(ss.state, aa.state)
+
     def test_invalid_state_type(self):
         bit_generator = self.bit_generator(*self.data1['seed'])
         with pytest.raises(TypeError):
@@ -268,17 +263,17 @@ class Base(object):
         with pytest.raises(ValueError):
             bit_generator.state = state
 
-    def test_invalid_seed_type(self):
-        bit_generator = self.bit_generator(*self.data1['seed'])
-        for st in self.invalid_seed_types:
+    def test_invalid_init_type(self):
+        bit_generator = self.bit_generator
+        for st in self.invalid_init_types:
             with pytest.raises(TypeError):
-                bit_generator.seed(*st)
+                bit_generator(*st)
 
-    def test_invalid_seed_values(self):
-        bit_generator = self.bit_generator(*self.data1['seed'])
-        for st in self.invalid_seed_values:
-            with pytest.raises(ValueError):
-                bit_generator.seed(*st)
+    def test_invalid_init_values(self):
+        bit_generator = self.bit_generator
+        for st in self.invalid_init_values:
+            with pytest.raises((ValueError, OverflowError)):
+                bit_generator(*st)
 
     def test_benchmark(self):
         bit_generator = self.bit_generator(*self.data1['seed'])
@@ -321,9 +316,8 @@ class TestPhilox(Base):
         cls.data2 = cls._read_csv(
             join(pwd, './data/philox-testset-2.csv'))
         cls.seed_error_type = TypeError
-        cls.invalid_seed_types = []
-        cls.invalid_seed_values = [(1, None, 1), (-1,), (2 ** 257 + 1,),
-                                   (None, None, 2 ** 257 + 1)]
+        cls.invalid_init_types = []
+        cls.invalid_init_values = [(1, None, 1), (-1,), (None, None, 2 ** 257 + 1)]
 
     def test_set_key(self):
         bit_generator = self.bit_generator(*self.data1['seed'])
@@ -341,30 +335,9 @@ class TestPCG64(Base):
         cls.dtype = np.uint64
         cls.data1 = cls._read_csv(join(pwd, './data/pcg64-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/pcg64-testset-2.csv'))
-        cls.seed_error_type = TypeError
-        cls.invalid_seed_types = [(np.array([1, 2]),), (3.2,),
-                                  (None, np.zeros(1))]
-        cls.invalid_seed_values = [(-1,), (2 ** 129 + 1,), (None, -1),
-                                   (None, 2 ** 129 + 1)]
-
-    def test_seed_float_array(self):
-        rs = Generator(self.bit_generator(*self.data1['seed']))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed,
-                      np.array([np.pi]))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed,
-                      np.array([-np.pi]))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed,
-                      np.array([np.pi, -np.pi]))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed,
-                      np.array([0, np.pi]))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed, [np.pi])
-        assert_raises(self.seed_error_type, rs.bit_generator.seed, [0, np.pi])
-
-    def test_seed_out_of_range_array(self):
-        rs = Generator(self.bit_generator(*self.data1['seed']))
-        assert_raises(self.seed_error_type, rs.bit_generator.seed,
-                      [2 ** (2 * self.bits + 1)])
-        assert_raises(self.seed_error_type, rs.bit_generator.seed, [-1])
+        cls.seed_error_type = (ValueError, TypeError)
+        cls.invalid_init_types = [(3.2,), ([None],), (1, None)]
+        cls.invalid_init_values = [(-1,)]
 
     def test_advance_symmetry(self):
         rs = Generator(self.bit_generator(*self.data1['seed']))
@@ -391,42 +364,16 @@ class TestMT19937(Base):
         cls.data1 = cls._read_csv(join(pwd, './data/mt19937-testset-1.csv'))
         cls.data2 = cls._read_csv(join(pwd, './data/mt19937-testset-2.csv'))
         cls.seed_error_type = ValueError
-        cls.invalid_seed_types = []
-        cls.invalid_seed_values = [(-1,), np.array([2 ** 33])]
-
-    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 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_float(self):
-        # GH #82
-        rs = Generator(self.bit_generator(*self.data1['seed']))
-        assert_raises(TypeError, rs.bit_generator.seed, np.pi)
-        assert_raises(TypeError, rs.bit_generator.seed, -np.pi)
+        cls.invalid_init_types = []
+        cls.invalid_init_values = [(-1,)]
 
     def test_seed_float_array(self):
-        # GH #82
-        rs = Generator(self.bit_generator(*self.data1['seed']))
-        bit_generator = rs.bit_generator
-        assert_raises(TypeError, bit_generator.seed, np.array([np.pi]))
-        assert_raises(TypeError, bit_generator.seed, np.array([-np.pi]))
-        assert_raises(TypeError, bit_generator.seed, np.array([np.pi, -np.pi]))
-        assert_raises(TypeError, bit_generator.seed, np.array([0, np.pi]))
-        assert_raises(TypeError, bit_generator.seed, [np.pi])
-        assert_raises(TypeError, bit_generator.seed, [0, np.pi])
+        assert_raises(TypeError, self.bit_generator, np.array([np.pi]))
+        assert_raises(TypeError, self.bit_generator, np.array([-np.pi]))
+        assert_raises(TypeError, self.bit_generator, np.array([np.pi, -np.pi]))
+        assert_raises(TypeError, self.bit_generator, np.array([0, np.pi]))
+        assert_raises(TypeError, self.bit_generator, [np.pi])
+        assert_raises(TypeError, self.bit_generator, [0, np.pi])
 
     def test_state_tuple(self):
         rs = Generator(self.bit_generator(*self.data1['seed']))